@bitgo/sdk-coin-apt 2.5.4 → 2.6.1

package/dist/src/lib/transaction/customTransaction.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomTransaction = void 0;
+const transaction_1 = require("./transaction");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const validation_1 = require("../utils/validation");
+const utils_1 = __importDefault(require("../utils"));
+/**
+ * Transaction class for custom Aptos transactions.
+ */
+class CustomTransaction extends transaction_1.Transaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._typeArguments = [];
+        this._functionArguments = [];
+        this._type = sdk_core_1.TransactionType.CustomTx;
+    }
+    /**
+     * Set the custom transaction parameters
+     */
+    setCustomTransactionParams(params) {
+        (0, validation_1.validateModuleName)(params.moduleName);
+        (0, validation_1.validateFunctionName)(params.functionName);
+        this._moduleName = params.moduleName;
+        this._functionName = params.functionName;
+        this._typeArguments = params.typeArguments || [];
+        this._functionArguments = params.functionArguments || [];
+        this._entryFunctionAbi = params.abi;
+    }
+    /**
+     * Set the entry function ABI
+     */
+    setEntryFunctionAbi(abi) {
+        this._entryFunctionAbi = abi;
+    }
+    /**
+     * Get the full function name
+     */
+    get fullFunctionName() {
+        if (!this._moduleName || !this._functionName) {
+            return '';
+        }
+        return `${this._moduleName}::${this._functionName}`;
+    }
+    /**
+     * Parse a transaction payload to extract the custom transaction data
+     * Requires ABI information for proper type-aware conversion
+     *
+     * @param {TransactionPayload} payload - The transaction payload to parse
+     */
+    parseTransactionPayload(payload) {
+        if (!(payload instanceof ts_sdk_1.TransactionPayloadEntryFunction)) {
+            throw new sdk_core_1.InvalidTransactionError('Expected entry function payload for custom transaction');
+        }
+        const entryFunction = payload.entryFunction;
+        // Extract function data
+        const moduleAddress = entryFunction.module_name.address.toString();
+        const moduleIdentifier = entryFunction.module_name.name.identifier;
+        const functionIdentifier = entryFunction.function_name.identifier;
+        const moduleName = `${moduleAddress}::${moduleIdentifier}`;
+        // Validate
+        (0, validation_1.validateModuleName)(moduleName);
+        (0, validation_1.validateFunctionName)(functionIdentifier);
+        this._moduleName = moduleName;
+        this._functionName = functionIdentifier;
+        this._typeArguments = entryFunction.type_args.map((typeArg) => typeArg.toString());
+        // Parse arguments using ABI information
+        // If ABI is available, parse with type awareness; otherwise store raw args for later processing
+        if (this._entryFunctionAbi?.parameters) {
+            this._functionArguments = entryFunction.args.map((arg, index) => {
+                const paramType = this._entryFunctionAbi?.parameters?.[index];
+                if (!paramType) {
+                    throw new sdk_core_1.InvalidTransactionError(`Missing ABI parameter type for argument ${index} in ${this._moduleName}::${this._functionName}. ` +
+                        'ABI parameter count mismatch.');
+                }
+                return this.convertArgumentByABI(arg, paramType);
+            });
+        }
+        else {
+            // Store raw arguments temporarily - transaction will be re-parsed when ABI is provided
+            this._functionArguments = entryFunction.args.map((arg) => arg);
+        }
+    }
+    /**
+     * Generate transaction payload data
+     */
+    getTransactionPayloadData() {
+        const functionName = this.getValidatedFullFunctionName();
+        // Arguments are pre-processed during parsing phase
+        const processedArguments = this._functionArguments;
+        return {
+            function: functionName,
+            typeArguments: this._typeArguments,
+            functionArguments: processedArguments,
+            abi: this._entryFunctionAbi,
+        };
+    }
+    /**
+     * Convert argument based on ABI type information
+     */
+    convertArgumentByABI(arg, paramType) {
+        // Helper function to convert bytes to hex string
+        const bytesToHex = (bytes) => {
+            return '0x' + bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+        };
+        // Helper function to try converting a hex string to an AccountAddress
+        const tryToAddress = (hexStr) => {
+            try {
+                return ts_sdk_1.AccountAddress.fromString(hexStr);
+            }
+            catch {
+                return hexStr;
+            }
+        };
+        // Handle primitive values (string, number, boolean)
+        if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {
+            // Address conversion for hex strings
+            if (paramType instanceof ts_sdk_1.TypeTagAddress && typeof arg === 'string' && arg.startsWith('0x')) {
+                return tryToAddress(arg);
+            }
+            // Type conversions based on parameter type
+            if (paramType instanceof ts_sdk_1.TypeTagBool)
+                return Boolean(arg);
+            if (paramType instanceof ts_sdk_1.TypeTagU8 || paramType instanceof ts_sdk_1.TypeTagU16 || paramType instanceof ts_sdk_1.TypeTagU32)
+                return Number(arg);
+            if (paramType instanceof ts_sdk_1.TypeTagU64 || paramType instanceof ts_sdk_1.TypeTagU128 || paramType instanceof ts_sdk_1.TypeTagU256)
+                return String(arg);
+            return arg;
+        }
+        // Handle BCS-encoded data with 'data' property
+        if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {
+            const bytes = Array.from(arg.data);
+            const hexString = bytesToHex(bytes);
+            return paramType instanceof ts_sdk_1.TypeTagAddress ? tryToAddress(hexString) : hexString;
+        }
+        // Handle nested BCS structures with 'value' property
+        if (arg && typeof arg === 'object' && 'value' in arg && arg.value) {
+            // Check if inner value is a Uint8Array (common for U64 arguments)
+            if (arg.value.value && arg.value.value instanceof Uint8Array) {
+                const bytes = Array.from(arg.value.value);
+                if (this.isNumericType(paramType)) {
+                    return this.convertNumericArgument(bytes, paramType);
+                }
+                // For non-numeric types, convert to hex string
+                return bytesToHex(bytes);
+            }
+            // Simple value wrapper
+            if (!('value' in arg.value) || typeof arg.value.value !== 'object') {
+                return this.convertArgumentByABI(arg.value, paramType);
+            }
+            // Double nested structure with numeric keys
+            const bytesObj = arg.value.value;
+            const keys = Object.keys(bytesObj)
+                .filter((k) => !isNaN(parseInt(k, 10)))
+                .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+            if (keys.length === 0)
+                return arg;
+            const bytes = keys.map((k) => bytesObj[k]);
+            let extractedValue;
+            // Convert bytes based on parameter type using unified approach
+            if (this.isNumericType(paramType)) {
+                extractedValue = this.convertNumericArgument(bytes, paramType);
+            }
+            else if (paramType instanceof ts_sdk_1.TypeTagAddress) {
+                extractedValue = bytesToHex(bytes);
+            }
+            else if (paramType instanceof ts_sdk_1.TypeTagBool) {
+                extractedValue = bytes[0] === 1;
+            }
+            else {
+                extractedValue = bytesToHex(bytes);
+            }
+            return this.convertArgumentByABI(extractedValue, paramType);
+        }
+        // For anything else, return as-is
+        return arg;
+    }
+    /**
+     * Get custom transaction parameters
+     */
+    getCustomTransactionParams() {
+        return {
+            moduleName: this._moduleName || '',
+            functionName: this._functionName || '',
+            typeArguments: this._typeArguments,
+            functionArguments: this._functionArguments,
+            abi: this._entryFunctionAbi,
+        };
+    }
+    /**
+     * Override recipient getter for custom transactions
+     */
+    get recipient() {
+        if (this._recipients.length === 0) {
+            return {
+                address: '',
+                amount: '0',
+            };
+        }
+        return this._recipients[0];
+    }
+    /**
+     * Get validated full function name
+     */
+    getValidatedFullFunctionName() {
+        if (!this._moduleName || !this._functionName) {
+            throw new Error('Module name and function name must be set before building transaction');
+        }
+        const fullName = `${this._moduleName}::${this._functionName}`;
+        // Basic validation
+        const fullFunctionPattern = /^(0x[a-fA-F0-9]{1,64}|[a-zA-Z_][a-zA-Z0-9_]*)::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$/;
+        if (!fullFunctionPattern.test(fullName)) {
+            throw new Error(`Invalid full function name format: "${fullName}". Expected format: "address::module::function"`);
+        }
+        return fullName;
+    }
+    /**
+     * Check if a parameter type is a numeric type
+     */
+    isNumericType(paramType) {
+        return (paramType instanceof ts_sdk_1.TypeTagU8 ||
+            paramType instanceof ts_sdk_1.TypeTagU16 ||
+            paramType instanceof ts_sdk_1.TypeTagU32 ||
+            paramType instanceof ts_sdk_1.TypeTagU64 ||
+            paramType instanceof ts_sdk_1.TypeTagU128 ||
+            paramType instanceof ts_sdk_1.TypeTagU256);
+    }
+    /**
+     * Convert numeric argument using consistent little-endian byte handling
+     */
+    convertNumericArgument(bytes, paramType) {
+        if (paramType instanceof ts_sdk_1.TypeTagU8 || paramType instanceof ts_sdk_1.TypeTagU16 || paramType instanceof ts_sdk_1.TypeTagU32) {
+            // Small integers: use Number for compatibility
+            let result = 0;
+            for (let i = bytes.length - 1; i >= 0; i--) {
+                result = result * 256 + bytes[i];
+            }
+            return result;
+        }
+        if (paramType instanceof ts_sdk_1.TypeTagU64 || paramType instanceof ts_sdk_1.TypeTagU128 || paramType instanceof ts_sdk_1.TypeTagU256) {
+            // Large integers: reuse the existing utility method
+            return utils_1.default.getAmountFromPayloadArgs(new Uint8Array(bytes));
+        }
+        // Fallback for unexpected numeric types
+        return '0x' + bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+    }
+}
+exports.CustomTransaction = CustomTransaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customTransaction.js","sourceRoot":"","sources":["../../../../src/lib/transaction/customTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction } from './transaction';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport {\n  EntryFunctionABI,\n  EntryFunctionArgumentTypes,\n  SimpleEntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  TransactionPayload,\n  TransactionPayloadEntryFunction,\n  AccountAddress,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagU8,\n  TypeTagU16,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU128,\n  TypeTagU256,\n} from '@aptos-labs/ts-sdk';\nimport { CustomTransactionParams } from '../iface';\nimport { validateModuleName, validateFunctionName } from '../utils/validation';\nimport utils from '../utils';\n\n/**\n * Transaction class for custom Aptos transactions.\n */\nexport class CustomTransaction extends Transaction {\n  private _moduleName: string;\n  private _functionName: string;\n  private _typeArguments: string[] = [];\n  private _functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes> = [];\n  private _entryFunctionAbi?: EntryFunctionABI;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._type = TransactionType.CustomTx;\n  }\n\n  /**\n   * Set the custom transaction parameters\n   */\n  setCustomTransactionParams(params: CustomTransactionParams): void {\n    validateModuleName(params.moduleName);\n    validateFunctionName(params.functionName);\n\n    this._moduleName = params.moduleName;\n    this._functionName = params.functionName;\n    this._typeArguments = params.typeArguments || [];\n    this._functionArguments = params.functionArguments || [];\n    this._entryFunctionAbi = params.abi;\n  }\n\n  /**\n   * Set the entry function ABI\n   */\n  setEntryFunctionAbi(abi: EntryFunctionABI): void {\n    this._entryFunctionAbi = abi;\n  }\n\n  /**\n   * Get the full function name\n   */\n  get fullFunctionName(): string {\n    if (!this._moduleName || !this._functionName) {\n      return '';\n    }\n    return `${this._moduleName}::${this._functionName}`;\n  }\n\n  /**\n   * Parse a transaction payload to extract the custom transaction data\n   * Requires ABI information for proper type-aware conversion\n   *\n   * @param {TransactionPayload} payload - The transaction payload to parse\n   */\n  protected parseTransactionPayload(payload: TransactionPayload): void {\n    if (!(payload instanceof TransactionPayloadEntryFunction)) {\n      throw new InvalidTransactionError('Expected entry function payload for custom transaction');\n    }\n\n    const entryFunction = payload.entryFunction;\n\n    // Extract function data\n    const moduleAddress = entryFunction.module_name.address.toString();\n    const moduleIdentifier = entryFunction.module_name.name.identifier;\n    const functionIdentifier = entryFunction.function_name.identifier;\n\n    const moduleName = `${moduleAddress}::${moduleIdentifier}`;\n\n    // Validate\n    validateModuleName(moduleName);\n    validateFunctionName(functionIdentifier);\n\n    this._moduleName = moduleName;\n    this._functionName = functionIdentifier;\n    this._typeArguments = entryFunction.type_args.map((typeArg) => typeArg.toString());\n\n    // Parse arguments using ABI information\n    // If ABI is available, parse with type awareness; otherwise store raw args for later processing\n    if (this._entryFunctionAbi?.parameters) {\n      this._functionArguments = entryFunction.args.map((arg: any, index: number) => {\n        const paramType = this._entryFunctionAbi?.parameters?.[index];\n        if (!paramType) {\n          throw new InvalidTransactionError(\n            `Missing ABI parameter type for argument ${index} in ${this._moduleName}::${this._functionName}. ` +\n              'ABI parameter count mismatch.'\n          );\n        }\n        return this.convertArgumentByABI(arg, paramType);\n      });\n    } else {\n      // Store raw arguments temporarily - transaction will be re-parsed when ABI is provided\n      this._functionArguments = entryFunction.args.map((arg: any) => arg);\n    }\n  }\n\n  /**\n   * Generate transaction payload data\n   */\n  protected getTransactionPayloadData(): InputGenerateTransactionPayloadData {\n    const functionName = this.getValidatedFullFunctionName();\n\n    // Arguments are pre-processed during parsing phase\n    const processedArguments = this._functionArguments;\n\n    return {\n      function: functionName,\n      typeArguments: this._typeArguments,\n      functionArguments: processedArguments,\n      abi: this._entryFunctionAbi,\n    } as InputGenerateTransactionPayloadData;\n  }\n\n  /**\n   * Convert argument based on ABI type information\n   */\n  private convertArgumentByABI(arg: any, paramType: any): any {\n    // Helper function to convert bytes to hex string\n    const bytesToHex = (bytes: number[]): string => {\n      return '0x' + bytes.map((b) => b.toString(16).padStart(2, '0')).join('');\n    };\n\n    // Helper function to try converting a hex string to an AccountAddress\n    const tryToAddress = (hexStr: string): any => {\n      try {\n        return AccountAddress.fromString(hexStr);\n      } catch {\n        return hexStr;\n      }\n    };\n\n    // Handle primitive values (string, number, boolean)\n    if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {\n      // Address conversion for hex strings\n      if (paramType instanceof TypeTagAddress && typeof arg === 'string' && arg.startsWith('0x')) {\n        return tryToAddress(arg);\n      }\n\n      // Type conversions based on parameter type\n      if (paramType instanceof TypeTagBool) return Boolean(arg);\n      if (paramType instanceof TypeTagU8 || paramType instanceof TypeTagU16 || paramType instanceof TypeTagU32)\n        return Number(arg);\n      if (paramType instanceof TypeTagU64 || paramType instanceof TypeTagU128 || paramType instanceof TypeTagU256)\n        return String(arg);\n\n      return arg;\n    }\n\n    // Handle BCS-encoded data with 'data' property\n    if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {\n      const bytes = Array.from(arg.data) as number[];\n      const hexString = bytesToHex(bytes);\n\n      return paramType instanceof TypeTagAddress ? tryToAddress(hexString) : hexString;\n    }\n\n    // Handle nested BCS structures with 'value' property\n    if (arg && typeof arg === 'object' && 'value' in arg && arg.value) {\n      // Check if inner value is a Uint8Array (common for U64 arguments)\n      if (arg.value.value && arg.value.value instanceof Uint8Array) {\n        const bytes = Array.from(arg.value.value) as number[];\n        if (this.isNumericType(paramType)) {\n          return this.convertNumericArgument(bytes, paramType);\n        }\n        // For non-numeric types, convert to hex string\n        return bytesToHex(bytes);\n      }\n\n      // Simple value wrapper\n      if (!('value' in arg.value) || typeof arg.value.value !== 'object') {\n        return this.convertArgumentByABI(arg.value, paramType);\n      }\n\n      // Double nested structure with numeric keys\n      const bytesObj = arg.value.value;\n      const keys = Object.keys(bytesObj)\n        .filter((k) => !isNaN(parseInt(k, 10)))\n        .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));\n\n      if (keys.length === 0) return arg;\n\n      const bytes = keys.map((k) => bytesObj[k]);\n      let extractedValue: any;\n\n      // Convert bytes based on parameter type using unified approach\n      if (this.isNumericType(paramType)) {\n        extractedValue = this.convertNumericArgument(bytes, paramType);\n      } else if (paramType instanceof TypeTagAddress) {\n        extractedValue = bytesToHex(bytes);\n      } else if (paramType instanceof TypeTagBool) {\n        extractedValue = bytes[0] === 1;\n      } else {\n        extractedValue = bytesToHex(bytes);\n      }\n\n      return this.convertArgumentByABI(extractedValue, paramType);\n    }\n\n    // For anything else, return as-is\n    return arg;\n  }\n\n  /**\n   * Get custom transaction parameters\n   */\n  getCustomTransactionParams(): CustomTransactionParams {\n    return {\n      moduleName: this._moduleName || '',\n      functionName: this._functionName || '',\n      typeArguments: this._typeArguments,\n      functionArguments: this._functionArguments,\n      abi: this._entryFunctionAbi,\n    };\n  }\n\n  /**\n   * Override recipient getter for custom transactions\n   */\n  get recipient(): any {\n    if (this._recipients.length === 0) {\n      return {\n        address: '',\n        amount: '0',\n      };\n    }\n    return this._recipients[0];\n  }\n\n  /**\n   * Get validated full function name\n   */\n  private getValidatedFullFunctionName(): `${string}::${string}::${string}` {\n    if (!this._moduleName || !this._functionName) {\n      throw new Error('Module name and function name must be set before building transaction');\n    }\n\n    const fullName = `${this._moduleName}::${this._functionName}`;\n\n    // Basic validation\n    const fullFunctionPattern =\n      /^(0x[a-fA-F0-9]{1,64}|[a-zA-Z_][a-zA-Z0-9_]*)::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$/;\n    if (!fullFunctionPattern.test(fullName)) {\n      throw new Error(`Invalid full function name format: \"${fullName}\". Expected format: \"address::module::function\"`);\n    }\n\n    return fullName as `${string}::${string}::${string}`;\n  }\n\n  /**\n   * Check if a parameter type is a numeric type\n   */\n  private isNumericType(paramType: any): boolean {\n    return (\n      paramType instanceof TypeTagU8 ||\n      paramType instanceof TypeTagU16 ||\n      paramType instanceof TypeTagU32 ||\n      paramType instanceof TypeTagU64 ||\n      paramType instanceof TypeTagU128 ||\n      paramType instanceof TypeTagU256\n    );\n  }\n\n  /**\n   * Convert numeric argument using consistent little-endian byte handling\n   */\n  private convertNumericArgument(bytes: number[], paramType: any): any {\n    if (paramType instanceof TypeTagU8 || paramType instanceof TypeTagU16 || paramType instanceof TypeTagU32) {\n      // Small integers: use Number for compatibility\n      let result = 0;\n      for (let i = bytes.length - 1; i >= 0; i--) {\n        result = result * 256 + bytes[i];\n      }\n      return result;\n    }\n\n    if (paramType instanceof TypeTagU64 || paramType instanceof TypeTagU128 || paramType instanceof TypeTagU256) {\n      // Large integers: reuse the existing utility method\n      return utils.getAmountFromPayloadArgs(new Uint8Array(bytes));\n    }\n\n    // Fallback for unexpected numeric types\n    return '0x' + bytes.map((b) => b.toString(16).padStart(2, '0')).join('');\n  }\n}\n"]}

package/dist/src/lib/transactionBuilder/customTransactionBuilder.d.ts

@@ -0,0 +1,64 @@
+import { TransactionType } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { EntryFunctionABI, TransactionPayload } from '@aptos-labs/ts-sdk';
+import { Transaction } from '../transaction/transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { CustomTransaction } from '../transaction/customTransaction';
+import { CustomTransactionParams } from '../iface';
+/**
+ * Builder for Aptos custom transactions.
+ * Allows building transactions with any entry function call.
+ */
+export declare class CustomTransactionBuilder extends TransactionBuilder {
+    protected _transaction: CustomTransaction;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * @returns {TransactionType} The transaction type
+     */
+    protected get transactionType(): TransactionType;
+    /**
+     * Set the custom transaction parameters
+     *
+     * @param {CustomTransactionParams} params - Custom transaction parameters
+     * @returns {CustomTransactionBuilder} The builder instance
+     */
+    customTransaction(params: CustomTransactionParams): CustomTransactionBuilder;
+    /**
+     * Set the entry function ABI
+     *
+     * @param {EntryFunctionABI} abi - The ABI definition for the entry function
+     * @returns {CustomTransactionBuilder} The builder instance
+     */
+    entryFunctionAbi(abi: EntryFunctionABI): CustomTransactionBuilder;
+    /**
+     * @inheritdoc
+     */
+    assetId(assetId: string): TransactionBuilder;
+    /**
+     * Check if a transaction payload is valid for this builder
+     *
+     * @param {TransactionPayload} payload - The transaction payload to check
+     * @returns {boolean} True if the payload is valid for this builder
+     */
+    protected isValidTransactionPayload(payload: TransactionPayload): boolean;
+    /**
+     * Initialize the builder from an existing transaction
+     *
+     * @param {Transaction} tx - The transaction to initialize from
+     */
+    initBuilder(tx: Transaction): void;
+    /**
+     * Build the transaction
+     *
+     * @returns {Promise<CustomTransaction>} The built transaction
+     */
+    build(): Promise<CustomTransaction>;
+    /**
+     * Get the transaction builder instance from an existing transaction
+     *
+     * @param {Transaction} tx - The transaction to convert
+     * @returns {TransactionBuilder} The transaction builder
+     */
+    from(tx: Transaction): TransactionBuilder;
+}
+//# sourceMappingURL=customTransactionBuilder.d.ts.map

package/dist/src/lib/transactionBuilder/customTransactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/transactionBuilder/customTransactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAmC,MAAM,oBAAoB,CAAC;AAC3G,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAGnD;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,kBAAkB;IAC9D,SAAS,CAAC,YAAY,EAAE,iBAAiB,CAAC;gBAE9B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;OAEG;IACH,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,GAAG,wBAAwB;IAa5E;;;;;OAKG;IACH,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,wBAAwB;IAKjE;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB;IAM5C;;;;;OAKG;IACH,SAAS,CAAC,yBAAyB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO;IAsBzE;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAYlC;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,iBAAiB,CAAC;IASzC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,EAAE,WAAW,GAAG,kBAAkB;CAQ1C"}

package/dist/src/lib/transactionBuilder/customTransactionBuilder.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomTransactionBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const transactionBuilder_1 = require("./transactionBuilder");
+const customTransaction_1 = require("../transaction/customTransaction");
+const validation_1 = require("../utils/validation");
+/**
+ * Builder for Aptos custom transactions.
+ * Allows building transactions with any entry function call.
+ */
+class CustomTransactionBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new customTransaction_1.CustomTransaction(_coinConfig);
+    }
+    /**
+     * @returns {TransactionType} The transaction type
+     */
+    get transactionType() {
+        return sdk_core_1.TransactionType.CustomTx;
+    }
+    /**
+     * Set the custom transaction parameters
+     *
+     * @param {CustomTransactionParams} params - Custom transaction parameters
+     * @returns {CustomTransactionBuilder} The builder instance
+     */
+    customTransaction(params) {
+        if (!params.moduleName) {
+            throw new sdk_core_1.BuildTransactionError('Missing module name');
+        }
+        if (!params.functionName) {
+            throw new sdk_core_1.BuildTransactionError('Missing function name');
+        }
+        this._transaction.setCustomTransactionParams(params);
+        return this;
+    }
+    /**
+     * Set the entry function ABI
+     *
+     * @param {EntryFunctionABI} abi - The ABI definition for the entry function
+     * @returns {CustomTransactionBuilder} The builder instance
+     */
+    entryFunctionAbi(abi) {
+        this._transaction.setEntryFunctionAbi(abi);
+        return this;
+    }
+    /**
+     * @inheritdoc
+     */
+    assetId(assetId) {
+        // Asset ID is optional for custom transactions
+        this._transaction.assetId = assetId;
+        return this;
+    }
+    /**
+     * Check if a transaction payload is valid for this builder
+     *
+     * @param {TransactionPayload} payload - The transaction payload to check
+     * @returns {boolean} True if the payload is valid for this builder
+     */
+    isValidTransactionPayload(payload) {
+        // Basic payload type check
+        if (!(payload instanceof ts_sdk_1.TransactionPayloadEntryFunction)) {
+            return false;
+        }
+        try {
+            const entryFunction = payload.entryFunction;
+            // Validate module and function identifiers
+            const moduleAddress = entryFunction.module_name.address.toString();
+            const moduleIdentifier = entryFunction.module_name.name.identifier;
+            const functionIdentifier = entryFunction.function_name.identifier;
+            const moduleName = `${moduleAddress}::${moduleIdentifier}`;
+            if (!(0, validation_1.isValidModuleName)(moduleName) || !(0, validation_1.isValidFunctionName)(functionIdentifier)) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Initialize the builder from an existing transaction
+     *
+     * @param {Transaction} tx - The transaction to initialize from
+     */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        if (tx instanceof customTransaction_1.CustomTransaction) {
+            const params = tx.getCustomTransactionParams();
+            // Only set custom transaction params if they are defined
+            if (params.moduleName && params.functionName) {
+                this.customTransaction(params);
+            }
+        }
+    }
+    /**
+     * Build the transaction
+     *
+     * @returns {Promise<CustomTransaction>} The built transaction
+     */
+    async build() {
+        const params = this._transaction.getCustomTransactionParams();
+        if (!params.moduleName || !params.functionName) {
+            throw new sdk_core_1.BuildTransactionError('Missing required module or function name');
+        }
+        return (await super.build());
+    }
+    /**
+     * Get the transaction builder instance from an existing transaction
+     *
+     * @param {Transaction} tx - The transaction to convert
+     * @returns {TransactionBuilder} The transaction builder
+     */
+    from(tx) {
+        if (!(tx instanceof customTransaction_1.CustomTransaction)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction type');
+        }
+        this.initBuilder(tx);
+        return this;
+    }
+}
+exports.CustomTransactionBuilder = CustomTransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customTransactionBuilder.js","sourceRoot":"","sources":["../../../../src/lib/transactionBuilder/customTransactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BuildTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { EntryFunctionABI, TransactionPayload, TransactionPayloadEntryFunction } from '@aptos-labs/ts-sdk';\nimport { Transaction } from '../transaction/transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { CustomTransaction } from '../transaction/customTransaction';\nimport { CustomTransactionParams } from '../iface';\nimport { isValidModuleName, isValidFunctionName } from '../utils/validation';\n\n/**\n * Builder for Aptos custom transactions.\n * Allows building transactions with any entry function call.\n */\nexport class CustomTransactionBuilder extends TransactionBuilder {\n  protected _transaction: CustomTransaction;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new CustomTransaction(_coinConfig);\n  }\n\n  /**\n   * @returns {TransactionType} The transaction type\n   */\n  protected get transactionType(): TransactionType {\n    return TransactionType.CustomTx;\n  }\n\n  /**\n   * Set the custom transaction parameters\n   *\n   * @param {CustomTransactionParams} params - Custom transaction parameters\n   * @returns {CustomTransactionBuilder} The builder instance\n   */\n  customTransaction(params: CustomTransactionParams): CustomTransactionBuilder {\n    if (!params.moduleName) {\n      throw new BuildTransactionError('Missing module name');\n    }\n\n    if (!params.functionName) {\n      throw new BuildTransactionError('Missing function name');\n    }\n\n    this._transaction.setCustomTransactionParams(params);\n    return this;\n  }\n\n  /**\n   * Set the entry function ABI\n   *\n   * @param {EntryFunctionABI} abi - The ABI definition for the entry function\n   * @returns {CustomTransactionBuilder} The builder instance\n   */\n  entryFunctionAbi(abi: EntryFunctionABI): CustomTransactionBuilder {\n    this._transaction.setEntryFunctionAbi(abi);\n    return this;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  assetId(assetId: string): TransactionBuilder {\n    // Asset ID is optional for custom transactions\n    this._transaction.assetId = assetId;\n    return this;\n  }\n\n  /**\n   * Check if a transaction payload is valid for this builder\n   *\n   * @param {TransactionPayload} payload - The transaction payload to check\n   * @returns {boolean} True if the payload is valid for this builder\n   */\n  protected isValidTransactionPayload(payload: TransactionPayload): boolean {\n    // Basic payload type check\n    if (!(payload instanceof TransactionPayloadEntryFunction)) {\n      return false;\n    }\n    try {\n      const entryFunction = payload.entryFunction;\n      // Validate module and function identifiers\n      const moduleAddress = entryFunction.module_name.address.toString();\n      const moduleIdentifier = entryFunction.module_name.name.identifier;\n      const functionIdentifier = entryFunction.function_name.identifier;\n      const moduleName = `${moduleAddress}::${moduleIdentifier}`;\n\n      if (!isValidModuleName(moduleName) || !isValidFunctionName(functionIdentifier)) {\n        return false;\n      }\n      return true;\n    } catch (error) {\n      return false;\n    }\n  }\n\n  /**\n   * Initialize the builder from an existing transaction\n   *\n   * @param {Transaction} tx - The transaction to initialize from\n   */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n\n    if (tx instanceof CustomTransaction) {\n      const params = tx.getCustomTransactionParams();\n      // Only set custom transaction params if they are defined\n      if (params.moduleName && params.functionName) {\n        this.customTransaction(params);\n      }\n    }\n  }\n\n  /**\n   * Build the transaction\n   *\n   * @returns {Promise<CustomTransaction>} The built transaction\n   */\n  async build(): Promise<CustomTransaction> {\n    const params = (this._transaction as CustomTransaction).getCustomTransactionParams();\n    if (!params.moduleName || !params.functionName) {\n      throw new BuildTransactionError('Missing required module or function name');\n    }\n\n    return (await super.build()) as CustomTransaction;\n  }\n\n  /**\n   * Get the transaction builder instance from an existing transaction\n   *\n   * @param {Transaction} tx - The transaction to convert\n   * @returns {TransactionBuilder} The transaction builder\n   */\n  from(tx: Transaction): TransactionBuilder {\n    if (!(tx instanceof CustomTransaction)) {\n      throw new BuildTransactionError('Invalid transaction type');\n    }\n\n    this.initBuilder(tx);\n    return this;\n  }\n}\n"]}

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

