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

package/dist/src/lib/transactionBuilderFactory.js

@@ -1,17 +1,144 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionBuilderFactory = void 0;
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transferBuilder_1 = require("./transferBuilder");
+const constants_1 = require("./constants");
+const utils_1 = __importDefault(require("./utils"));
+const transactions_1 = require("@iota/iota-sdk/transactions");
+/**
+ * Factory class for creating IOTA transaction builders.
+ *
+ * This factory provides methods to create transaction builders for different
+ * transaction types and to reconstruct transactions from raw transaction data.
+ *
+ * @example
+ * ```typescript
+ * const factory = new TransactionBuilderFactory(coins.get('tiota'));
+ *
+ * // Create a new transfer builder
+ * const builder = factory.getTransferBuilder();
+ *
+ * // Rebuild from raw transaction
+ * const rebuiltBuilder = factory.from(rawTxHex);
+ * ```
+ */
 class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(coinConfig) {
+        super(coinConfig);
+    }
+    /**
+     * Wallet initialization is not implemented for IOTA.
+     * IOTA wallets are initialized through the TSS flow.
+     *
+     * @throws Error always - not implemented
+     */
     getWalletInitializationBuilder() {
         throw new Error('Method not implemented.');
     }
-    getTransferBuilder() {
-        throw new Error('Method not implemented.');
+    /**
+     * Creates a transfer transaction builder.
+     * Optionally initializes the builder with data from an existing transaction.
+     *
+     * @param tx - Optional existing transaction to initialize the builder
+     * @returns A new TransferBuilder instance
+     *
+     * @example
+     * ```typescript
+     * // Create a new transfer builder
+     * const builder = factory.getTransferBuilder();
+     *
+     * // Initialize from existing transaction
+     * const existingTx = await builder.build();
+     * const newBuilder = factory.getTransferBuilder(existingTx);
+     * ```
+     */
+    getTransferBuilder(tx) {
+        return this.initializeBuilder(tx, new transferBuilder_1.TransferBuilder(this._coinConfig));
     }
-    from(raw) {
-        throw new Error('Method not implemented.');
+    /**
+     * Reconstructs a transaction builder from raw transaction data.
+     * Automatically identifies the transaction type and creates the appropriate builder.
+     *
+     * @param rawTx - Raw transaction data (hex string or Uint8Array)
+     * @returns TransactionBuilder appropriate for the transaction type
+     * @throws InvalidTransactionError if the transaction type is not supported
+     *
+     * @example
+     * ```typescript
+     * // From hex string
+     * const builder = factory.from('0x1234...');
+     *
+     * // From Uint8Array
+     * const builder = factory.from(new Uint8Array([...]));
+     *
+     * // Rebuild and access the transaction
+     * const tx = await builder.build();
+     * ```
+     */
+    from(rawTx) {
+        const rawTxBase64 = utils_1.default.getBase64String(rawTx);
+        const transactionType = this.identifyTransactionType(rawTxBase64);
+        switch (transactionType) {
+            case sdk_core_1.TransactionType.Send:
+                return this.createTransferBuilderFromRawTx(rawTxBase64);
+            default:
+                throw new sdk_core_1.InvalidTransactionError(`Unsupported transaction type: ${transactionType}`);
+        }
+    }
+    /**
+     * Identifies the transaction type by analyzing its commands.
+     * Currently supports transfer transactions (Send type).
+     *
+     * @param rawTx - Raw transaction in base64 format
+     * @returns The identified transaction type
+     * @throws InvalidTransactionError if transaction contains unsupported commands
+     */
+    identifyTransactionType(rawTx) {
+        const txData = transactions_1.Transaction.from(rawTx).getData();
+        if (this.isTransferTransaction(txData)) {
+            return sdk_core_1.TransactionType.Send;
+        }
+        throw new sdk_core_1.InvalidTransactionError('Transaction contains unsupported commands');
+    }
+    /**
+     * Checks if a transaction is a transfer transaction by validating its commands.
+     * Transfer transactions only contain: SplitCoins, MergeCoins, and TransferObjects commands.
+     *
+     * @param txData - The parsed transaction data
+     * @returns true if all commands are valid transfer commands
+     */
+    isTransferTransaction(txData) {
+        return txData.commands.every((command) => constants_1.TRANSFER_TRANSACTION_COMMANDS.includes(command.$kind));
+    }
+    /**
+     * Creates a TransferBuilder from raw transaction data.
+     *
+     * @param rawTxBase64 - Raw transaction in base64 format
+     * @returns Initialized TransferBuilder
+     */
+    createTransferBuilderFromRawTx(rawTxBase64) {
+        const builder = new transferBuilder_1.TransferBuilder(this._coinConfig);
+        builder.fromImplementation(rawTxBase64);
+        return builder;
+    }
+    /**
+     * Initializes a builder with data from an existing transaction.
+     * If no transaction is provided, returns the builder as-is.
+     *
+     * @param tx - Optional transaction to initialize from
+     * @param builder - The builder to initialize
+     * @returns The initialized builder
+     */
+    initializeBuilder(tx, builder) {
+        if (tx) {
+            builder.initBuilder(tx);
+        }
+        return builder;
     }
 }
 exports.TransactionBuilderFactory = TransactionBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvdHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxtREFBcUU7QUFJckUsTUFBYSx5QkFBMEIsU0FBUSx3Q0FBNkI7SUFDbkUsOEJBQThCO1FBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBQ00sa0JBQWtCO1FBQ3ZCLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBQ00sSUFBSSxDQUFDLEdBQXdCO1FBQ2xDLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUM3QyxDQUFDO0NBQ0Y7QUFWRCw4REFVQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VUcmFuc2FjdGlvbkJ1aWxkZXJGYWN0b3J5IH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb25CdWlsZGVyIH0gZnJvbSAnLi90cmFuc2FjdGlvbkJ1aWxkZXInO1xuaW1wb3J0IHsgVHJhbnNmZXJCdWlsZGVyIH0gZnJvbSAnLi90cmFuc2ZlckJ1aWxkZXInO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeSBleHRlbmRzIEJhc2VUcmFuc2FjdGlvbkJ1aWxkZXJGYWN0b3J5IHtcbiAgcHVibGljIGdldFdhbGxldEluaXRpYWxpemF0aW9uQnVpbGRlcigpOiB2b2lkIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ01ldGhvZCBub3QgaW1wbGVtZW50ZWQuJyk7XG4gIH1cbiAgcHVibGljIGdldFRyYW5zZmVyQnVpbGRlcigpOiBUcmFuc2ZlckJ1aWxkZXIge1xuICAgIHRocm93IG5ldyBFcnJvcignTWV0aG9kIG5vdCBpbXBsZW1lbnRlZC4nKTtcbiAgfVxuICBwdWJsaWMgZnJvbShyYXc6IHN0cmluZyB8IFVpbnQ4QXJyYXkpOiBUcmFuc2FjdGlvbkJ1aWxkZXIge1xuICAgIHRocm93IG5ldyBFcnJvcignTWV0aG9kIG5vdCBpbXBsZW1lbnRlZC4nKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":";;;;;;AAAA,mDAA+G;AAE/G,uDAAoD;AAEpD,2CAA4D;AAC5D,oDAA4B;AAC5B,8DAA6E;AAG7E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,yBAA0B,SAAQ,wCAA6B;IAC1E,YAAY,UAAgC;QAC1C,KAAK,CAAC,UAAU,CAAC,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACI,8BAA8B;QACnC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,kBAAkB,CAAC,EAAgB;QACjC,OAAO,IAAI,CAAC,iBAAiB,CAAC,EAAE,EAAE,IAAI,iCAAe,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,IAAI,CAAC,KAA0B;QAC7B,MAAM,WAAW,GAAG,eAAK,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QACjD,MAAM,eAAe,GAAG,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;QAElE,QAAQ,eAAe,EAAE,CAAC;YACxB,KAAK,0BAAe,CAAC,IAAI;gBACvB,OAAO,IAAI,CAAC,8BAA8B,CAAC,WAAW,CAAC,CAAC;YAC1D;gBACE,MAAM,IAAI,kCAAuB,CAAC,iCAAiC,eAAe,EAAE,CAAC,CAAC;QAC1F,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACK,uBAAuB,CAAC,KAA0B;QACxD,MAAM,MAAM,GAAG,0BAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;QAErD,IAAI,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,CAAC;YACvC,OAAO,0BAAe,CAAC,IAAI,CAAC;QAC9B,CAAC;QAED,MAAM,IAAI,kCAAuB,CAAC,2CAA2C,CAAC,CAAC;IACjF,CAAC;IAED;;;;;;OAMG;IACK,qBAAqB,CAAC,MAA8C;QAC1E,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,yCAA6B,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IACnG,CAAC;IAED;;;;;OAKG;IACK,8BAA8B,CAAC,WAAmB;QACxD,MAAM,OAAO,GAAG,IAAI,iCAAe,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACtD,OAAO,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;QACxC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;OAOG;IACK,iBAAiB,CAA+B,EAA2B,EAAE,OAAU;QAC7F,IAAI,EAAE,EAAE,CAAC;YACP,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QAC1B,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AA3HD,8DA2HC","sourcesContent":["import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { TransferBuilder } from './transferBuilder';\nimport { Transaction } from './transaction';\nimport { TRANSFER_TRANSACTION_COMMANDS } from './constants';\nimport utils from './utils';\nimport { Transaction as IotaTransaction } from '@iota/iota-sdk/transactions';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\n\n/**\n * Factory class for creating IOTA transaction builders.\n *\n * This factory provides methods to create transaction builders for different\n * transaction types and to reconstruct transactions from raw transaction data.\n *\n * @example\n * ```typescript\n * const factory = new TransactionBuilderFactory(coins.get('tiota'));\n *\n * // Create a new transfer builder\n * const builder = factory.getTransferBuilder();\n *\n * // Rebuild from raw transaction\n * const rebuiltBuilder = factory.from(rawTxHex);\n * ```\n */\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n  }\n\n  /**\n   * Wallet initialization is not implemented for IOTA.\n   * IOTA wallets are initialized through the TSS flow.\n   *\n   * @throws Error always - not implemented\n   */\n  public getWalletInitializationBuilder(): void {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Creates a transfer transaction builder.\n   * Optionally initializes the builder with data from an existing transaction.\n   *\n   * @param tx - Optional existing transaction to initialize the builder\n   * @returns A new TransferBuilder instance\n   *\n   * @example\n   * ```typescript\n   * // Create a new transfer builder\n   * const builder = factory.getTransferBuilder();\n   *\n   * // Initialize from existing transaction\n   * const existingTx = await builder.build();\n   * const newBuilder = factory.getTransferBuilder(existingTx);\n   * ```\n   */\n  getTransferBuilder(tx?: Transaction): TransferBuilder {\n    return this.initializeBuilder(tx, new TransferBuilder(this._coinConfig));\n  }\n\n  /**\n   * Reconstructs a transaction builder from raw transaction data.\n   * Automatically identifies the transaction type and creates the appropriate builder.\n   *\n   * @param rawTx - Raw transaction data (hex string or Uint8Array)\n   * @returns TransactionBuilder appropriate for the transaction type\n   * @throws InvalidTransactionError if the transaction type is not supported\n   *\n   * @example\n   * ```typescript\n   * // From hex string\n   * const builder = factory.from('0x1234...');\n   *\n   * // From Uint8Array\n   * const builder = factory.from(new Uint8Array([...]));\n   *\n   * // Rebuild and access the transaction\n   * const tx = await builder.build();\n   * ```\n   */\n  from(rawTx: string | Uint8Array): TransactionBuilder {\n    const rawTxBase64 = utils.getBase64String(rawTx);\n    const transactionType = this.identifyTransactionType(rawTxBase64);\n\n    switch (transactionType) {\n      case TransactionType.Send:\n        return this.createTransferBuilderFromRawTx(rawTxBase64);\n      default:\n        throw new InvalidTransactionError(`Unsupported transaction type: ${transactionType}`);\n    }\n  }\n\n  /**\n   * Identifies the transaction type by analyzing its commands.\n   * Currently supports transfer transactions (Send type).\n   *\n   * @param rawTx - Raw transaction in base64 format\n   * @returns The identified transaction type\n   * @throws InvalidTransactionError if transaction contains unsupported commands\n   */\n  private identifyTransactionType(rawTx: string | Uint8Array): TransactionType {\n    const txData = IotaTransaction.from(rawTx).getData();\n\n    if (this.isTransferTransaction(txData)) {\n      return TransactionType.Send;\n    }\n\n    throw new InvalidTransactionError('Transaction contains unsupported commands');\n  }\n\n  /**\n   * Checks if a transaction is a transfer transaction by validating its commands.\n   * Transfer transactions only contain: SplitCoins, MergeCoins, and TransferObjects commands.\n   *\n   * @param txData - The parsed transaction data\n   * @returns true if all commands are valid transfer commands\n   */\n  private isTransferTransaction(txData: ReturnType<IotaTransaction['getData']>): boolean {\n    return txData.commands.every((command) => TRANSFER_TRANSACTION_COMMANDS.includes(command.$kind));\n  }\n\n  /**\n   * Creates a TransferBuilder from raw transaction data.\n   *\n   * @param rawTxBase64 - Raw transaction in base64 format\n   * @returns Initialized TransferBuilder\n   */\n  private createTransferBuilderFromRawTx(rawTxBase64: string): TransferBuilder {\n    const builder = new TransferBuilder(this._coinConfig);\n    builder.fromImplementation(rawTxBase64);\n    return builder;\n  }\n\n  /**\n   * Initializes a builder with data from an existing transaction.\n   * If no transaction is provided, returns the builder as-is.\n   *\n   * @param tx - Optional transaction to initialize from\n   * @param builder - The builder to initialize\n   * @returns The initialized builder\n   */\n  private initializeBuilder<T extends TransactionBuilder>(tx: Transaction | undefined, builder: T): T {\n    if (tx) {\n      builder.initBuilder(tx);\n    }\n    return builder;\n  }\n}\n"]}

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

