@bitgo-beta/sdk-coin-iota 1.0.1-beta.44 → 1.0.1-beta.441

package/dist/src/lib/transferTransaction.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferTransaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transaction_1 = require("./transaction");
+const transactions_1 = require("@iota/iota-sdk/transactions");
+const utils_1 = require("@iota/iota-sdk/utils");
+const cryptography_1 = require("@iota/iota-sdk/cryptography");
+const bcs_1 = require("@iota/bcs");
+const constants_1 = require("./constants");
+const utils_2 = __importDefault(require("./utils"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+class TransferTransaction extends transaction_1.Transaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._type = sdk_core_1.TransactionType.Send;
+        this._inputs = [];
+        this._outputs = [];
+    }
+    get recipients() {
+        return this._recipients;
+    }
+    set recipients(value) {
+        this._recipients = value;
+        this._rebuildRequired = true;
+    }
+    get paymentObjects() {
+        return this._paymentObjects;
+    }
+    set paymentObjects(value) {
+        this._paymentObjects = value;
+        this._rebuildRequired = true;
+    }
+    /**
+     * @inheritDoc
+     */
+    addInputsAndOutputs() {
+        if (!this._iotaTransaction) {
+            return;
+        }
+        const totalAmount = this.recipients.reduce((accumulator, current) => accumulator + Number(current.amount), 0);
+        this._outputs = this.recipients.map((recipient, index) => ({
+            address: recipient.address,
+            value: recipient.amount.toString(),
+            coin: this._coinConfig.name,
+        }));
+        this._inputs = [
+            {
+                address: this.sender,
+                value: totalAmount.toString(),
+                coin: this._coinConfig.name,
+            },
+        ];
+    }
+    toJson() {
+        return {
+            ...super.toJson(),
+            recipients: this.recipients,
+            paymentObjects: this.paymentObjects,
+        };
+    }
+    parseFromJSON(txData) {
+        super.parseFromJSON(txData);
+        this.recipients = txData.recipients;
+        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();
+        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');
+        }
+    }
+    /**
+     * Parses transaction inputs to extract objects, amounts, and receiver addresses.
+     */
+    parseTransactionInputs(txData) {
+        const inputObjects = [];
+        const amounts = [];
+        const receivers = [];
+        txData.inputs.forEach((input) => {
+            if (input.$kind === 'Object' && 'ImmOrOwnedObject' in input.Object) {
+                inputObjects.push(input.Object.ImmOrOwnedObject);
+            }
+            if (input.$kind === 'Pure' && 'bytes' in input.Pure) {
+                const value = (0, utils_1.fromBase64)(input.Pure.bytes);
+                const hexValue = '0x' + (0, sdk_core_1.toHex)(value);
+                if (utils_2.default.isValidAddress(hexValue)) {
+                    receivers.push(hexValue);
+                }
+                else {
+                    amounts.push(new bcs_1.BcsReader(value).read64().toString());
+                }
+            }
+        });
+        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');
+        }
+    }
+    /**
+     * 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() {
+        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() {
+        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})`);
+        }
+    }
+    /**
+     * 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
+        }
+        // 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) {
+        const outputs = this.recipients.map((recipient) => recipient);
+        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_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,20 +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;
+    /**
+     * 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;
 }
+/**
+ * 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,EAAoD,MAAM,sBAAsB,CAAC;AASnG,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;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAKlD,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAInD;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"}