@bitgo-beta/sdk-coin-iota 1.0.0-alpha.43 → 1.0.0-alpha.44

package/dist/src/lib/transferTransaction.js

@@ -68,12 +68,33 @@ class TransferTransaction extends transaction_1.Transaction {
         this.paymentObjects = txData.paymentObjects;
         this.updateIsSimulateTx();
     }
+    /**
+     * Parses a transfer transaction from its broadcast format (base64 or raw bytes).
+     * Extracts recipients, amounts, and payment objects from the transaction data.
+     */
     parseFromBroadcastTx(tx) {
         const txData = transactions_1.Transaction.from(tx).getData();
-        if (txData.commands.filter((command) => !constants_1.TRANSFER_TRANSACTION_COMMANDS.includes(command.$kind)).length > 0) {
+        this.validateTransferCommands(txData);
+        super.parseFromBroadcastTx(tx);
+        const { inputObjects, amounts, receivers } = this.parseTransactionInputs(txData);
+        this.validateAmountsMatchReceivers(amounts, receivers);
+        this.assignParsedObjects(inputObjects);
+        this.assignRecipients(receivers, amounts);
+        this.updateIsSimulateTx();
+    }
+    /**
+     * Validates that the transaction only contains supported transfer commands.
+     */
+    validateTransferCommands(txData) {
+        const hasUnsupportedCommands = txData.commands.some((command) => !constants_1.TRANSFER_TRANSACTION_COMMANDS.includes(command.$kind));
+        if (hasUnsupportedCommands) {
             throw new sdk_core_1.InvalidTransactionError('Unsupported commands in the transaction');
         }
-        super.parseFromBroadcastTx(tx);
+    }
+    /**
+     * Parses transaction inputs to extract objects, amounts, and receiver addresses.
+     */
+    parseTransactionInputs(txData) {
         const inputObjects = [];
         const amounts = [];
         const receivers = [];
@@ -92,82 +113,229 @@ class TransferTransaction extends transaction_1.Transaction {
                 }
             }
         });
+        return { inputObjects, amounts, receivers };
+    }
+    /**
+     * Validates that the number of amounts matches the number of receivers.
+     */
+    validateAmountsMatchReceivers(amounts, receivers) {
         if (amounts.length !== receivers.length) {
-            throw new sdk_core_1.InvalidTransactionError('count of amounts does not match count of receivers');
-        }
-        this._paymentObjects = inputObjects;
-        this.recipients = [];
-        receivers.forEach((recipient, index) => {
-            this._recipients.push({
-                address: recipient,
-                amount: amounts[index],
-            });
-        });
-        this.updateIsSimulateTx();
+            throw new sdk_core_1.InvalidTransactionError('Count of amounts does not match count of receivers');
+        }
+    }
+    /**
+     * Assigns parsed input objects to either gas payment objects or payment objects.
+     * If no gas objects exist and sender pays own gas, objects become gas objects.
+     * Otherwise, they become payment objects.
+     */
+    assignParsedObjects(inputObjects) {
+        if (inputObjects.length === 0) {
+            return;
+        }
+        const noGasObjectsExist = !this.gasPaymentObjects || this.gasPaymentObjects.length === 0;
+        const senderPaysOwnGas = !this.gasSponsor || this.sender === this.gasSponsor;
+        if (noGasObjectsExist && senderPaysOwnGas) {
+            this.gasPaymentObjects = inputObjects;
+        }
+        else {
+            this._paymentObjects = inputObjects;
+        }
+    }
+    /**
+     * Creates and assigns recipients from parsed addresses and amounts.
+     */
+    assignRecipients(receivers, amounts) {
+        this._recipients = receivers.map((address, index) => ({
+            address,
+            amount: amounts[index],
+        }));
     }
     messageWithIntent(message) {
         return (0, cryptography_1.messageWithIntent)('TransactionData', message);
     }