@@ -6,10 +6,11 @@ import { SignedTransaction } from '@aptos-labs/ts-sdk';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { FungibleAssetTransferBuilder } from './transactionBuilder/fungibleAssetTransferBuilder';
 import { DigitalAssetTransferBuilder } from './transactionBuilder/digitalAssetTransferBuilder';
+import { CustomTransactionBuilder } from './transactionBuilder/customTransactionBuilder';
 export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     constructor(_coinConfig: Readonly<CoinConfig>);
     /** @inheritdoc */
-    from(signedRawTxn: string): TransactionBuilder;
+    from(signedRawTxn: string, abi?: any): TransactionBuilder;
     getTransactionTypeFromSignedTxn(signedTxn: SignedTransaction): TransactionType;
     /** @inheritdoc */
     getTransferBuilder(tx?: Transaction): TransferBuilder;
@@ -17,6 +18,13 @@ export declare class TransactionBuilderFactory extends BaseTransactionBuilderFac
     getFungibleAssetTransactionBuilder(tx?: Transaction): FungibleAssetTransferBuilder;
     /** @inheritdoc */
     getDigitalAssetTransactionBuilder(tx?: Transaction): DigitalAssetTransferBuilder;
+    /**
+     * Get a custom transaction builder
+     *
+     * @param tx - Optional transaction to initialize the builder with
+     * @returns A custom transaction builder
+     */
+    getCustomTransactionBuilder(tx?: Transaction): CustomTransactionBuilder;
     /** @inheritdoc */
     getWalletInitializationBuilder(): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAA2B,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC1G,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAEvE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,4BAA4B,EAAE,MAAM,mDAAmD,CAAC;AAEjG,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAC;AAE/F,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,kBAAkB;IAyB9C,+BAA+B,CAAC,SAAS,EAAE,iBAAiB,GAAG,eAAe;IAK9E,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,kBAAkB;IAClB,kCAAkC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,4BAA4B;IAIlF,kBAAkB;IAClB,iCAAiC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,2BAA2B;IAIhF,kBAAkB;IAClB,8BAA8B,IAAI,IAAI;IAItC;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;CAM1B"}
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAA2B,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC1G,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAEvE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,4BAA4B,EAAE,MAAM,mDAAmD,CAAC;AAEjG,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAC;AAE/F,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AAEzF,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,kBAAkB;IAiCzD,+BAA+B,CAAC,SAAS,EAAE,iBAAiB,GAAG,eAAe;IAK9E,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,kBAAkB;IAClB,kCAAkC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,4BAA4B;IAIlF,kBAAkB;IAClB,iCAAiC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,2BAA2B;IAIhF;;;;;OAKG;IACH,2BAA2B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,wBAAwB;IAIvE,kBAAkB;IAClB,8BAA8B,IAAI,IAAI;IAItC;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;CAM1B"}

