@bitgo-beta/sdk-coin-sol 7.6.4-beta.62 → 7.6.4-beta.621

package/dist/esm/lib/transactionBuilderFactory.d.ts

@@ -0,0 +1,120 @@
+import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { AtaInitializationBuilder } from './ataInitializationBuilder';
+import { CloseAtaBuilder } from './closeAtaBuilder';
+import { RecoverNestedAtaBuilder } from './recoverNestedAtaBuilder';
+import { CustomInstructionBuilder } from './customInstructionBuilder';
+import { StakingActivateBuilder } from './stakingActivateBuilder';
+import { StakingAuthorizeBuilder } from './stakingAuthorizeBuilder';
+import { StakingDeactivateBuilder } from './stakingDeactivateBuilder';
+import { StakingDelegateBuilder } from './stakingDelegateBuilder';
+import { StakingRawMsgAuthorizeBuilder } from './stakingRawMsgAuthorizeBuilder';
+import { StakingWithdrawBuilder } from './stakingWithdrawBuilder';
+import { TokenTransferBuilder } from './tokenTransferBuilder';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { TransferBuilder } from './transferBuilder';
+import { TransferBuilderV2 } from './transferBuilderV2';
+import { WalletInitializationBuilder } from './walletInitializationBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Returns a proper builder for the given encoded transaction
+     *
+     * @param { string} raw - Encoded transaction in base64 string format
+     */
+    from(raw: string): TransactionBuilder | StakingRawMsgAuthorizeBuilder;
+    /** @inheritdoc */
+    getWalletInitializationBuilder(tx?: Transaction): WalletInitializationBuilder;
+    /** @inheritdoc */
+    getTransferBuilder(tx?: Transaction): TransferBuilder;
+    /** @inheritdoc */
+    getTokenTransferBuilder(tx?: Transaction): TokenTransferBuilder;
+    /**
+     * Returns the transfer builder V2 to create a funds transfer transaction
+     */
+    getTransferBuilderV2(tx?: Transaction): TransferBuilderV2;
+    /**
+     * Returns the staking builder to create a staking account and also a delegate in one transaction.
+     * once the tx reach the network it will automatically by activated on next epoch
+     *
+     * @see https://docs.solana.com/cluster/stake-delegation-and-rewards#stake-warmup-cooldown-withdrawal
+     *
+     * @param {Transaction} tx - the transaction to be used to initialize the builder
+     * @returns {StakingDeactivateBuilder} - the initialized staking activate builder
+     */
+    getStakingActivateBuilder(tx?: Transaction): StakingActivateBuilder;
+    /**
+     * Returns the builder to create a staking deactivate transaction.
+     * Deactivated is set in the current epoch + cooldown
+     * The account's stake will ramp down to zero by that epoch, and the lamports will be available for withdrawal.
+     *
+     * @see https://docs.solana.com/cluster/stake-delegation-and-rewards#stake-warmup-cooldown-withdrawal
+     *
+     * @param {Transaction} tx - the transaction to be used to initialize the builder
+     * @returns {StakingDeactivateBuilder} - the initialized staking deactivate builder
+     */
+    getStakingDeactivateBuilder(tx?: Transaction): StakingDeactivateBuilder;
+    /**
+     * Returns the builder to create a staking withdraw transaction.
+     * once the staking account reach 0 SOL it will not be traceable anymore by the network
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#destroying-a-stake-account
+     *
+     * @param {Transaction} tx - the transaction to be used to intialize the builder
+     * @returns {StakingWithdrawBuilder} - the initialized staking withdraw builder
+     */
+    getStakingWithdrawBuilder(tx?: Transaction): StakingWithdrawBuilder;
+    /**
+     * Returns the builder to authorized staking account.
+     *
+     * @param {Transaction} tx - the transaction to be used to intialize the builder
+     * @returns {StakingAuthorizeBuilder} - the initialized staking authorize builder
+     */
+    getStakingAuthorizeBuilder(tx?: Transaction): StakingAuthorizeBuilder;
+    /**
+     * Returns the builder to delegate staking account.
+     *
+     * @param {Transaction} tx - the transaction to be used to delegate staking account
+     * @returns {StakingDelegateBuilder} - the staking delegate builder
+     */
+    getStakingDelegateBuilder(tx?: Transaction): StakingDelegateBuilder;
+    /**
+     * Returns the raw message builder to authorized staking account.
+     *
+     * @param {Transaction} tx - the transaction to be used to intialize the builder
+     * @returns {StakingWithdrawBuilder} - the initialized staking authorize builder
+     */
+    getStakingRawMsgAuthorizeBuilder(tx?: Transaction): StakingRawMsgAuthorizeBuilder;
+    /**
+     * Returns the builder to create a create associated token account transaction.
+     */
+    getAtaInitializationBuilder(tx?: Transaction): AtaInitializationBuilder;
+    /**
+     * Returns the builder to create a close associated token account transaction.
+     */
+    getCloseAtaInitializationBuilder(tx?: Transaction): CloseAtaBuilder;
+    /**
+     * Returns the builder to recover tokens from a nested ATA (an ATA owned by another ATA).
+     */
+    getRecoverNestedAtaBuilder(tx?: Transaction): RecoverNestedAtaBuilder;
+    /**
+     * Returns the builder to create transactions with custom Solana instructions.
+     */
+    getCustomInstructionBuilder(tx?: Transaction): CustomInstructionBuilder;
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    private initializeBuilder;
+    /** Parse the transaction from a raw transaction
+     *
+     * @param {string} rawTransaction - the raw tx
+     * @returns {Transaction} parsed transaction
+     */
+    private parseTransaction;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