+    /**
+     * Populates the IOTA transaction with inputs and commands for the transfer.
+     * This determines which objects to use for payment (either payment objects or gas objects),
+     * consolidates them into a single coin, and then splits/transfers to recipients.
+     */
     populateTxInputsAndCommands() {
-        if (this.paymentObjects) {
-            let firstInputObj = this._iotaTransaction.object(transactions_1.Inputs.ObjectRef(this.paymentObjects[0]));
-            if (this.paymentObjects.length > 1) {
-                let idx = 1;
-                while (idx < this.paymentObjects.length) {
-                    [firstInputObj] = this._iotaTransaction.mergeCoins(firstInputObj, this.paymentObjects
-                        .slice(idx, idx + constants_1.MAX_INPUT_OBJECTS)
-                        .map((input) => this._iotaTransaction.object(transactions_1.Inputs.ObjectRef(input))));
-                    idx += constants_1.MAX_INPUT_OBJECTS;
-                }
-            }
-            const coins = this._iotaTransaction.splitCoins(firstInputObj, this._recipients.map((recipient) => recipient.amount));
-            this._recipients.forEach((recipient, idx) => {
-                this._iotaTransaction.transferObjects([coins[idx]], recipient.address);
-            });
+        const sourceCoin = this.getConsolidatedSourceCoin();
+        this.splitAndTransferToRecipients(sourceCoin);
+    }
+    /**
+     * Determines which objects to use as the payment source and consolidates them.
+     * If payment objects are provided, use those. Otherwise, if the sender is paying
+     * their own gas, use the gas objects for payment.
+     */
+    getConsolidatedSourceCoin() {
+        if (this.hasPaymentObjects()) {
+            return this.consolidatePaymentObjects();
+        }
+        return this.consolidateGasObjects();
+    }
+    /**
+     * Checks if payment objects exist and if gas objects should be used instead.
+     * Gas objects are used when: no payment objects exist AND sender pays their own gas.
+     */
+    hasPaymentObjects() {
+        const hasPaymentObjects = this.paymentObjects && this.paymentObjects.length > 0;
+        if (hasPaymentObjects) {
+            return true;
         }
+        // If no payment objects, only use gas objects if sender pays own gas
+        const senderPaysOwnGas = !this.gasSponsor || this.gasSponsor === this.sender;
+        return !senderPaysOwnGas;
     }
+    /**
+     * Consolidates payment objects into a single coin object.
+     * If multiple payment objects exist, they are merged in batches.
+     */
+    consolidatePaymentObjects() {
+        if (!this.paymentObjects || this.paymentObjects.length === 0) {
+            throw new sdk_core_1.InvalidTransactionError('Payment objects are required');
+        }
+        const firstObject = this._iotaTransaction.object(transactions_1.Inputs.ObjectRef(this.paymentObjects[0]));
+        // Single object doesn't need consolidation
+        if (this.paymentObjects.length > 1) {
+            // Merge extra objects into the first one
+            this.mergeObjectsInBatches(firstObject, this.paymentObjects.slice(1), constants_1.MAX_INPUT_OBJECTS);
+        }
+        return firstObject;
+    }
+    /**
+     * Consolidates gas payment objects into a single coin object.
+     * If the number of gas objects exceeds the maximum, they are merged in batches.
+     */
+    consolidateGasObjects() {
+        if (!this.gasPaymentObjects || this.gasPaymentObjects.length === 0) {
+            throw new sdk_core_1.InvalidTransactionError('Gas payment objects are required');
+        }
+        const gasObject = this._iotaTransaction.gas;
+        if (this.gasPaymentObjects.length > constants_1.MAX_GAS_PAYMENT_OBJECTS) {
+            // Merge excess gas objects to stay within limits
+            this.mergeObjectsInBatches(gasObject, this.gasPaymentObjects, constants_1.MAX_INPUT_OBJECTS);
+        }
+        return gasObject;
+    }
+    /**
+     * Merges multiple coin objects into a target coin in batches.
+     * This is necessary because IOTA has limits on the number of objects per merge command.
+     *
+     * @param targetCoin - The coin to merge into
+     * @param objectsToMerge - Array of objects to merge
+     * @param batchSize - Maximum number of objects to merge per batch
+     * @returns The consolidated coin object
+     */
+    mergeObjectsInBatches(targetCoin, objectsToMerge, batchSize) {
+        for (let startIndex = 0; startIndex < objectsToMerge.length; startIndex += batchSize) {
+            const batch = objectsToMerge.slice(startIndex, startIndex + batchSize);
+            const batchAsTransactionObjects = batch.map((obj) => this._iotaTransaction.object(transactions_1.Inputs.ObjectRef(obj)));
+            this._iotaTransaction.mergeCoins(targetCoin, batchAsTransactionObjects);
+        }
+    }
+    /**
+     * Splits the source coin into the amounts needed for each recipient and transfers them.
+     * This creates split coin commands for all recipient amounts, then transfer commands
+     * to send each split coin to the corresponding recipient.
+     */
+    splitAndTransferToRecipients(sourceCoin) {
+        const recipientAmounts = this._recipients.map((recipient) => recipient.amount);
+        const splitCoins = this._iotaTransaction.splitCoins(sourceCoin, recipientAmounts);
+        this._recipients.forEach((recipient, index) => {
+            this._iotaTransaction.transferObjects([splitCoins[index]], recipient.address);
+        });
+    }
+    /**
+     * Validates all transfer transaction data before building.
+     * Checks recipients, payment objects, and ensures no duplicate object IDs.
+     */
     validateTxDataImplementation() {
-        if (!this.recipients || this.recipients?.length === 0) {
+        this.validateRecipientsList();
+        this.validatePaymentObjectsExist();
+        this.validateNoDuplicateObjects();
+    }
+    /**
+     * Validates that recipients exist and don't exceed the maximum allowed.
+     */
+    validateRecipientsList() {
+        if (!this.recipients || this.recipients.length === 0) {
             throw new sdk_core_1.InvalidTransactionError('Transaction recipients are required');
         }
         if (this.recipients.length > constants_1.MAX_RECIPIENTS) {
             throw new sdk_core_1.InvalidTransactionError(`Recipients count (${this.recipients.length}) exceeds maximum allowed (${constants_1.MAX_RECIPIENTS})`);
         }
-        if (!this.paymentObjects || this.paymentObjects?.length === 0) {
-            throw new sdk_core_1.InvalidTransactionError('Payment objects are required');
+    }
+    /**
+     * Validates that either payment objects or gas objects exist for funding the transfer.
+     * When a gas sponsor is used, payment objects are required.
+     * Otherwise, either payment objects or gas objects can be used.
+     */
+    validatePaymentObjectsExist() {
+        const hasPaymentObjects = this.paymentObjects && this.paymentObjects.length > 0;
+        if (hasPaymentObjects) {
+            return; // Payment objects exist, validation passes
         }
-        // Check for duplicate object IDs in payment objects
-        const paymentObjectIds = this.paymentObjects.map((obj) => obj.objectId);
-        const uniquePaymentIds = new Set(paymentObjectIds);
-        if (uniquePaymentIds.size !== paymentObjectIds.length) {
-            throw new sdk_core_1.InvalidTransactionError('Duplicate object IDs found in payment objects');
-        }
-        if (this.gasPaymentObjects && this.gasPaymentObjects.length > 0) {
-            const gasObjectIds = this.gasPaymentObjects.map((gas) => gas.objectId);
-            // Check for duplicate object IDs in gas payment objects
-            const uniqueGasIds = new Set(gasObjectIds);
-            if (uniqueGasIds.size !== gasObjectIds.length) {
-                throw new sdk_core_1.InvalidTransactionError('Duplicate object IDs found in gas payment objects');
-            }
-            const duplicates = this.paymentObjects.filter((payment) => gasObjectIds.includes(payment.objectId));
-            if (duplicates.length > 0) {
-                throw new sdk_core_1.InvalidTransactionError('Payment objects cannot be the same as gas payment objects: ' + duplicates.map((d) => d.objectId).join(', '));
-            }
+        // No payment objects - check if gas objects can be used instead
+        const hasGasSponsor = this.gasSponsor && this.gasSponsor !== this.sender;
+        if (hasGasSponsor) {
+            throw new sdk_core_1.InvalidTransactionError('Payment objects are required when using a gas sponsor');
+        }
+        // No gas sponsor - gas objects must exist
+        const hasGasObjects = this.gasPaymentObjects && this.gasPaymentObjects.length > 0;
+        if (!hasGasObjects) {
+            throw new sdk_core_1.InvalidTransactionError('Payment or Gas objects are required');
+        }
+    }
+    /**
+     * Validates that there are no duplicate object IDs within payment objects,
+     * gas payment objects, or between the two groups.
+     */
+    validateNoDuplicateObjects() {
+        const paymentObjectIds = this.paymentObjects?.map((obj) => obj.objectId) ?? [];
+        // Check for duplicates within payment objects
+        this.checkForDuplicateIds(paymentObjectIds, 'payment objects');
+        if (!this.gasPaymentObjects || this.gasPaymentObjects.length === 0) {
+            return;
+        }
+        const gasObjectIds = this.gasPaymentObjects.map((gas) => gas.objectId);
+        // Check for duplicates within gas payment objects
+        this.checkForDuplicateIds(gasObjectIds, 'gas payment objects');
+        // Check for overlaps between payment and gas objects
+        const overlappingIds = paymentObjectIds.filter((id) => gasObjectIds.includes(id));
+        if (overlappingIds.length > 0) {
+            throw new sdk_core_1.InvalidTransactionError('Payment objects cannot be the same as gas payment objects: ' + overlappingIds.join(', '));
+        }
+    }
+    /**
+     * Helper to check for duplicate IDs in an array.
+     */
+    checkForDuplicateIds(ids, objectType) {
+        const uniqueIds = new Set(ids);
+        if (uniqueIds.size !== ids.length) {
+            throw new sdk_core_1.InvalidTransactionError(`Duplicate object IDs found in ${objectType}`);
         }
     }
     /**
      * @inheritDoc
+     * Provides a human-readable explanation of the transfer transaction.
      */
-    explainTransactionImplementation(json, explanationResult) {
+    explainTransactionImplementation(_json, explanationResult) {
         const outputs = this.recipients.map((recipient) => recipient);
-        const outputAmountBN = this.recipients.reduce((accumulator, current) => accumulator.plus(current.amount), new bignumber_js_1.default(0));
-        const outputAmount = outputAmountBN.toString();
+        const outputAmount = this.calculateTotalOutputAmount();
         return {
             ...explanationResult,
             outputAmount,
             outputs,
         };
     }
+    /**
+     * Calculates the total amount being transferred to all recipients.
+     */
+    calculateTotalOutputAmount() {
+        return this.recipients
+            .reduce((accumulator, current) => accumulator.plus(current.amount), new bignumber_js_1.default(0))
+            .toString();
+    }
 }
 exports.TransferTransaction = TransferTransaction;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferTransaction.js","sourceRoot":"","sources":["../../../src/lib/transferTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { InvalidTransactionError, toHex, TransactionRecipient, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { Transaction } from './transaction';\nimport { TransactionExplanation, TransactionObjectInput, TransferTxData, TxData } from './iface';\nimport {\n  Inputs as IotaInputs,\n  TransactionObjectArgument,\n  Transaction as IotaTransaction,\n} from '@iota/iota-sdk/transactions';\nimport { fromBase64 } from '@iota/iota-sdk/utils';\nimport { messageWithIntent as iotaMessageWithIntent } from '@iota/iota-sdk/cryptography';\nimport { BcsReader } from '@iota/bcs';\nimport { MAX_INPUT_OBJECTS, MAX_RECIPIENTS, TRANSFER_TRANSACTION_COMMANDS } from './constants';\nimport utils from './utils';\nimport BigNumber from 'bignumber.js';\n\nexport class TransferTransaction extends Transaction {\n  private _recipients: TransactionRecipient[];\n  private _paymentObjects?: TransactionObjectInput[];\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._type = TransactionType.Send;\n    this._inputs = [];\n    this._outputs = [];\n  }\n\n  get recipients(): TransactionRecipient[] {\n    return this._recipients;\n  }\n\n  set recipients(value: TransactionRecipient[]) {\n    this._recipients = value;\n    this._rebuildRequired = true;\n  }\n\n  get paymentObjects(): TransactionObjectInput[] | undefined {\n    return this._paymentObjects;\n  }\n\n  set paymentObjects(value: TransactionObjectInput[] | undefined) {\n    this._paymentObjects = value;\n    this._rebuildRequired = true;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  addInputsAndOutputs(): void {\n    if (!this._iotaTransaction) {\n      return;\n    }\n    const totalAmount = this.recipients.reduce((accumulator, current) => accumulator + Number(current.amount), 0);\n    this._outputs = this.recipients.map((recipient, index) => ({\n      address: recipient.address,\n      value: recipient.amount.toString(),\n      coin: this._coinConfig.name,\n    }));\n    this._inputs = [\n      {\n        address: this.sender,\n        value: totalAmount.toString(),\n        coin: this._coinConfig.name,\n      },\n    ];\n  }\n\n  toJson(): TransferTxData {\n    return {\n      ...super.toJson(),\n      recipients: this.recipients,\n      paymentObjects: this.paymentObjects,\n    };\n  }\n\n  parseFromJSON(txData: TransferTxData): void {\n    super.parseFromJSON(txData);\n    this.recipients = txData.recipients;\n    this.paymentObjects = txData.paymentObjects;\n    this.updateIsSimulateTx();\n  }\n\n  parseFromBroadcastTx(tx: string | Uint8Array): void {\n    const txData = IotaTransaction.from(tx).getData();\n    if (txData.commands.filter((command) => !TRANSFER_TRANSACTION_COMMANDS.includes(command.$kind)).length > 0) {\n      throw new InvalidTransactionError('Unsupported commands in the transaction');\n    }\n    super.parseFromBroadcastTx(tx);\n    const inputObjects: TransactionObjectInput[] = [];\n    const amounts: string[] = [];\n    const receivers: string[] = [];\n    txData.inputs.forEach((input) => {\n      if (input.$kind === 'Object' && 'ImmOrOwnedObject' in input.Object) {\n        inputObjects.push(input.Object.ImmOrOwnedObject as TransactionObjectInput);\n      }\n      if (input.$kind === 'Pure' && 'bytes' in input.Pure) {\n        const value = fromBase64(input.Pure.bytes);\n        const hexValue = '0x' + toHex(value);\n        if (utils.isValidAddress(hexValue)) {\n          receivers.push(hexValue);\n        } else {\n          amounts.push(new BcsReader(value).read64().toString());\n        }\n      }\n    });\n    if (amounts.length !== receivers.length) {\n      throw new InvalidTransactionError('count of amounts does not match count of receivers');\n    }\n    this._paymentObjects = inputObjects;\n    this.recipients = [];\n    receivers.forEach((recipient, index) => {\n      this._recipients.push({\n        address: recipient,\n        amount: amounts[index],\n      });\n    });\n    this.updateIsSimulateTx();\n  }\n\n  protected messageWithIntent(message: Uint8Array): Uint8Array {\n    return iotaMessageWithIntent('TransactionData', message);\n  }\n\n  protected populateTxInputsAndCommands(): void {\n    if (this.paymentObjects) {\n      let firstInputObj: TransactionObjectArgument = this._iotaTransaction.object(\n        IotaInputs.ObjectRef(this.paymentObjects[0])\n      );\n      if (this.paymentObjects.length > 1) {\n        let idx = 1;\n        while (idx < this.paymentObjects.length) {\n          [firstInputObj] = this._iotaTransaction.mergeCoins(\n            firstInputObj,\n            this.paymentObjects\n              .slice(idx, idx + MAX_INPUT_OBJECTS)\n              .map((input) => this._iotaTransaction.object(IotaInputs.ObjectRef(input)))\n          );\n          idx += MAX_INPUT_OBJECTS;\n        }\n      }\n\n      const coins = this._iotaTransaction.splitCoins(\n        firstInputObj,\n        this._recipients.map((recipient) => recipient.amount)\n      );\n      this._recipients.forEach((recipient, idx) => {\n        this._iotaTransaction.transferObjects([coins[idx]], recipient.address);\n      });\n    }\n  }\n\n  protected validateTxDataImplementation(): void {\n    if (!this.recipients || this.recipients?.length === 0) {\n      throw new InvalidTransactionError('Transaction recipients are required');\n    }\n\n    if (this.recipients.length > MAX_RECIPIENTS) {\n      throw new InvalidTransactionError(\n        `Recipients count (${this.recipients.length}) exceeds maximum allowed (${MAX_RECIPIENTS})`\n      );\n    }\n\n    if (!this.paymentObjects || this.paymentObjects?.length === 0) {\n      throw new InvalidTransactionError('Payment objects are required');\n    }\n\n    // Check for duplicate object IDs in payment objects\n    const paymentObjectIds = this.paymentObjects.map((obj) => obj.objectId);\n    const uniquePaymentIds = new Set(paymentObjectIds);\n    if (uniquePaymentIds.size !== paymentObjectIds.length) {\n      throw new InvalidTransactionError('Duplicate object IDs found in payment objects');\n    }\n\n    if (this.gasPaymentObjects && this.gasPaymentObjects.length > 0) {\n      const gasObjectIds = this.gasPaymentObjects.map((gas) => gas.objectId);\n\n      // Check for duplicate object IDs in gas payment objects\n      const uniqueGasIds = new Set(gasObjectIds);\n      if (uniqueGasIds.size !== gasObjectIds.length) {\n        throw new InvalidTransactionError('Duplicate object IDs found in gas payment objects');\n      }\n\n      const duplicates = this.paymentObjects.filter((payment) => gasObjectIds.includes(payment.objectId));\n      if (duplicates.length > 0) {\n        throw new InvalidTransactionError(\n          'Payment objects cannot be the same as gas payment objects: ' + duplicates.map((d) => d.objectId).join(', ')\n        );\n      }\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected explainTransactionImplementation(\n    json: TxData,\n    explanationResult: TransactionExplanation\n  ): TransactionExplanation {\n    const outputs: TransactionRecipient[] = this.recipients.map((recipient) => recipient);\n    const outputAmountBN = this.recipients.reduce(\n      (accumulator, current) => accumulator.plus(current.amount),\n      new BigNumber(0)\n    );\n    const outputAmount = outputAmountBN.toString();\n\n    return {\n      ...explanationResult,\n      outputAmount,\n      outputs,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferTransaction.js","sourceRoot":"","sources":["../../../src/lib/transferTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { InvalidTransactionError, toHex, TransactionRecipient, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { Transaction } from './transaction';\nimport { TransactionExplanation, TransactionObjectInput, TransferTxData, TxData } from './iface';\nimport {\n  Inputs as IotaInputs,\n  TransactionObjectArgument,\n  Transaction as IotaTransaction,\n} from '@iota/iota-sdk/transactions';\nimport { fromBase64 } from '@iota/iota-sdk/utils';\nimport { messageWithIntent as iotaMessageWithIntent } from '@iota/iota-sdk/cryptography';\nimport { BcsReader } from '@iota/bcs';\nimport { MAX_GAS_PAYMENT_OBJECTS, MAX_INPUT_OBJECTS, MAX_RECIPIENTS, TRANSFER_TRANSACTION_COMMANDS } from './constants';\nimport utils from './utils';\nimport BigNumber from 'bignumber.js';\n\nexport class TransferTransaction extends Transaction {\n  private _recipients: TransactionRecipient[];\n  private _paymentObjects?: TransactionObjectInput[];\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._type = TransactionType.Send;\n    this._inputs = [];\n    this._outputs = [];\n  }\n\n  get recipients(): TransactionRecipient[] {\n    return this._recipients;\n  }\n\n  set recipients(value: TransactionRecipient[]) {\n    this._recipients = value;\n    this._rebuildRequired = true;\n  }\n\n  get paymentObjects(): TransactionObjectInput[] | undefined {\n    return this._paymentObjects;\n  }\n\n  set paymentObjects(value: TransactionObjectInput[] | undefined) {\n    this._paymentObjects = value;\n    this._rebuildRequired = true;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  addInputsAndOutputs(): void {\n    if (!this._iotaTransaction) {\n      return;\n    }\n    const totalAmount = this.recipients.reduce((accumulator, current) => accumulator + Number(current.amount), 0);\n    this._outputs = this.recipients.map((recipient, index) => ({\n      address: recipient.address,\n      value: recipient.amount.toString(),\n      coin: this._coinConfig.name,\n    }));\n    this._inputs = [\n      {\n        address: this.sender,\n        value: totalAmount.toString(),\n        coin: this._coinConfig.name,\n      },\n    ];\n  }\n\n  toJson(): TransferTxData {\n    return {\n      ...super.toJson(),\n      recipients: this.recipients,\n      paymentObjects: this.paymentObjects,\n    };\n  }\n\n  parseFromJSON(txData: TransferTxData): void {\n    super.parseFromJSON(txData);\n    this.recipients = txData.recipients;\n    this.paymentObjects = txData.paymentObjects;\n    this.updateIsSimulateTx();\n  }\n\n  /**\n   * Parses a transfer transaction from its broadcast format (base64 or raw bytes).\n   * Extracts recipients, amounts, and payment objects from the transaction data.\n   */\n  parseFromBroadcastTx(tx: string | Uint8Array): void {\n    const txData = IotaTransaction.from(tx).getData();\n    this.validateTransferCommands(txData);\n\n    super.parseFromBroadcastTx(tx);\n\n    const { inputObjects, amounts, receivers } = this.parseTransactionInputs(txData);\n    this.validateAmountsMatchReceivers(amounts, receivers);\n    this.assignParsedObjects(inputObjects);\n    this.assignRecipients(receivers, amounts);\n    this.updateIsSimulateTx();\n  }\n\n  /**\n   * Validates that the transaction only contains supported transfer commands.\n   */\n  private validateTransferCommands(txData: ReturnType<IotaTransaction['getData']>): void {\n    const hasUnsupportedCommands = txData.commands.some(\n      (command) => !TRANSFER_TRANSACTION_COMMANDS.includes(command.$kind)\n    );\n\n    if (hasUnsupportedCommands) {\n      throw new InvalidTransactionError('Unsupported commands in the transaction');\n    }\n  }\n\n  /**\n   * Parses transaction inputs to extract objects, amounts, and receiver addresses.\n   */\n  private parseTransactionInputs(txData: ReturnType<IotaTransaction['getData']>): {\n    inputObjects: TransactionObjectInput[];\n    amounts: string[];\n    receivers: string[];\n  } {\n    const inputObjects: TransactionObjectInput[] = [];\n    const amounts: string[] = [];\n    const receivers: string[] = [];\n\n    txData.inputs.forEach((input) => {\n      if (input.$kind === 'Object' && 'ImmOrOwnedObject' in input.Object) {\n        inputObjects.push(input.Object.ImmOrOwnedObject as TransactionObjectInput);\n      }\n\n      if (input.$kind === 'Pure' && 'bytes' in input.Pure) {\n        const value = fromBase64(input.Pure.bytes);\n        const hexValue = '0x' + toHex(value);\n\n        if (utils.isValidAddress(hexValue)) {\n          receivers.push(hexValue);\n        } else {\n          amounts.push(new BcsReader(value).read64().toString());\n        }\n      }\n    });\n\n    return { inputObjects, amounts, receivers };\n  }\n\n  /**\n   * Validates that the number of amounts matches the number of receivers.\n   */\n  private validateAmountsMatchReceivers(amounts: string[], receivers: string[]): void {\n    if (amounts.length !== receivers.length) {\n      throw new InvalidTransactionError('Count of amounts does not match count of receivers');\n    }\n  }\n\n  /**\n   * Assigns parsed input objects to either gas payment objects or payment objects.\n   * If no gas objects exist and sender pays own gas, objects become gas objects.\n   * Otherwise, they become payment objects.\n   */\n  private assignParsedObjects(inputObjects: TransactionObjectInput[]): void {\n    if (inputObjects.length === 0) {\n      return;\n    }\n\n    const noGasObjectsExist = !this.gasPaymentObjects || this.gasPaymentObjects.length === 0;\n    const senderPaysOwnGas = !this.gasSponsor || this.sender === this.gasSponsor;\n\n    if (noGasObjectsExist && senderPaysOwnGas) {\n      this.gasPaymentObjects = inputObjects;\n    } else {\n      this._paymentObjects = inputObjects;\n    }\n  }\n\n  /**\n   * Creates and assigns recipients from parsed addresses and amounts.\n   */\n  private assignRecipients(receivers: string[], amounts: string[]): void {\n    this._recipients = receivers.map((address, index) => ({\n      address,\n      amount: amounts[index],\n    }));\n  }\n\n  protected messageWithIntent(message: Uint8Array): Uint8Array {\n    return iotaMessageWithIntent('TransactionData', message);\n  }\n\n  /**\n   * Populates the IOTA transaction with inputs and commands for the transfer.\n   * This determines which objects to use for payment (either payment objects or gas objects),\n   * consolidates them into a single coin, and then splits/transfers to recipients.\n   */\n  protected populateTxInputsAndCommands(): void {\n    const sourceCoin = this.getConsolidatedSourceCoin();\n    this.splitAndTransferToRecipients(sourceCoin);\n  }\n\n  /**\n   * Determines which objects to use as the payment source and consolidates them.\n   * If payment objects are provided, use those. Otherwise, if the sender is paying\n   * their own gas, use the gas objects for payment.\n   */\n  private getConsolidatedSourceCoin(): TransactionObjectArgument {\n    if (this.hasPaymentObjects()) {\n      return this.consolidatePaymentObjects();\n    }\n    return this.consolidateGasObjects();\n  }\n\n  /**\n   * Checks if payment objects exist and if gas objects should be used instead.\n   * Gas objects are used when: no payment objects exist AND sender pays their own gas.\n   */\n  private hasPaymentObjects(): boolean {\n    const hasPaymentObjects = this.paymentObjects && this.paymentObjects.length > 0;\n    if (hasPaymentObjects) {\n      return true;\n    }\n\n    // If no payment objects, only use gas objects if sender pays own gas\n    const senderPaysOwnGas = !this.gasSponsor || this.gasSponsor === this.sender;\n    return !senderPaysOwnGas;\n  }\n\n  /**\n   * Consolidates payment objects into a single coin object.\n   * If multiple payment objects exist, they are merged in batches.\n   */\n  private consolidatePaymentObjects(): TransactionObjectArgument {\n    if (!this.paymentObjects || this.paymentObjects.length === 0) {\n      throw new InvalidTransactionError('Payment objects are required');\n    }\n\n    const firstObject = this._iotaTransaction.object(IotaInputs.ObjectRef(this.paymentObjects[0]));\n\n    // Single object doesn't need consolidation\n    if (this.paymentObjects.length > 1) {\n      // Merge extra objects into the first one\n      this.mergeObjectsInBatches(firstObject, this.paymentObjects.slice(1), MAX_INPUT_OBJECTS);\n    }\n\n    return firstObject;\n  }\n\n  /**\n   * Consolidates gas payment objects into a single coin object.\n   * If the number of gas objects exceeds the maximum, they are merged in batches.\n   */\n  private consolidateGasObjects(): TransactionObjectArgument {\n    if (!this.gasPaymentObjects || this.gasPaymentObjects.length === 0) {\n      throw new InvalidTransactionError('Gas payment objects are required');\n    }\n\n    const gasObject = this._iotaTransaction.gas;\n\n    if (this.gasPaymentObjects.length > MAX_GAS_PAYMENT_OBJECTS) {\n      // Merge excess gas objects to stay within limits\n      this.mergeObjectsInBatches(gasObject, this.gasPaymentObjects, MAX_INPUT_OBJECTS);\n    }\n\n    return gasObject;\n  }\n\n  /**\n   * Merges multiple coin objects into a target coin in batches.\n   * This is necessary because IOTA has limits on the number of objects per merge command.\n   *\n   * @param targetCoin - The coin to merge into\n   * @param objectsToMerge - Array of objects to merge\n   * @param batchSize - Maximum number of objects to merge per batch\n   * @returns The consolidated coin object\n   */\n  private mergeObjectsInBatches(\n    targetCoin: TransactionObjectArgument,\n    objectsToMerge: TransactionObjectInput[],\n    batchSize: number\n  ): void {\n    for (let startIndex = 0; startIndex < objectsToMerge.length; startIndex += batchSize) {\n      const batch = objectsToMerge.slice(startIndex, startIndex + batchSize);\n      const batchAsTransactionObjects = batch.map((obj) => this._iotaTransaction.object(IotaInputs.ObjectRef(obj)));\n\n      this._iotaTransaction.mergeCoins(targetCoin, batchAsTransactionObjects);\n    }\n  }\n\n  /**\n   * Splits the source coin into the amounts needed for each recipient and transfers them.\n   * This creates split coin commands for all recipient amounts, then transfer commands\n   * to send each split coin to the corresponding recipient.\n   */\n  private splitAndTransferToRecipients(sourceCoin: TransactionObjectArgument): void {\n    const recipientAmounts = this._recipients.map((recipient) => recipient.amount);\n    const splitCoins = this._iotaTransaction.splitCoins(sourceCoin, recipientAmounts);\n\n    this._recipients.forEach((recipient, index) => {\n      this._iotaTransaction.transferObjects([splitCoins[index]], recipient.address);\n    });\n  }\n\n  /**\n   * Validates all transfer transaction data before building.\n   * Checks recipients, payment objects, and ensures no duplicate object IDs.\n   */\n  protected validateTxDataImplementation(): void {\n    this.validateRecipientsList();\n    this.validatePaymentObjectsExist();\n    this.validateNoDuplicateObjects();\n  }\n\n  /**\n   * Validates that recipients exist and don't exceed the maximum allowed.\n   */\n  private validateRecipientsList(): void {\n    if (!this.recipients || this.recipients.length === 0) {\n      throw new InvalidTransactionError('Transaction recipients are required');\n    }\n\n    if (this.recipients.length > MAX_RECIPIENTS) {\n      throw new InvalidTransactionError(\n        `Recipients count (${this.recipients.length}) exceeds maximum allowed (${MAX_RECIPIENTS})`\n      );\n    }\n  }\n\n  /**\n   * Validates that either payment objects or gas objects exist for funding the transfer.\n   * When a gas sponsor is used, payment objects are required.\n   * Otherwise, either payment objects or gas objects can be used.\n   */\n  private validatePaymentObjectsExist(): void {\n    const hasPaymentObjects = this.paymentObjects && this.paymentObjects.length > 0;\n    if (hasPaymentObjects) {\n      return; // Payment objects exist, validation passes\n    }\n\n    // No payment objects - check if gas objects can be used instead\n    const hasGasSponsor = this.gasSponsor && this.gasSponsor !== this.sender;\n    if (hasGasSponsor) {\n      throw new InvalidTransactionError('Payment objects are required when using a gas sponsor');\n    }\n\n    // No gas sponsor - gas objects must exist\n    const hasGasObjects = this.gasPaymentObjects && this.gasPaymentObjects.length > 0;\n    if (!hasGasObjects) {\n      throw new InvalidTransactionError('Payment or Gas objects are required');\n    }\n  }\n\n  /**\n   * Validates that there are no duplicate object IDs within payment objects,\n   * gas payment objects, or between the two groups.\n   */\n  private validateNoDuplicateObjects(): void {\n    const paymentObjectIds = this.paymentObjects?.map((obj) => obj.objectId) ?? [];\n\n    // Check for duplicates within payment objects\n    this.checkForDuplicateIds(paymentObjectIds, 'payment objects');\n\n    if (!this.gasPaymentObjects || this.gasPaymentObjects.length === 0) {\n      return;\n    }\n\n    const gasObjectIds = this.gasPaymentObjects.map((gas) => gas.objectId);\n\n    // Check for duplicates within gas payment objects\n    this.checkForDuplicateIds(gasObjectIds, 'gas payment objects');\n\n    // Check for overlaps between payment and gas objects\n    const overlappingIds = paymentObjectIds.filter((id) => gasObjectIds.includes(id));\n    if (overlappingIds.length > 0) {\n      throw new InvalidTransactionError(\n        'Payment objects cannot be the same as gas payment objects: ' + overlappingIds.join(', ')\n      );\n    }\n  }\n\n  /**\n   * Helper to check for duplicate IDs in an array.\n   */\n  private checkForDuplicateIds(ids: string[], objectType: string): void {\n    const uniqueIds = new Set(ids);\n    if (uniqueIds.size !== ids.length) {\n      throw new InvalidTransactionError(`Duplicate object IDs found in ${objectType}`);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   * Provides a human-readable explanation of the transfer transaction.\n   */\n  protected explainTransactionImplementation(\n    _json: TxData,\n    explanationResult: TransactionExplanation\n  ): TransactionExplanation {\n    const outputs = this.recipients.map((recipient) => recipient);\n    const outputAmount = this.calculateTotalOutputAmount();\n\n    return {\n      ...explanationResult,\n      outputAmount,\n      outputs,\n    };\n  }\n\n  /**\n   * Calculates the total amount being transferred to all recipients.\n   */\n  private calculateTotalOutputAmount(): string {\n    return this.recipients\n      .reduce((accumulator, current) => accumulator.plus(current.amount), new BigNumber(0))\n      .toString();\n  }\n}\n"]}

package/dist/src/lib/utils.d.ts

@@ -1,23 +1,121 @@
 import { BaseUtils } from '@bitgo-beta/sdk-core';
+/**
+ * Utility class for IOTA-specific validation and conversion operations.
+ * Implements the BaseUtils interface and provides methods for validating
+ * addresses, keys, signatures, and transaction data.
+ */
 export declare class Utils implements BaseUtils {
-    /** @inheritdoc */
+    /**
+     * Validates an IOTA address format.
+     * IOTA addresses are 64-character hex strings prefixed with '0x'.
+     *
+     * @param address - The address to validate
+     * @returns true if the address is valid
+     *
+     * @example
+     * ```typescript
+     * utils.isValidAddress('0x1234...') // true
+     * utils.isValidAddress('invalid') // false
+     * ```
+     */
     isValidAddress(address: string): boolean;
-    /** @inheritdoc */
+    /**
+     * Validates an IOTA block ID (digest).
+     * Block IDs are 32-byte base58-encoded strings.
+     *
+     * @param hash - The block ID to validate
+     * @returns true if the block ID is valid
+     */
     isValidBlockId(hash: string): boolean;
-    /** @inheritdoc */
+    /**
+     * Validates an IOTA transaction ID (digest).
+     * Transaction IDs are 32-byte base58-encoded strings.
+     *
+     * @param txId - The transaction ID to validate
+     * @returns true if the transaction ID is valid
+     */
+    isValidTransactionId(txId: string): boolean;
+    /**
+     * Validates an Ed25519 private key format.
+     *
+     * @param key - The private key to validate (hex string)
+     * @returns true if the private key is valid
+     */
     isValidPrivateKey(key: string): boolean;
-    /** @inheritdoc */
+    /**
+     * Validates an Ed25519 public key format.
+     *
+     * @param key - The public key to validate (hex string)
+     * @returns true if the public key is valid
+     */
     isValidPublicKey(key: string): boolean;
-    /** @inheritdoc */
+    /**
+     * Validates an IOTA signature format.
+     * Signatures must be base64-encoded and exactly 64 bytes when decoded.
+     *
+     * @param signature - The base64-encoded signature to validate
+     * @returns true if the signature is valid
+     */
     isValidSignature(signature: string): boolean;
-    /** @inheritdoc */
-    isValidTransactionId(txId: string): boolean;
+    /**
+     * Validates a raw IOTA transaction format.
+     * Attempts to parse the transaction using the IOTA SDK.
+     *
+     * @param rawTransaction - The raw transaction (base64 string or Uint8Array)
+     * @returns true if the transaction can be parsed
+     */
+    isValidRawTransaction(rawTransaction: string | Uint8Array): boolean;
+    /**
+     * Validates a hex string with a specific length requirement.
+     * Checks for '0x' or '0X' prefix followed by the specified number of hex characters.
+     *
+     * @param value - The hex string to validate
+     * @param length - The required length (number of hex characters, excluding prefix)
+     * @returns true if the hex string matches the format and length
+     */
     isValidHex(value: string, length: number): boolean;
-    isValidBase64(str: string): boolean;
+    /**
+     * Converts a value to a base64-encoded string.
+     * Handles both Uint8Array and hex string inputs.
+     *
+     * @param value - The value to encode (Uint8Array or hex string)
+     * @returns Base64-encoded string
+     *
+     * @example
+     * ```typescript
+     * utils.getBase64String(new Uint8Array([1, 2, 3]))
+     * utils.getBase64String('0x010203')
+     * ```
+     */
     getBase64String(value: string | Uint8Array): string;
+    /**
+     * Derives an IOTA address from an Ed25519 public key.
+     * Uses the IOTA SDK's address derivation algorithm.
+     *
+     * @param publicKey - The Ed25519 public key (hex string)
+     * @returns The derived IOTA address
+     *
+     * @example
+     * ```typescript
+     * const address = utils.getAddressFromPublicKey('8c26e54e36c902c5...')
+     * // Returns: '0x9882188ba3e8070a...'
+     * ```
+     */
     getAddressFromPublicKey(publicKey: string): string;
-    isValidRawTransaction(rawTransaction: string | Uint8Array): boolean;
 }
+/**
+ * Singleton instance of the Utils class.
+ * Use this for all IOTA utility operations throughout the SDK.
+ *
+ * @example
+ * ```typescript
+ * import utils from './utils';
+ *
+ * if (utils.isValidAddress(address)) {
+ *   // Process valid address
+ * }
+ * ```
+ */
 declare const utils: Utils;
 export default utils;
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA8D,MAAM,sBAAsB,CAAC;AAW7G,qBAAa,KAAM,YAAW,SAAS;IACrC,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,kBAAkB;IAClB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC,kBAAkB;IAClB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAItC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAQ5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAKlD,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAqBnC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM;IAUnD,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAKlD,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO;CAQpE;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA8D,MAAM,sBAAsB,CAAC;AAW7G;;;;GAIG;AACH,qBAAa,KAAM,YAAW,SAAS;IAKrC;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC;;;;;;OAMG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;;OAMG;IACH,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAQ3C;;;;;OAKG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC;;;;;OAKG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAQtC;;;;;;OAMG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAU5C;;;;;;OAMG;IACH,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO;IAanE;;;;;;;OAOG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAKlD;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM;IAOnD;;;;;;;;;;;;OAYG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAInD;AAED;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}