package/dist/src/lib/transactionBuilderFactory.js

@@ -13,12 +13,14 @@ const fungibleAssetTransfer_1 = require("./transaction/fungibleAssetTransfer");
 const fungibleAssetTransferBuilder_1 = require("./transactionBuilder/fungibleAssetTransferBuilder");
 const digitalAssetTransfer_1 = require("./transaction/digitalAssetTransfer");
 const digitalAssetTransferBuilder_1 = require("./transactionBuilder/digitalAssetTransferBuilder");
+const customTransaction_1 = require("./transaction/customTransaction");
+const customTransactionBuilder_1 = require("./transactionBuilder/customTransactionBuilder");
 class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
     constructor(_coinConfig) {
         super(_coinConfig);
     }
     /** @inheritdoc */
-    from(signedRawTxn) {
+    from(signedRawTxn, abi) {
         try {
             const signedTxn = transaction_1.Transaction.deserializeSignedTransaction(signedRawTxn);
             const txnType = this.getTransactionTypeFromSignedTxn(signedTxn);
@@ -35,6 +37,13 @@ class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory
                     const digitalAssetTransferTx = new digitalAssetTransfer_1.DigitalAssetTransfer(this._coinConfig);
                     digitalAssetTransferTx.fromDeserializedSignedTransaction(signedTxn);
                     return this.getDigitalAssetTransactionBuilder(digitalAssetTransferTx);
+                case sdk_core_1.TransactionType.CustomTx:
+                    const customTx = new customTransaction_1.CustomTransaction(this._coinConfig);
+                    if (abi) {
+                        customTx.setEntryFunctionAbi(abi);
+                    }
+                    customTx.fromDeserializedSignedTransaction(signedTxn);
+                    return this.getCustomTransactionBuilder(customTx);
                 default:
                     throw new sdk_core_1.InvalidTransactionError('Invalid transaction');
             }
@@ -59,6 +68,15 @@ class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory
     getDigitalAssetTransactionBuilder(tx) {
         return this.initializeBuilder(tx, new digitalAssetTransferBuilder_1.DigitalAssetTransferBuilder(this._coinConfig));
     }
+    /**
+     * Get a custom transaction builder
+     *
+     * @param tx - Optional transaction to initialize the builder with
+     * @returns A custom transaction builder
+     */
+    getCustomTransactionBuilder(tx) {
+        return this.initializeBuilder(tx, new customTransactionBuilder_1.CustomTransactionBuilder(this._coinConfig));
+    }
     /** @inheritdoc */
     getWalletInitializationBuilder() {
         throw new Error('Method not implemented.');
@@ -78,4 +96,4 @@ class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory
     }
 }
 exports.TransactionBuilderFactory = TransactionBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,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
+//# 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/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder/transactionBuilder';\nimport { TransferBuilder } from './transactionBuilder/transferBuilder';\nimport utils from './utils';\nimport { Transaction } from './transaction/transaction';\nimport { SignedTransaction } from '@aptos-labs/ts-sdk';\nimport { TransferTransaction } from './transaction/transferTransaction';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { FungibleAssetTransfer } from './transaction/fungibleAssetTransfer';\nimport { FungibleAssetTransferBuilder } from './transactionBuilder/fungibleAssetTransferBuilder';\nimport { DigitalAssetTransfer } from './transaction/digitalAssetTransfer';\nimport { DigitalAssetTransferBuilder } from './transactionBuilder/digitalAssetTransferBuilder';\nimport { CustomTransaction } from './transaction/customTransaction';\nimport { CustomTransactionBuilder } from './transactionBuilder/customTransactionBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  from(signedRawTxn: string, abi?: any): TransactionBuilder {\n    try {\n      const signedTxn = Transaction.deserializeSignedTransaction(signedRawTxn);\n      const txnType = this.getTransactionTypeFromSignedTxn(signedTxn);\n\n      switch (txnType) {\n        case TransactionType.Send:\n          const transferTx = new TransferTransaction(this._coinConfig);\n          transferTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getTransferBuilder(transferTx);\n        case TransactionType.SendToken:\n          const fungibleTransferTokenTx = new FungibleAssetTransfer(this._coinConfig);\n          fungibleTransferTokenTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getFungibleAssetTransactionBuilder(fungibleTransferTokenTx);\n        case TransactionType.SendNFT:\n          const digitalAssetTransferTx = new DigitalAssetTransfer(this._coinConfig);\n          digitalAssetTransferTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getDigitalAssetTransactionBuilder(digitalAssetTransferTx);\n        case TransactionType.CustomTx:\n          const customTx = new CustomTransaction(this._coinConfig);\n          if (abi) {\n            customTx.setEntryFunctionAbi(abi);\n          }\n          customTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getCustomTransactionBuilder(customTx);\n        default:\n          throw new InvalidTransactionError('Invalid transaction');\n      }\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  getTransactionTypeFromSignedTxn(signedTxn: SignedTransaction): TransactionType {\n    const rawTxn = signedTxn.raw_txn;\n    return utils.getTransactionTypeFromTransactionPayload(rawTxn.payload);\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(tx?: Transaction): TransferBuilder {\n    return this.initializeBuilder(tx, new TransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getFungibleAssetTransactionBuilder(tx?: Transaction): FungibleAssetTransferBuilder {\n    return this.initializeBuilder(tx, new FungibleAssetTransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getDigitalAssetTransactionBuilder(tx?: Transaction): DigitalAssetTransferBuilder {\n    return this.initializeBuilder(tx, new DigitalAssetTransferBuilder(this._coinConfig));\n  }\n\n  /**\n   * Get a custom transaction builder\n   *\n   * @param tx - Optional transaction to initialize the builder with\n   * @returns A custom transaction builder\n   */\n  getCustomTransactionBuilder(tx?: Transaction): CustomTransactionBuilder {\n    return this.initializeBuilder(tx, new CustomTransactionBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): void {\n    throw new Error('Method not implemented.');\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"]}