Merge branch '2.0' into remove-milestones-mentions

bindings/core/src/method/client.rs

@@ -187,10 +187,9 @@ pub enum ClientMethod {
     },
     /// Return the information of committee members at the given epoch index. If epoch index is not provided, the
     /// current committee members are returned.
-    #[serde(rename_all = "camelCase")]
     GetCommittee {
         /// The epoch index to query.
-        epoch_index: Option<EpochIndex>,
+        epoch: Option<EpochIndex>,
     },
     /// Get issuance
     GetIssuance,

bindings/core/src/method_handler/client.rs

@@ -196,7 +196,7 @@ pub(crate) async fn call_client_method_internal(
             Response::Validators(client.get_validators(page_size, cursor).await?)
         }
         ClientMethod::GetValidator { account_id } => Response::Validator(client.get_validator(&account_id).await?),
-        ClientMethod::GetCommittee { epoch_index } => Response::Committee(client.get_committee(epoch_index).await?),
+        ClientMethod::GetCommittee { epoch } => Response::Committee(client.get_committee(epoch).await?),
         ClientMethod::GetIssuance => Response::Issuance(client.get_issuance().await?),
         ClientMethod::PostBlockRaw { block_bytes } => Response::BlockId(
             client

bindings/nodejs/lib/client/client.ts

@@ -252,13 +252,13 @@ export class Client {
     /**
      * Returns the information of committee members at the given epoch index. If epoch index is not provided, the
      * current committee members are returned.
-     * GET /api/core/v3/committee/?epochIndex
+     * GET /api/core/v3/committee/?epoch
      */
-    async getCommittee(epochIndex?: EpochIndex): Promise<CommitteeResponse> {
+    async getCommittee(epoch?: EpochIndex): Promise<CommitteeResponse> {
         const response = await this.methodHandler.callMethod({
             name: 'getCommittee',
             data: {
-                epochIndex,
+                epoch,
             },
         });
 

bindings/nodejs/lib/types/block/output/feature.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SlotIndex } from '../slot';
-import { Type } from 'class-transformer';
+import { Transform, Type } from 'class-transformer';
 import { Address, AddressDiscriminator } from '../address';
 import {
     BlockIssuerKey,
@@ -11,7 +11,7 @@ import {
 import { u256, u64 } from '../../utils/type-aliases';
 import { EpochIndex } from '../../block/slot';
 import { NativeToken } from '../../models/native-token';
-import { HexEncodedString } from '../../utils/hex-encoding';
+import { HexEncodedString, hexToBigInt } from '../../utils/hex-encoding';
 
 /**
  * Printable ASCII characters.
@@ -147,16 +147,18 @@ class NativeTokenFeature extends Feature {
     /**
      * Amount of native tokens of the given Token ID.
      */
+    @Transform((value) => hexToBigInt(value.value))
     readonly amount: u256;
 
     /**
      * Creates a new `NativeTokenFeature`.
-     * @param nativeToken The native token stored with the feature.
+     * @param id The identifier of the native token.
+     * @param amount The native token amount.
      */
-    constructor(nativeToken: NativeToken) {
+    constructor(id: HexEncodedString, amount: u256) {
         super(FeatureType.NativeToken);
-        this.id = nativeToken.id;
-        this.amount = nativeToken.amount;
+        this.id = id;
+        this.amount = amount;
     }
 
     /**

bindings/nodejs/lib/types/block/output/output.ts

@@ -153,6 +153,7 @@ class BasicOutput extends CommonOutput {
 
     /**
      * @param amount The amount of the output.
+     * @param mana The mana of the output.
      * @param unlockConditions The unlock conditions for the output.
      */
     constructor(amount: u64, mana: u64, unlockConditions: UnlockCondition[]) {

bindings/nodejs/lib/types/client/bridge/client.ts

@@ -104,7 +104,7 @@ export interface __GetValidatorMethod__ {
 export interface __GetCommitteeMethod__ {
     name: 'getCommittee';
     data: {
-        epochIndex?: EpochIndex;
+        epoch?: EpochIndex;
     };
 }
 

bindings/nodejs/lib/types/error.ts

@@ -30,8 +30,6 @@ export type ClientErrorName =
     | 'inputAddressNotFound'
     | 'invalidAmount'
     | 'invalidMnemonic'
-    | 'invalidTransactionLength'
-    | 'invalidSignedTransactionPayloadLength'
     | 'json'
     | 'missingParameter'
     | 'node'

bindings/python/iota_sdk/client/_node_core_api.py

@@ -144,13 +144,13 @@ def get_validator(self, account_id: HexStr) -> ValidatorResponse:
     # Committee routes.
 
     def get_committee(
-            self, epoch_index: Optional[EpochIndex] = None) -> CommitteeResponse:
+            self, epoch: Optional[EpochIndex] = None) -> CommitteeResponse:
         """Returns the information of committee members at the given epoch index. If epoch index is not provided, the
         current committee members are returned.
-        GET /api/core/v3/committee/?epochIndex
+        GET /api/core/v3/committee/?epoch
         """
         return CommitteeResponse.from_dict(self._call_method('getCommittee', {
-            'epochIndex': epoch_index
+            'epoch': epoch
         }))
 
     # Block routes.

sdk/examples/wallet/offline_signing/2_sign_transaction.rs

@@ -48,8 +48,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let signed_transaction = SignedTransactionPayload::new(prepared_transaction_data.transaction.clone(), unlocks)?;
 
-    signed_transaction.validate_length()?;
-
     let signed_transaction_data = SignedTransactionData {
         payload: signed_transaction,
         inputs_data: prepared_transaction_data.inputs_data,

sdk/src/client/api/block_builder/transaction.rs

@@ -3,30 +3,15 @@
 
 //! Transaction preparation and signing
 
-use packable::PackableExt;
-
 use crate::{
-    client::{
-        api::{PreparedTransactionData, SignedTransactionData},
-        ClientError,
-    },
+    client::api::{PreparedTransactionData, SignedTransactionData},
     types::block::{
         output::{Output, OutputId},
-        payload::signed_transaction::{SignedTransactionPayload, Transaction},
         protocol::ProtocolParameters,
         semantic::{SemanticValidationContext, TransactionFailureReason},
-        signature::Ed25519Signature,
-        Block, BlockId,
     },
 };
 
-const MAX_TX_LENGTH_FOR_BLOCK_WITH_8_PARENTS: usize = Block::LENGTH_MAX - Block::LENGTH_MIN - (7 * BlockId::LENGTH);
-// Length for unlocks with a single signature unlock (unlocks length + unlock type + signature type + public key +
-// signature)
-const SINGLE_UNLOCK_LENGTH: usize = 1 + 1 + Ed25519Signature::PUBLIC_KEY_LENGTH + Ed25519Signature::SIGNATURE_LENGTH;
-// Type + reference index
-const REFERENCE_ACCOUNT_NFT_UNLOCK_LENGTH: usize = 1 + 2;
-
 impl PreparedTransactionData {
     /// Verifies the semantic of a prepared transaction.
     pub fn verify_semantic(&self, protocol_parameters: &ProtocolParameters) -> Result<(), TransactionFailureReason> {
@@ -68,44 +53,3 @@ impl SignedTransactionData {
         context.validate()
     }
 }
-
-impl SignedTransactionPayload {
-    /// Verifies that the signed transaction payload doesn't exceed the block size limit with 8 parents.
-    pub fn validate_length(&self) -> Result<(), ClientError> {
-        let signed_transaction_payload_bytes = self.pack_to_vec();
-        if signed_transaction_payload_bytes.len() > MAX_TX_LENGTH_FOR_BLOCK_WITH_8_PARENTS {
-            return Err(ClientError::InvalidSignedTransactionPayloadLength {
-                length: signed_transaction_payload_bytes.len(),
-                max_length: MAX_TX_LENGTH_FOR_BLOCK_WITH_8_PARENTS,
-            });
-        }
-        Ok(())
-    }
-}
-
-impl Transaction {
-    /// Verifies that the transaction doesn't exceed the block size limit with 8 parents.
-    /// Assuming one signature unlock and otherwise reference/account/nft unlocks.
-    /// `validate_transaction_payload_length()` should later be used to check the length again with the correct
-    /// unlocks.
-    pub fn validate_length(&self) -> Result<(), ClientError> {
-        let transaction_bytes = self.pack_to_vec();
-
-        // Assuming there is only 1 signature unlock and the rest is reference/account/nft unlocks
-        let reference_account_nft_unlocks_amount = self.inputs().len() - 1;
-
-        // Max tx payload length - length for one signature unlock (there might be more unlocks, we check with them
-        // later again, when we built the transaction payload)
-        let max_length = MAX_TX_LENGTH_FOR_BLOCK_WITH_8_PARENTS
-            - SINGLE_UNLOCK_LENGTH
-            - (reference_account_nft_unlocks_amount * REFERENCE_ACCOUNT_NFT_UNLOCK_LENGTH);
-
-        if transaction_bytes.len() > max_length {
-            return Err(ClientError::InvalidTransactionLength {
-                length: transaction_bytes.len(),
-                max_length,
-            });
-        }
-        Ok(())
-    }
-}

sdk/src/client/api/block_builder/transaction_builder/error.rs

@@ -39,7 +39,9 @@ pub enum TransactionBuilderError {
         required: u64,
     },
     /// Insufficient mana provided.
-    #[error("insufficient mana: found {found}, required {required}")]
+    #[error(
+        "insufficient mana: found {found}, required {required}, slots remaining until enough mana {slots_remaining}"
+    )]
     InsufficientMana {
         /// The amount found.
         found: u64,

sdk/src/client/api/block_builder/transaction_builder/mod.rs

@@ -169,11 +169,7 @@ impl Client {
             transaction_builder = transaction_builder.disable_additional_input_selection();
         }
 
-        let prepared_transaction_data = transaction_builder.finish()?;
-
-        prepared_transaction_data.transaction.validate_length()?;
-
-        Ok(prepared_transaction_data)
+        Ok(transaction_builder.finish()?)
     }
 }
 

sdk/src/client/api/wait_for_tx_acceptance.rs

@@ -26,14 +26,20 @@ impl Client {
             .unwrap_or(DEFAULT_WAIT_FOR_TX_ACCEPTANCE_INTERVAL);
 
         for _ in 0..max_attempts.unwrap_or(DEFAULT_WAIT_FOR_TX_ACCEPTANCE_MAX_ATTEMPTS) {
-            let transaction_metadata = self.get_transaction_metadata(transaction_id).await?;
-
-            match transaction_metadata.transaction_state {
-                TransactionState::Accepted | TransactionState::Committed | TransactionState::Finalized => {
-                    return Ok(());
+            match self.get_transaction_metadata(transaction_id).await {
+                Ok(transaction_metadata) => {
+                    match transaction_metadata.transaction_state {
+                        TransactionState::Accepted | TransactionState::Committed | TransactionState::Finalized => {
+                            return Ok(());
+                        }
+                        TransactionState::Failed => {
+                            return Err(ClientError::TransactionAcceptance(transaction_id.to_string()));
+                        }
+                        TransactionState::Pending => {} // Just need to wait longer
+                    };
                 }
-                TransactionState::Failed => return Err(ClientError::TransactionAcceptance(transaction_id.to_string())),
-                TransactionState::Pending => {} // Just need to wait longer
+                Err(ClientError::Node(crate::client::node_api::error::Error::NotFound(_))) => {}
+                Err(e) => return Err(e),
             };
 
             #[cfg(target_family = "wasm")]

sdk/src/client/error.rs

@@ -67,22 +67,6 @@ pub enum ClientError {
     /// Invalid mnemonic error
     #[error("invalid mnemonic {0}")]
     InvalidMnemonic(String),
-    /// The transaction is too large
-    #[error("the transaction is too large. Its length is {length}, max length is {max_length}")]
-    InvalidTransactionLength {
-        /// The found length.
-        length: usize,
-        /// The max supported length.
-        max_length: usize,
-    },
-    /// The signed transaction payload is too large
-    #[error("the signed transaction payload is too large. Its length is {length}, max length is {max_length}")]
-    InvalidSignedTransactionPayloadLength {
-        /// The found length.
-        length: usize,
-        /// The max length.
-        max_length: usize,
-    },
     /// JSON error
     #[error("{0}")]
     Json(#[from] serde_json::Error),

sdk/src/client/node_api/core/routes.rs

@@ -37,7 +37,7 @@ use crate::{
 pub(crate) static INFO_PATH: &str = "api/core/v3/info";
 
 /// Contains the info and the url from the node (useful when multiple nodes are used)
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct NodeInfoResponse {
     /// The returned info
@@ -167,13 +167,13 @@ impl Client {
 
     /// Returns the information of committee members at the given epoch index. If epoch index is not provided, the
     /// current committee members are returned.
-    /// GET /api/core/v3/committee/?epochIndex
+    /// GET /api/core/v3/committee/?epoch
     pub async fn get_committee(
         &self,
-        epoch_index: impl Into<Option<EpochIndex>> + Send,
+        epoch: impl Into<Option<EpochIndex>> + Send,
     ) -> Result<CommitteeResponse, ClientError> {
         const PATH: &str = "api/core/v3/committee";
-        let query = query_tuples_to_query_string([epoch_index.into().map(|i| ("epochIndex", i.to_string()))]);
+        let query = query_tuples_to_query_string([epoch.into().map(|i| ("epoch", i.to_string()))]);
 
         self.get_request(PATH, query.as_deref(), false).await
     }

sdk/src/client/secret/mod.rs

@@ -666,8 +666,6 @@ where
     } = prepared_transaction_data;
     let tx_payload = SignedTransactionPayload::new(transaction, unlocks)?;
 
-    tx_payload.validate_length()?;
-
     let data = SignedTransactionData {
         payload: tx_payload,
         inputs_data,

sdk/src/types/api/core.rs

@@ -34,7 +34,7 @@ pub struct RoutesResponse {
 
 /// Response of GET /api/core/v3/info.
 /// General information about the node.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct InfoResponse {
     pub name: String,

sdk/src/types/block/payload/error.rs

@@ -42,8 +42,12 @@ pub enum PayloadError {
     InputCount(<InputCount as TryFrom<usize>>::Error),
     #[display(fmt = "invalid output count: {_0}")]
     OutputCount(<OutputCount as TryFrom<usize>>::Error),
+    #[display(fmt = "the signed transaction payload is too large. Its length is {length}, max length is {max_length}")]
+    SignedTransactionPayloadLength { length: usize, max_length: usize },
     #[display(fmt = "invalid transaction amount sum: {_0}")]
     TransactionAmountSum(u128),
+    #[display(fmt = "the transaction is too large. Its length is {length}, max length is {max_length}")]
+    TransactionLength { length: usize, max_length: usize },
     #[display(fmt = "duplicate output chain: {_0}")]
     DuplicateOutputChain(ChainId),
     #[display(fmt = "duplicate UTXO {_0} in inputs")]

sdk/src/types/block/payload/signed_transaction/mod.rs

@@ -8,6 +8,7 @@ mod transaction_id;
 
 use packable::{Packable, PackableExt};
 
+use self::transaction::MAX_TX_LENGTH_FOR_BLOCK_WITH_SINGLE_PARENT;
 pub(crate) use self::transaction::{InputCount, OutputCount};
 pub use self::{
     transaction::{Transaction, TransactionBuilder, TransactionCapabilities, TransactionCapabilityFlag},
@@ -69,9 +70,26 @@ fn verify_signed_transaction_payload(payload: &SignedTransactionPayload) -> Resu
         });
     }
 
+    payload.validate_length()?;
+
     Ok(())
 }
 
+impl SignedTransactionPayload {
+    /// Verifies that the transaction doesn't exceed the block size limit with 1 parent.
+    fn validate_length(&self) -> Result<(), PayloadError> {
+        let signed_transaction_payload_bytes = self.pack_to_vec();
+        if signed_transaction_payload_bytes.len() > MAX_TX_LENGTH_FOR_BLOCK_WITH_SINGLE_PARENT {
+            return Err(PayloadError::SignedTransactionPayloadLength {
+                length: signed_transaction_payload_bytes.len(),
+                max_length: MAX_TX_LENGTH_FOR_BLOCK_WITH_SINGLE_PARENT,
+            });
+        }
+
+        Ok(())
+    }
+}
+
 #[cfg(feature = "serde")]
 pub mod dto {
     use alloc::vec::Vec;