@@ -1,8 +1,58 @@
 import { TransactionBuilder } from './transactionBuilder';
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-import { TransactionType } from '@bitgo-beta/sdk-core';
+import { TransferTransaction } from './transferTransaction';
+import { TransactionRecipient } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionObjectInput } from './iface';
+/**
+ * Builder for IOTA transfer transactions.
+ * Handles transactions that transfer IOTA tokens from the sender to one or more recipients.
+ */
 export declare class TransferBuilder extends TransactionBuilder {
     constructor(_coinConfig: Readonly<CoinConfig>);
-    protected get transactionType(): TransactionType;
+    /**
+     * Sets the recipients for this transfer transaction.
+     * @param recipients - Array of recipients with their addresses and amounts
+     * @returns This builder for method chaining
+     * @throws BuildTransactionError if any recipient is invalid
+     */
+    recipients(recipients: TransactionRecipient[]): this;
+    /**
+     * Sets the payment objects (coin objects) to be used for this transfer.
+     * These are the source coins that will be split and transferred to recipients.
+     * @param paymentObjects - Array of IOTA coin objects to use for payment
+     * @returns This builder for method chaining
+     */
+    paymentObjects(paymentObjects: TransactionObjectInput[]): this;
+    /**
+     * Initializes the builder with data from an existing transfer transaction.
+     * @param tx - The source transaction to copy data from
+     * @throws BuildTransactionError if transaction is not a TransferTransaction
+     */
+    initBuilder(tx: Transaction): void;
+    /**
+     * Validates that the transaction is of the correct type (TransferTransaction).
+     */
+    private validateTransactionType;
+    /**
+     * Copies transfer-specific data from source transaction.
+     */
+    private copyTransferData;
+    /**
+     * Validates a complete transfer transaction.
+     * @param transaction - The transaction to validate
+     * @throws BuildTransactionError if transaction is invalid or not a TransferTransaction
+     */
+    validateTransaction(transaction?: Transaction): void;
+    /**
+     * Returns the transaction as a TransferTransaction type.
+     */
+    protected get transferTransaction(): TransferTransaction;
+    /**
+     * Validates all recipients have valid addresses and amounts.
+     * @param recipients - Array of recipients to validate
+     * @throws BuildTransactionError if any recipient has invalid address or amount
+     */
+    private validateRecipients;
 }
 //# sourceMappingURL=transferBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,qBAAa,eAAgB,SAAQ,kBAAkB;gBACzC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;CACF"}