package/dist/esm/lib/transactionBuilderFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAA4C,MAAM,sBAAsB,CAAC;AAC/G,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,GAAG,6BAA6B;IA0CrE,kBAAkB;IAClB,8BAA8B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,2BAA2B;IAI7E,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,kBAAkB;IAClB,uBAAuB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,oBAAoB;IAI/D;;OAEG;IACH,oBAAoB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,iBAAiB;IAIzD;;;;;;;;OAQG;IACH,yBAAyB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,sBAAsB;IAInE;;;;;;;;;OASG;IACH,2BAA2B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,wBAAwB;IAIvE;;;;;;;;OAQG;IACH,yBAAyB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,sBAAsB;IAInE;;;;;OAKG;IACH,0BAA0B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,uBAAuB;IAGrE;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,sBAAsB;IAInE;;;;;OAKG;IACH,gCAAgC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,6BAA6B;IAQjF;;OAEG;IACH,2BAA2B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,wBAAwB;IAIvE;;OAEG;IACH,gCAAgC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAInE;;OAEG;IACH,0BAA0B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,uBAAuB;IAIrE;;OAEG;IACH,2BAA2B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,wBAAwB;IAIvE;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAMzB"}

package/dist/esm/lib/transactionBuilderFactory.js

@@ -0,0 +1,205 @@
+import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { AtaInitializationBuilder } from './ataInitializationBuilder';
+import { CloseAtaBuilder } from './closeAtaBuilder';
+import { RecoverNestedAtaBuilder } from './recoverNestedAtaBuilder';
+import { CustomInstructionBuilder } from './customInstructionBuilder';
+import { StakingActivateBuilder } from './stakingActivateBuilder';
+import { StakingAuthorizeBuilder } from './stakingAuthorizeBuilder';
+import { StakingDeactivateBuilder } from './stakingDeactivateBuilder';
+import { StakingDelegateBuilder } from './stakingDelegateBuilder';
+import { StakingRawMsgAuthorizeBuilder } from './stakingRawMsgAuthorizeBuilder';
+import { StakingWithdrawBuilder } from './stakingWithdrawBuilder';
+import { TokenTransferBuilder } from './tokenTransferBuilder';
+import { Transaction } from './transaction';
+import { TransferBuilder } from './transferBuilder';
+import { TransferBuilderV2 } from './transferBuilderV2';
+import { validateRawTransaction } from './utils';
+import { WalletInitializationBuilder } from './walletInitializationBuilder';
+export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     * Returns a proper builder for the given encoded transaction
+     *
+     * @param { string} raw - Encoded transaction in base64 string format
+     */
+    from(raw) {
+        validateRawTransaction(raw);
+        const tx = this.parseTransaction(raw);
+        try {
+            switch (tx.type) {
+                case TransactionType.Send:
+                    const uniqueInputCoins = tx.inputs
+                        .map((input) => input.coin)
+                        .filter((coin, index, arr) => arr.indexOf(coin) === index);
+                    if (uniqueInputCoins.includes('sol') || uniqueInputCoins.includes('tsol')) {
+                        return this.getTransferBuilderV2(tx);
+                    }
+                    else {
+                        return this.getTokenTransferBuilder(tx);
+                    }
+                case TransactionType.WalletInitialization:
+                    return this.getWalletInitializationBuilder(tx);
+                case TransactionType.StakingActivate:
+                    return this.getStakingActivateBuilder(tx);
+                case TransactionType.StakingDeactivate:
+                    return this.getStakingDeactivateBuilder(tx);
+                case TransactionType.StakingWithdraw:
+                    return this.getStakingWithdrawBuilder(tx);
+                case TransactionType.AssociatedTokenAccountInitialization:
+                    return this.getAtaInitializationBuilder(tx);
+                case TransactionType.StakingAuthorize:
+                    return this.getStakingAuthorizeBuilder(tx);
+                case TransactionType.StakingAuthorizeRaw:
+                    return this.getStakingRawMsgAuthorizeBuilder(tx);
+                case TransactionType.StakingDelegate:
+                    return this.getStakingDelegateBuilder(tx);
+                case TransactionType.CloseAssociatedTokenAccount:
+                    return this.getCloseAtaInitializationBuilder(tx);
+                case TransactionType.CustomTx:
+                    return this.getCustomInstructionBuilder(tx);
+                default:
+                    throw new InvalidTransactionError('Invalid transaction');
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder(tx) {
+        return this.initializeBuilder(tx, new WalletInitializationBuilder(this._coinConfig));
+    }
+    /** @inheritdoc */
+    getTransferBuilder(tx) {
+        return this.initializeBuilder(tx, new TransferBuilder(this._coinConfig));
+    }
+    /** @inheritdoc */
+    getTokenTransferBuilder(tx) {
+        return this.initializeBuilder(tx, new TokenTransferBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the transfer builder V2 to create a funds transfer transaction
+     */
+    getTransferBuilderV2(tx) {
+        return this.initializeBuilder(tx, new TransferBuilderV2(this._coinConfig));
+    }
+    /**
+     * Returns the staking builder to create a staking account and also a delegate in one transaction.
+     * once the tx reach the network it will automatically by activated on next epoch
+     *
+     * @see https://docs.solana.com/cluster/stake-delegation-and-rewards#stake-warmup-cooldown-withdrawal
+     *
+     * @param {Transaction} tx - the transaction to be used to initialize the builder
+     * @returns {StakingDeactivateBuilder} - the initialized staking activate builder
+     */
+    getStakingActivateBuilder(tx) {
+        return this.initializeBuilder(tx, new StakingActivateBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the builder to create a staking deactivate transaction.
+     * Deactivated is set in the current epoch + cooldown
+     * The account's stake will ramp down to zero by that epoch, and the lamports will be available for withdrawal.
+     *
+     * @see https://docs.solana.com/cluster/stake-delegation-and-rewards#stake-warmup-cooldown-withdrawal
+     *
+     * @param {Transaction} tx - the transaction to be used to initialize the builder
+     * @returns {StakingDeactivateBuilder} - the initialized staking deactivate builder
+     */
+    getStakingDeactivateBuilder(tx) {
+        return this.initializeBuilder(tx, new StakingDeactivateBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the builder to create a staking withdraw transaction.
+     * once the staking account reach 0 SOL it will not be traceable anymore by the network
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#destroying-a-stake-account
+     *
+     * @param {Transaction} tx - the transaction to be used to intialize the builder
+     * @returns {StakingWithdrawBuilder} - the initialized staking withdraw builder
+     */
+    getStakingWithdrawBuilder(tx) {
+        return this.initializeBuilder(tx, new StakingWithdrawBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the builder to authorized staking account.
+     *
+     * @param {Transaction} tx - the transaction to be used to intialize the builder
+     * @returns {StakingAuthorizeBuilder} - the initialized staking authorize builder
+     */
+    getStakingAuthorizeBuilder(tx) {
+        return this.initializeBuilder(tx, new StakingAuthorizeBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the builder to delegate staking account.
+     *
+     * @param {Transaction} tx - the transaction to be used to delegate staking account
+     * @returns {StakingDelegateBuilder} - the staking delegate builder
+     */
+    getStakingDelegateBuilder(tx) {
+        return this.initializeBuilder(tx, new StakingDelegateBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the raw message builder to authorized staking account.
+     *
+     * @param {Transaction} tx - the transaction to be used to intialize the builder
+     * @returns {StakingWithdrawBuilder} - the initialized staking authorize builder
+     */
+    getStakingRawMsgAuthorizeBuilder(tx) {
+        const builder = new StakingRawMsgAuthorizeBuilder(this._coinConfig);
+        if (tx) {
+            builder.initBuilder(tx);
+        }
+        return builder;
+    }
+    /**
+     * Returns the builder to create a create associated token account transaction.
+     */
+    getAtaInitializationBuilder(tx) {
+        return this.initializeBuilder(tx, new AtaInitializationBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the builder to create a close associated token account transaction.
+     */
+    getCloseAtaInitializationBuilder(tx) {
+        return this.initializeBuilder(tx, new CloseAtaBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the builder to recover tokens from a nested ATA (an ATA owned by another ATA).
+     */
+    getRecoverNestedAtaBuilder(tx) {
+        return this.initializeBuilder(tx, new RecoverNestedAtaBuilder(this._coinConfig));
+    }
+    /**
+     * Returns the builder to create transactions with custom Solana instructions.
+     */
+    getCustomInstructionBuilder(tx) {
+        return this.initializeBuilder(tx, new CustomInstructionBuilder(this._coinConfig));
+    }
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    initializeBuilder(tx, builder) {
+        if (tx) {
+            builder.initBuilder(tx);
+        }
+        return builder;
+    }
+    /** Parse the transaction from a raw transaction
+     *
+     * @param {string} rawTransaction - the raw tx
+     * @returns {Transaction} parsed transaction
+     */
+    parseTransaction(rawTransaction) {
+        const tx = new Transaction(this._coinConfig);
+        tx.setUseTokenAddressTokenName(true);
+        tx.fromRawTransaction(rawTransaction);
+        return tx;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { AtaInitializationBuilder } from './ataInitializationBuilder';\nimport { CloseAtaBuilder } from './closeAtaBuilder';\nimport { RecoverNestedAtaBuilder } from './recoverNestedAtaBuilder';\nimport { CustomInstructionBuilder } from './customInstructionBuilder';\nimport { StakingActivateBuilder } from './stakingActivateBuilder';\nimport { StakingAuthorizeBuilder } from './stakingAuthorizeBuilder';\nimport { StakingDeactivateBuilder } from './stakingDeactivateBuilder';\nimport { StakingDelegateBuilder } from './stakingDelegateBuilder';\nimport { StakingRawMsgAuthorizeBuilder } from './stakingRawMsgAuthorizeBuilder';\nimport { StakingWithdrawBuilder } from './stakingWithdrawBuilder';\nimport { TokenTransferBuilder } from './tokenTransferBuilder';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { TransferBuilder } from './transferBuilder';\nimport { TransferBuilderV2 } from './transferBuilderV2';\nimport { validateRawTransaction } from './utils';\nimport { WalletInitializationBuilder } from './walletInitializationBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Returns a proper builder for the given encoded transaction\n   *\n   * @param { string} raw - Encoded transaction in base64 string format\n   */\n  from(raw: string): TransactionBuilder | StakingRawMsgAuthorizeBuilder {\n    validateRawTransaction(raw);\n    const tx = this.parseTransaction(raw);\n    try {\n      switch (tx.type) {\n        case TransactionType.Send:\n          const uniqueInputCoins = tx.inputs\n            .map((input) => input.coin)\n            .filter((coin, index, arr) => arr.indexOf(coin) === index);\n          if (uniqueInputCoins.includes('sol') || uniqueInputCoins.includes('tsol')) {\n            return this.getTransferBuilderV2(tx);\n          } else {\n            return this.getTokenTransferBuilder(tx);\n          }\n        case TransactionType.WalletInitialization:\n          return this.getWalletInitializationBuilder(tx);\n        case TransactionType.StakingActivate:\n          return this.getStakingActivateBuilder(tx);\n        case TransactionType.StakingDeactivate:\n          return this.getStakingDeactivateBuilder(tx);\n        case TransactionType.StakingWithdraw:\n          return this.getStakingWithdrawBuilder(tx);\n        case TransactionType.AssociatedTokenAccountInitialization:\n          return this.getAtaInitializationBuilder(tx);\n        case TransactionType.StakingAuthorize:\n          return this.getStakingAuthorizeBuilder(tx);\n        case TransactionType.StakingAuthorizeRaw:\n          return this.getStakingRawMsgAuthorizeBuilder(tx);\n        case TransactionType.StakingDelegate:\n          return this.getStakingDelegateBuilder(tx);\n        case TransactionType.CloseAssociatedTokenAccount:\n          return this.getCloseAtaInitializationBuilder(tx);\n        case TransactionType.CustomTx:\n          return this.getCustomInstructionBuilder(tx);\n        default:\n          throw new InvalidTransactionError('Invalid transaction');\n      }\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(tx?: Transaction): WalletInitializationBuilder {\n    return this.initializeBuilder(tx, new WalletInitializationBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(tx?: Transaction): TransferBuilder {\n    return this.initializeBuilder(tx, new TransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getTokenTransferBuilder(tx?: Transaction): TokenTransferBuilder {\n    return this.initializeBuilder(tx, new TokenTransferBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the transfer builder V2 to create a funds transfer transaction\n   */\n  getTransferBuilderV2(tx?: Transaction): TransferBuilderV2 {\n    return this.initializeBuilder(tx, new TransferBuilderV2(this._coinConfig));\n  }\n\n  /**\n   * Returns the staking builder to create a staking account and also a delegate in one transaction.\n   * once the tx reach the network it will automatically by activated on next epoch\n   *\n   * @see https://docs.solana.com/cluster/stake-delegation-and-rewards#stake-warmup-cooldown-withdrawal\n   *\n   * @param {Transaction} tx - the transaction to be used to initialize the builder\n   * @returns {StakingDeactivateBuilder} - the initialized staking activate builder\n   */\n  getStakingActivateBuilder(tx?: Transaction): StakingActivateBuilder {\n    return this.initializeBuilder(tx, new StakingActivateBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the builder to create a staking deactivate transaction.\n   * Deactivated is set in the current epoch + cooldown\n   * The account's stake will ramp down to zero by that epoch, and the lamports will be available for withdrawal.\n   *\n   * @see https://docs.solana.com/cluster/stake-delegation-and-rewards#stake-warmup-cooldown-withdrawal\n   *\n   * @param {Transaction} tx - the transaction to be used to initialize the builder\n   * @returns {StakingDeactivateBuilder} - the initialized staking deactivate builder\n   */\n  getStakingDeactivateBuilder(tx?: Transaction): StakingDeactivateBuilder {\n    return this.initializeBuilder(tx, new StakingDeactivateBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the builder to create a staking withdraw transaction.\n   * once the staking account reach 0 SOL it will not be traceable anymore by the network\n   *\n   * @see https://docs.solana.com/staking/stake-accounts#destroying-a-stake-account\n   *\n   * @param {Transaction} tx - the transaction to be used to intialize the builder\n   * @returns {StakingWithdrawBuilder} - the initialized staking withdraw builder\n   */\n  getStakingWithdrawBuilder(tx?: Transaction): StakingWithdrawBuilder {\n    return this.initializeBuilder(tx, new StakingWithdrawBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the builder to authorized staking account.\n   *\n   * @param {Transaction} tx - the transaction to be used to intialize the builder\n   * @returns {StakingAuthorizeBuilder} - the initialized staking authorize builder\n   */\n  getStakingAuthorizeBuilder(tx?: Transaction): StakingAuthorizeBuilder {\n    return this.initializeBuilder(tx, new StakingAuthorizeBuilder(this._coinConfig));\n  }\n  /**\n   * Returns the builder to delegate staking account.\n   *\n   * @param {Transaction} tx - the transaction to be used to delegate staking account\n   * @returns {StakingDelegateBuilder} - the staking delegate builder\n   */\n  getStakingDelegateBuilder(tx?: Transaction): StakingDelegateBuilder {\n    return this.initializeBuilder(tx, new StakingDelegateBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the raw message builder to authorized staking account.\n   *\n   * @param {Transaction} tx - the transaction to be used to intialize the builder\n   * @returns {StakingWithdrawBuilder} - the initialized staking authorize builder\n   */\n  getStakingRawMsgAuthorizeBuilder(tx?: Transaction): StakingRawMsgAuthorizeBuilder {\n    const builder = new StakingRawMsgAuthorizeBuilder(this._coinConfig);\n    if (tx) {\n      builder.initBuilder(tx);\n    }\n    return builder;\n  }\n\n  /**\n   * Returns the builder to create a create associated token account transaction.\n   */\n  getAtaInitializationBuilder(tx?: Transaction): AtaInitializationBuilder {\n    return this.initializeBuilder(tx, new AtaInitializationBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the builder to create a close associated token account transaction.\n   */\n  getCloseAtaInitializationBuilder(tx?: Transaction): CloseAtaBuilder {\n    return this.initializeBuilder(tx, new CloseAtaBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the builder to recover tokens from a nested ATA (an ATA owned by another ATA).\n   */\n  getRecoverNestedAtaBuilder(tx?: Transaction): RecoverNestedAtaBuilder {\n    return this.initializeBuilder(tx, new RecoverNestedAtaBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns the builder to create transactions with custom Solana instructions.\n   */\n  getCustomInstructionBuilder(tx?: Transaction): CustomInstructionBuilder {\n    return this.initializeBuilder(tx, new CustomInstructionBuilder(this._coinConfig));\n  }\n\n  /**\n   * Initialize the builder with the given transaction\n   *\n   * @param {Transaction | undefined} tx - the transaction used to initialize the builder\n   * @param {TransactionBuilder} builder - the builder to be initialized\n   * @returns {TransactionBuilder} the builder initialized\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  /** Parse the transaction from a raw transaction\n   *\n   * @param {string} rawTransaction - the raw tx\n   * @returns {Transaction} parsed transaction\n   */\n  private parseTransaction(rawTransaction: string): Transaction {\n    const tx = new Transaction(this._coinConfig);\n    tx.setUseTokenAddressTokenName(true);\n    tx.fromRawTransaction(rawTransaction);\n    return tx;\n  }\n}\n"]}

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

@@ -0,0 +1,26 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+export interface SendParams {
+    address: string;
+    amount: string;
+}
+export declare class TransferBuilder extends TransactionBuilder {
+    private _sendParams;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    initBuilder(tx: Transaction): void;
+    /**
+     *  Set a transfer
+     *
+     * @param {string} fromAddress - the sender address
+     * @param {string} toAddress - the receiver address
+     * @param {string} amount - the amount sent
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send({ address, amount }: SendParams): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=transferBuilder.d.ts.map

package/dist/esm/lib/transferBuilder.js

@@ -0,0 +1,63 @@
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { isValidAmount, validateAddress } from './utils';
+import { InstructionBuilderTypes } from './constants';
+import assert from 'assert';
+export class TransferBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._sendParams = [];
+    }
+    get transactionType() {
+        return TransactionType.Send;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.Transfer) {
+                const transferInstruction = instruction;
+                this.sender(transferInstruction.params.fromAddress);
+                this.send({
+                    address: transferInstruction.params.toAddress,
+                    amount: transferInstruction.params.amount,
+                });
+            }
+        }
+    }
+    /**
+     *  Set a transfer
+     *
+     * @param {string} fromAddress - the sender address
+     * @param {string} toAddress - the receiver address
+     * @param {string} amount - the amount sent
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send({ address, amount }) {
+        validateAddress(address, 'address');
+        if (!amount || !isValidAmount(amount)) {
+            throw new BuildTransactionError('Invalid or missing amount, got: ' + amount);
+        }
+        if (BigInt(amount) > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new BuildTransactionError(`input amount ${amount} exceeds max safe int ${Number.MAX_SAFE_INTEGER}`);
+        }
+        this._sendParams.push({ address, amount });
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._sender, 'Sender must be set before building the transaction');
+        const transferData = this._sendParams.map((sendParams) => {
+            return {
+                type: InstructionBuilderTypes.Transfer,
+                params: {
+                    fromAddress: this._sender,
+                    toAddress: sendParams.address,
+                    amount: sendParams.amount,
+                },
+            };
+        });
+        this._instructionsData = transferData;
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/transferBuilderV2.d.ts

@@ -0,0 +1,69 @@
+import { TransactionBuilder } from './transactionBuilder';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { ExtraAccountMeta, PermissionlessThawIdempotent, TokenAssociateRecipient } from './iface';
+export interface SendParams {
+    address: string;
+    amount: string;
+    tokenName?: string;
+    tokenAddress?: string;
+    programId?: string;
+    decimalPlaces?: number;
+}
+export declare class TransferBuilderV2 extends TransactionBuilder {
+    private _sendParams;
+    private _createAtaParams;
+    private _transferHookAccounts?;
+    private _permissionlessThaw?;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Set the resolved sRFC-37 Token ACL permissionless-thaw params for this transfer.
+     *
+     * These must be resolved live by the caller (e.g. via `Sol.resolvePermissionlessThaw`) since
+     * builders remain offline and never perform RPC. When set, the built transaction bundles a
+     * `PermissionlessThawIdempotent` instruction after any ATA creation and before the transfer, so
+     * a freshly created (frozen) allowlist/blocklist token account is thawed atomically with the
+     * transfer — all-or-nothing.
+     *
+     * @param {PermissionlessThawIdempotent['params']} params - resolved thaw params
+     * @returns {TransferBuilderV2} This transaction builder
+     */
+    permissionlessThaw(params: PermissionlessThawIdempotent['params']): this;
+    /**
+     * Set the resolved Token-2022 Transfer Hook extra account metas for this transfer.
+     *
+     * These must be resolved live by the caller (e.g. via `Sol.resolveTransferHookAccounts`)
+     * since builders remain offline and never perform RPC. The order is significant and
+     * must match the hook's ExtraAccountMetaList.
+     *
+     * @param {ExtraAccountMeta[]} metas - resolved extra account metas, in hook order
+     * @returns {TransferBuilderV2} This transaction builder
+     */
+    transferHookAccounts(metas: ExtraAccountMeta[]): this;
+    protected get transactionType(): TransactionType;
+    initBuilder(tx: Transaction): void;
+    /**
+     * Set a feePayer
+     * @param payerAddress
+     */
+    feePayer(payerAddress: string): this;
+    /**
+     *  Set a transfer
+     *
+     * @param {SendParams} sendParams - sendParams
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send(sendParams: SendParams): this;
+    /**
+     *
+     * @param {TokenAssociateRecipient} recipient - recipient of the associated token account creation
+     * @param {string} recipient.ownerAddress - owner of the associated token account
+     * @param {string} recipient.tokenName - name of the token that is intended to associate
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    createAssociatedTokenAccount(recipient: TokenAssociateRecipient): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=transferBuilderV2.d.ts.map

package/dist/esm/lib/transferBuilderV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transferBuilderV2.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilderV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAS5C,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAEL,gBAAgB,EAChB,4BAA4B,EAC5B,uBAAuB,EAIxB,MAAM,SAAS,CAAC;AAIjB,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID,qBAAa,iBAAkB,SAAQ,kBAAkB;IACvD,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,qBAAqB,CAAC,CAAqB;IACnD,OAAO,CAAC,mBAAmB,CAAC,CAAyC;gBACzD,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,MAAM,EAAE,4BAA4B,CAAC,QAAQ,CAAC,GAAG,IAAI;IAKxE;;;;;;;;;OASG;IACH,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,IAAI;IAKrD,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA8BlC;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAMpC;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAiBlC;;;;;;OAMG;IACH,4BAA4B,CAAC,SAAS,EAAE,uBAAuB,GAAG,IAAI;IAmBtE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CA4H5D"}