+{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAyB,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEnF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,kBAAkB;gBACzC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;;OAKG;IACH,UAAU,CAAC,UAAU,EAAE,oBAAoB,EAAE,GAAG,IAAI;IAMpD;;;;;OAKG;IACH,cAAc,CAAC,cAAc,EAAE,sBAAsB,EAAE,GAAG,IAAI;IAK9D;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAMlC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAM/B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;OAIG;IACH,mBAAmB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;IAUpD;;OAEG;IACH,SAAS,KAAK,mBAAmB,IAAI,mBAAmB,CAEvD;IAED;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;CAM3B"}

package/dist/src/lib/transferBuilder.js

@@ -1,15 +1,98 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransferBuilder = void 0;
 const transactionBuilder_1 = require("./transactionBuilder");
+const transferTransaction_1 = require("./transferTransaction");
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+/**
+ * Builder for IOTA transfer transactions.
+ * Handles transactions that transfer IOTA tokens from the sender to one or more recipients.
+ */
 class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
+        this._transaction = new transferTransaction_1.TransferTransaction(_coinConfig);
     }
-    get transactionType() {
-        return sdk_core_1.TransactionType.Send;
+    /**
+     * Sets the recipients for this transfer transaction.
+     * @param recipients - Array of recipients with their addresses and amounts
+     * @returns This builder for method chaining
+     * @throws BuildTransactionError if any recipient is invalid
+     */
+    recipients(recipients) {
+        this.validateRecipients(recipients);
+        this.transferTransaction.recipients = recipients;
+        return this;
+    }
+    /**
+     * Sets the payment objects (coin objects) to be used for this transfer.
+     * These are the source coins that will be split and transferred to recipients.
+     * @param paymentObjects - Array of IOTA coin objects to use for payment
+     * @returns This builder for method chaining
+     */
+    paymentObjects(paymentObjects) {
+        this.transferTransaction.paymentObjects = paymentObjects;
+        return this;
+    }
+    /**
+     * Initializes the builder with data from an existing transfer transaction.
+     * @param tx - The source transaction to copy data from
+     * @throws BuildTransactionError if transaction is not a TransferTransaction
+     */
+    initBuilder(tx) {
+        this.validateTransactionType(tx);
+        super.initBuilder(tx);
+        this.copyTransferData(tx);
+    }
+    /**
+     * Validates that the transaction is of the correct type (TransferTransaction).
+     */
+    validateTransactionType(tx) {
+        if (!(tx instanceof transferTransaction_1.TransferTransaction)) {
+            throw new sdk_core_1.BuildTransactionError('Transaction must be of type TransferTransaction');
+        }
+    }
+    /**
+     * Copies transfer-specific data from source transaction.
+     */
+    copyTransferData(tx) {
+        this.transferTransaction.recipients = tx.recipients;
+        this.transferTransaction.paymentObjects = tx.paymentObjects;
+    }
+    /**
+     * Validates a complete transfer transaction.
+     * @param transaction - The transaction to validate
+     * @throws BuildTransactionError if transaction is invalid or not a TransferTransaction
+     */
+    validateTransaction(transaction) {
+        if (!transaction) {
+            throw new sdk_core_1.BuildTransactionError('Transaction is required for validation');
+        }
+        this.validateTransactionType(transaction);
+        super.validateTransaction(transaction);
+        this.validateRecipients(transaction.recipients);
+    }
+    /**
+     * Returns the transaction as a TransferTransaction type.
+     */
+    get transferTransaction() {
+        return this._transaction;
+    }
+    /**
+     * Validates all recipients have valid addresses and amounts.
+     * @param recipients - Array of recipients to validate
+     * @throws BuildTransactionError if any recipient has invalid address or amount
+     */
+    validateRecipients(recipients) {
+        recipients.forEach((recipient) => {
+            this.validateAddress({ address: recipient.address });
+            this.validateValue(new bignumber_js_1.default(recipient.amount));
+        });
     }
 }
 exports.TransferBuilder = TransferBuilder;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJCdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90cmFuc2ZlckJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkRBQTBEO0FBRTFELG1EQUF1RDtBQUV2RCxNQUFhLGVBQWdCLFNBQVEsdUNBQWtCO0lBQ3JELFlBQVksV0FBaUM7UUFDM0MsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxJQUFjLGVBQWU7UUFDM0IsT0FBTywwQkFBZSxDQUFDLElBQUksQ0FBQztJQUM5QixDQUFDO0NBQ0Y7QUFSRCwwQ0FRQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRyYW5zYWN0aW9uQnVpbGRlciB9IGZyb20gJy4vdHJhbnNhY3Rpb25CdWlsZGVyJztcbmltcG9ydCB7IEJhc2VDb2luIGFzIENvaW5Db25maWcgfSBmcm9tICdAYml0Z28tYmV0YS9zdGF0aWNzJztcbmltcG9ydCB7IFRyYW5zYWN0aW9uVHlwZSB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcblxuZXhwb3J0IGNsYXNzIFRyYW5zZmVyQnVpbGRlciBleHRlbmRzIFRyYW5zYWN0aW9uQnVpbGRlciB7XG4gIGNvbnN0cnVjdG9yKF9jb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKF9jb2luQ29uZmlnKTtcbiAgfVxuXG4gIHByb3RlY3RlZCBnZXQgdHJhbnNhY3Rpb25UeXBlKCk6IFRyYW5zYWN0aW9uVHlwZSB7XG4gICAgcmV0dXJuIFRyYW5zYWN0aW9uVHlwZS5TZW5kO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJCdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90cmFuc2ZlckJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsNkRBQTBEO0FBRTFELCtEQUE0RDtBQUM1RCxtREFBbUY7QUFDbkYsZ0VBQXFDO0FBSXJDOzs7R0FHRztBQUNILE1BQWEsZUFBZ0IsU0FBUSx1Q0FBa0I7SUFDckQsWUFBWSxXQUFpQztRQUMzQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDbkIsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLHlDQUFtQixDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQzNELENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILFVBQVUsQ0FBQyxVQUFrQztRQUMzQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDcEMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDakQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxjQUFjLENBQUMsY0FBd0M7UUFDckQsSUFBSSxDQUFDLG1CQUFtQixDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUM7UUFDekQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILFdBQVcsQ0FBQyxFQUFlO1FBQ3pCLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNqQyxLQUFLLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxFQUF5QixDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVEOztPQUVHO0lBQ0ssdUJBQXVCLENBQUMsRUFBZTtRQUM3QyxJQUFJLENBQUMsQ0FBQyxFQUFFLFlBQVkseUNBQW1CLENBQUMsRUFBRSxDQUFDO1lBQ3pDLE1BQU0sSUFBSSxnQ0FBcUIsQ0FBQyxpREFBaUQsQ0FBQyxDQUFDO1FBQ3JGLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSyxnQkFBZ0IsQ0FBQyxFQUF1QjtRQUM5QyxJQUFJLENBQUMsbUJBQW1CLENBQUMsVUFBVSxHQUFHLEVBQUUsQ0FBQyxVQUFVLENBQUM7UUFDcEQsSUFBSSxDQUFDLG1CQUFtQixDQUFDLGNBQWMsR0FBRyxFQUFFLENBQUMsY0FBYyxDQUFDO0lBQzlELENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsbUJBQW1CLENBQUMsV0FBeUI7UUFDM0MsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ2pCLE1BQU0sSUFBSSxnQ0FBcUIsQ0FBQyx3Q0FBd0MsQ0FBQyxDQUFDO1FBQzVFLENBQUM7UUFFRCxJQUFJLENBQUMsdUJBQXVCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDMUMsS0FBSyxDQUFDLG1CQUFtQixDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3ZDLElBQUksQ0FBQyxrQkFBa0IsQ0FBRSxXQUFtQyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQzNFLENBQUM7SUFFRDs7T0FFRztJQUNILElBQWMsbUJBQW1CO1FBQy9CLE9BQU8sSUFBSSxDQUFDLFlBQW1DLENBQUM7SUFDbEQsQ0FBQztJQUVEOzs7O09BSUc7SUFDSyxrQkFBa0IsQ0FBQyxVQUFrQztRQUMzRCxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUU7WUFDL0IsSUFBSSxDQUFDLGVBQWUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxTQUFTLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUNyRCxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksc0JBQVMsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUN0RCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRjtBQTFGRCwwQ0EwRkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUcmFuc2FjdGlvbkJ1aWxkZXIgfSBmcm9tICcuL3RyYW5zYWN0aW9uQnVpbGRlcic7XG5pbXBvcnQgeyBCYXNlQ29pbiBhcyBDb2luQ29uZmlnIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5pbXBvcnQgeyBUcmFuc2ZlclRyYW5zYWN0aW9uIH0gZnJvbSAnLi90cmFuc2ZlclRyYW5zYWN0aW9uJztcbmltcG9ydCB7IEJ1aWxkVHJhbnNhY3Rpb25FcnJvciwgVHJhbnNhY3Rpb25SZWNpcGllbnQgfSBmcm9tICdAYml0Z28tYmV0YS9zZGstY29yZSc7XG5pbXBvcnQgQmlnTnVtYmVyIGZyb20gJ2JpZ251bWJlci5qcyc7XG5pbXBvcnQgeyBUcmFuc2FjdGlvbiB9IGZyb20gJy4vdHJhbnNhY3Rpb24nO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb25PYmplY3RJbnB1dCB9IGZyb20gJy4vaWZhY2UnO1xuXG4vKipcbiAqIEJ1aWxkZXIgZm9yIElPVEEgdHJhbnNmZXIgdHJhbnNhY3Rpb25zLlxuICogSGFuZGxlcyB0cmFuc2FjdGlvbnMgdGhhdCB0cmFuc2ZlciBJT1RBIHRva2VucyBmcm9tIHRoZSBzZW5kZXIgdG8gb25lIG9yIG1vcmUgcmVjaXBpZW50cy5cbiAqL1xuZXhwb3J0IGNsYXNzIFRyYW5zZmVyQnVpbGRlciBleHRlbmRzIFRyYW5zYWN0aW9uQnVpbGRlciB7XG4gIGNvbnN0cnVjdG9yKF9jb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKF9jb2luQ29uZmlnKTtcbiAgICB0aGlzLl90cmFuc2FjdGlvbiA9IG5ldyBUcmFuc2ZlclRyYW5zYWN0aW9uKF9jb2luQ29uZmlnKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBTZXRzIHRoZSByZWNpcGllbnRzIGZvciB0aGlzIHRyYW5zZmVyIHRyYW5zYWN0aW9uLlxuICAgKiBAcGFyYW0gcmVjaXBpZW50cyAtIEFycmF5IG9mIHJlY2lwaWVudHMgd2l0aCB0aGVpciBhZGRyZXNzZXMgYW5kIGFtb3VudHNcbiAgICogQHJldHVybnMgVGhpcyBidWlsZGVyIGZvciBtZXRob2QgY2hhaW5pbmdcbiAgICogQHRocm93cyBCdWlsZFRyYW5zYWN0aW9uRXJyb3IgaWYgYW55IHJlY2lwaWVudCBpcyBpbnZhbGlkXG4gICAqL1xuICByZWNpcGllbnRzKHJlY2lwaWVudHM6IFRyYW5zYWN0aW9uUmVjaXBpZW50W10pOiB0aGlzIHtcbiAgICB0aGlzLnZhbGlkYXRlUmVjaXBpZW50cyhyZWNpcGllbnRzKTtcbiAgICB0aGlzLnRyYW5zZmVyVHJhbnNhY3Rpb24ucmVjaXBpZW50cyA9IHJlY2lwaWVudHM7XG4gICAgcmV0dXJuIHRoaXM7XG4gIH1cblxuICAvKipcbiAgICogU2V0cyB0aGUgcGF5bWVudCBvYmplY3RzIChjb2luIG9iamVjdHMpIHRvIGJlIHVzZWQgZm9yIHRoaXMgdHJhbnNmZXIuXG4gICAqIFRoZXNlIGFyZSB0aGUgc291cmNlIGNvaW5zIHRoYXQgd2lsbCBiZSBzcGxpdCBhbmQgdHJhbnNmZXJyZWQgdG8gcmVjaXBpZW50cy5cbiAgICogQHBhcmFtIHBheW1lbnRPYmplY3RzIC0gQXJyYXkgb2YgSU9UQSBjb2luIG9iamVjdHMgdG8gdXNlIGZvciBwYXltZW50XG4gICAqIEByZXR1cm5zIFRoaXMgYnVpbGRlciBmb3IgbWV0aG9kIGNoYWluaW5nXG4gICAqL1xuICBwYXltZW50T2JqZWN0cyhwYXltZW50T2JqZWN0czogVHJhbnNhY3Rpb25PYmplY3RJbnB1dFtdKTogdGhpcyB7XG4gICAgdGhpcy50cmFuc2ZlclRyYW5zYWN0aW9uLnBheW1lbnRPYmplY3RzID0gcGF5bWVudE9iamVjdHM7XG4gICAgcmV0dXJuIHRoaXM7XG4gIH1cblxuICAvKipcbiAgICogSW5pdGlhbGl6ZXMgdGhlIGJ1aWxkZXIgd2l0aCBkYXRhIGZyb20gYW4gZXhpc3RpbmcgdHJhbnNmZXIgdHJhbnNhY3Rpb24uXG4gICAqIEBwYXJhbSB0eCAtIFRoZSBzb3VyY2UgdHJhbnNhY3Rpb24gdG8gY29weSBkYXRhIGZyb21cbiAgICogQHRocm93cyBCdWlsZFRyYW5zYWN0aW9uRXJyb3IgaWYgdHJhbnNhY3Rpb24gaXMgbm90IGEgVHJhbnNmZXJUcmFuc2FjdGlvblxuICAgKi9cbiAgaW5pdEJ1aWxkZXIodHg6IFRyYW5zYWN0aW9uKTogdm9pZCB7XG4gICAgdGhpcy52YWxpZGF0ZVRyYW5zYWN0aW9uVHlwZSh0eCk7XG4gICAgc3VwZXIuaW5pdEJ1aWxkZXIodHgpO1xuICAgIHRoaXMuY29weVRyYW5zZmVyRGF0YSh0eCBhcyBUcmFuc2ZlclRyYW5zYWN0aW9uKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBWYWxpZGF0ZXMgdGhhdCB0aGUgdHJhbnNhY3Rpb24gaXMgb2YgdGhlIGNvcnJlY3QgdHlwZSAoVHJhbnNmZXJUcmFuc2FjdGlvbikuXG4gICAqL1xuICBwcml2YXRlIHZhbGlkYXRlVHJhbnNhY3Rpb25UeXBlKHR4OiBUcmFuc2FjdGlvbik6IHZvaWQge1xuICAgIGlmICghKHR4IGluc3RhbmNlb2YgVHJhbnNmZXJUcmFuc2FjdGlvbikpIHtcbiAgICAgIHRocm93IG5ldyBCdWlsZFRyYW5zYWN0aW9uRXJyb3IoJ1RyYW5zYWN0aW9uIG11c3QgYmUgb2YgdHlwZSBUcmFuc2ZlclRyYW5zYWN0aW9uJyk7XG4gICAgfVxuICB9XG5cbiAgLyoqXG4gICAqIENvcGllcyB0cmFuc2Zlci1zcGVjaWZpYyBkYXRhIGZyb20gc291cmNlIHRyYW5zYWN0aW9uLlxuICAgKi9cbiAgcHJpdmF0ZSBjb3B5VHJhbnNmZXJEYXRhKHR4OiBUcmFuc2ZlclRyYW5zYWN0aW9uKTogdm9pZCB7XG4gICAgdGhpcy50cmFuc2ZlclRyYW5zYWN0aW9uLnJlY2lwaWVudHMgPSB0eC5yZWNpcGllbnRzO1xuICAgIHRoaXMudHJhbnNmZXJUcmFuc2FjdGlvbi5wYXltZW50T2JqZWN0cyA9IHR4LnBheW1lbnRPYmplY3RzO1xuICB9XG5cbiAgLyoqXG4gICAqIFZhbGlkYXRlcyBhIGNvbXBsZXRlIHRyYW5zZmVyIHRyYW5zYWN0aW9uLlxuICAgKiBAcGFyYW0gdHJhbnNhY3Rpb24gLSBUaGUgdHJhbnNhY3Rpb24gdG8gdmFsaWRhdGVcbiAgICogQHRocm93cyBCdWlsZFRyYW5zYWN0aW9uRXJyb3IgaWYgdHJhbnNhY3Rpb24gaXMgaW52YWxpZCBvciBub3QgYSBUcmFuc2ZlclRyYW5zYWN0aW9uXG4gICAqL1xuICB2YWxpZGF0ZVRyYW5zYWN0aW9uKHRyYW5zYWN0aW9uPzogVHJhbnNhY3Rpb24pOiB2b2lkIHtcbiAgICBpZiAoIXRyYW5zYWN0aW9uKSB7XG4gICAgICB0aHJvdyBuZXcgQnVpbGRUcmFuc2FjdGlvbkVycm9yKCdUcmFuc2FjdGlvbiBpcyByZXF1aXJlZCBmb3IgdmFsaWRhdGlvbicpO1xuICAgIH1cblxuICAgIHRoaXMudmFsaWRhdGVUcmFuc2FjdGlvblR5cGUodHJhbnNhY3Rpb24pO1xuICAgIHN1cGVyLnZhbGlkYXRlVHJhbnNhY3Rpb24odHJhbnNhY3Rpb24pO1xuICAgIHRoaXMudmFsaWRhdGVSZWNpcGllbnRzKCh0cmFuc2FjdGlvbiBhcyBUcmFuc2ZlclRyYW5zYWN0aW9uKS5yZWNpcGllbnRzKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIHRoZSB0cmFuc2FjdGlvbiBhcyBhIFRyYW5zZmVyVHJhbnNhY3Rpb24gdHlwZS5cbiAgICovXG4gIHByb3RlY3RlZCBnZXQgdHJhbnNmZXJUcmFuc2FjdGlvbigpOiBUcmFuc2ZlclRyYW5zYWN0aW9uIHtcbiAgICByZXR1cm4gdGhpcy5fdHJhbnNhY3Rpb24gYXMgVHJhbnNmZXJUcmFuc2FjdGlvbjtcbiAgfVxuXG4gIC8qKlxuICAgKiBWYWxpZGF0ZXMgYWxsIHJlY2lwaWVudHMgaGF2ZSB2YWxpZCBhZGRyZXNzZXMgYW5kIGFtb3VudHMuXG4gICAqIEBwYXJhbSByZWNpcGllbnRzIC0gQXJyYXkgb2YgcmVjaXBpZW50cyB0byB2YWxpZGF0ZVxuICAgKiBAdGhyb3dzIEJ1aWxkVHJhbnNhY3Rpb25FcnJvciBpZiBhbnkgcmVjaXBpZW50IGhhcyBpbnZhbGlkIGFkZHJlc3Mgb3IgYW1vdW50XG4gICAqL1xuICBwcml2YXRlIHZhbGlkYXRlUmVjaXBpZW50cyhyZWNpcGllbnRzOiBUcmFuc2FjdGlvblJlY2lwaWVudFtdKTogdm9pZCB7XG4gICAgcmVjaXBpZW50cy5mb3JFYWNoKChyZWNpcGllbnQpID0+IHtcbiAgICAgIHRoaXMudmFsaWRhdGVBZGRyZXNzKHsgYWRkcmVzczogcmVjaXBpZW50LmFkZHJlc3MgfSk7XG4gICAgICB0aGlzLnZhbGlkYXRlVmFsdWUobmV3IEJpZ051bWJlcihyZWNpcGllbnQuYW1vdW50KSk7XG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,124 @@
+import { TransactionRecipient } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction } from './transaction';
+import { TransactionExplanation, TransactionObjectInput, TransferTxData, TxData } from './iface';
+export declare class TransferTransaction extends Transaction {
+    private _recipients;
+    private _paymentObjects?;
+    constructor(coinConfig: Readonly<CoinConfig>);
+    get recipients(): TransactionRecipient[];
+    set recipients(value: TransactionRecipient[]);
+    get paymentObjects(): TransactionObjectInput[] | undefined;
+    set paymentObjects(value: TransactionObjectInput[] | undefined);
+    /**
+     * @inheritDoc
+     */
+    addInputsAndOutputs(): void;
+    toJson(): TransferTxData;
+    parseFromJSON(txData: TransferTxData): void;
+    /**
+     * Parses a transfer transaction from its broadcast format (base64 or raw bytes).
+     * Extracts recipients, amounts, and payment objects from the transaction data.
+     */
+    parseFromBroadcastTx(tx: string | Uint8Array): void;
+    /**
+     * Validates that the transaction only contains supported transfer commands.
+     */
+    private validateTransferCommands;
+    /**
+     * Parses transaction inputs to extract objects, amounts, and receiver addresses.
+     */
+    private parseTransactionInputs;
+    /**
+     * Validates that the number of amounts matches the number of receivers.
+     */
+    private validateAmountsMatchReceivers;
+    /**
+     * 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.
+     */
+    private assignParsedObjects;
+    /**
+     * Creates and assigns recipients from parsed addresses and amounts.
+     */
+    private assignRecipients;
+    protected messageWithIntent(message: Uint8Array): Uint8Array;
+    /**
+     * 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.
+     */
+    protected populateTxInputsAndCommands(): void;
+    /**
+     * 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.
+     */
+    private getConsolidatedSourceCoin;
+    /**
+     * 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.
+     */
+    private hasPaymentObjects;
+    /**
+     * Consolidates payment objects into a single coin object.
+     * If multiple payment objects exist, they are merged in batches.
+     */
+    private consolidatePaymentObjects;
+    /**
+     * Consolidates gas payment objects into a single coin object.
+     * If the number of gas objects exceeds the maximum, they are merged in batches.
+     */
+    private consolidateGasObjects;
+    /**
+     * 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
+     */
+    private mergeObjectsInBatches;
+    /**
+     * 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.
+     */
+    private splitAndTransferToRecipients;
+    /**
+     * Validates all transfer transaction data before building.
+     * Checks recipients, payment objects, and ensures no duplicate object IDs.
+     */
+    protected validateTxDataImplementation(): void;
+    /**
+     * Validates that recipients exist and don't exceed the maximum allowed.
+     */
+    private validateRecipientsList;
+    /**
+     * 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.
+     */
+    private validatePaymentObjectsExist;
+    /**
+     * Validates that there are no duplicate object IDs within payment objects,
+     * gas payment objects, or between the two groups.
+     */
+    private validateNoDuplicateObjects;
+    /**
+     * Helper to check for duplicate IDs in an array.
+     */
+    private checkForDuplicateIds;
+    /**
+     * @inheritDoc
+     * Provides a human-readable explanation of the transfer transaction.
+     */
+    protected explainTransactionImplementation(_json: TxData, explanationResult: TransactionExplanation): TransactionExplanation;
+    /**
+     * Calculates the total amount being transferred to all recipients.
+     */
+    private calculateTotalOutputAmount;
+}
+//# sourceMappingURL=transferTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transferTransaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transferTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,oBAAoB,EAAmB,MAAM,sBAAsB,CAAC;AAC7G,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAajG,qBAAa,mBAAoB,SAAQ,WAAW;IAClD,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,eAAe,CAAC,CAA2B;gBAEvC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAO5C,IAAI,UAAU,IAAI,oBAAoB,EAAE,CAEvC;IAED,IAAI,UAAU,CAAC,KAAK,EAAE,oBAAoB,EAAE,EAG3C;IAED,IAAI,cAAc,IAAI,sBAAsB,EAAE,GAAG,SAAS,CAEzD;IAED,IAAI,cAAc,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,SAAS,EAG7D;IAED;;OAEG;IACH,mBAAmB,IAAI,IAAI;IAmB3B,MAAM,IAAI,cAAc;IAQxB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAO3C;;;OAGG;IACH,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAanD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAUhC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA6B9B;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAMrC;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAe3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAOxB,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU;IAI5D;;;;OAIG;IACH,SAAS,CAAC,2BAA2B,IAAI,IAAI;IAK7C;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IAOjC;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAgBjC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAe7B;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;IAa7B;;;;OAIG;IACH,OAAO,CAAC,4BAA4B;IASpC;;;OAGG;IACH,SAAS,CAAC,4BAA4B,IAAI,IAAI;IAM9C;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAmBnC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAwBlC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAO5B;;;OAGG;IACH,SAAS,CAAC,gCAAgC,CACxC,KAAK,EAAE,MAAM,EACb,iBAAiB,EAAE,sBAAsB,GACxC,sBAAsB;IAWzB;;OAEG;IACH,OAAO,CAAC,0BAA0B;CAKnC"}