@bitgo-beta/sdk-coin-apt 1.0.1-beta.9 → 1.0.1-beta.900

package/dist/src/lib/transaction/customTransaction.d.ts

@@ -0,0 +1,89 @@
+import { EntryFunctionABI, InputGenerateTransactionPayloadData, TransactionPayload } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { CustomTransactionParams } from '../iface';
+import { AbstractTransferTransaction } from './abstractTransferTransaction';
+/**
+ * Transaction class for custom Aptos transactions.
+ */
+export declare class CustomTransaction extends AbstractTransferTransaction {
+    private _moduleName;
+    private _functionName;
+    private _typeArguments;
+    private _functionArguments;
+    private _entryFunctionAbi?;
+    constructor(coinConfig: Readonly<CoinConfig>);
+    /**
+     * Set the custom transaction parameters
+     */
+    setCustomTransactionParams(params: CustomTransactionParams): void;
+    /**
+     * Set the entry function ABI
+     */
+    setEntryFunctionAbi(abi: EntryFunctionABI): void;
+    /**
+     * Get the full function name
+     */
+    get fullFunctionName(): string;
+    /**
+     * 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
+     */
+    protected parseTransactionPayload(payload: TransactionPayload): void;
+    /**
+     * Generate transaction payload data
+     */
+    protected getTransactionPayloadData(): InputGenerateTransactionPayloadData;
+    /**
+     * Convert argument based on ABI type information
+     */
+    private convertArgumentByABI;
+    /**
+     * Convert primitive argument values based on parameter type
+     */
+    private convertPrimitiveArgument;
+    /**
+     * Convert primitive numeric arguments to string
+     * - Big numbers break JavaScript (precision loss)
+     * - String safer for large U64/U128/U256 values
+     * - Aptos SDK converts string to correct type automatically
+     */
+    private convertPrimitiveNumericArgument;
+    /**
+     * Convert BCS data argument with 'data' property
+     */
+    private convertBcsDataArgument;
+    /**
+     * Convert nested BCS argument with 'value' property
+     */
+    private convertNestedBcsArgument;
+    /**
+     * Extract bytes from BCS object with numeric keys
+     */
+    private extractBytesFromBcsObject;
+    /**
+     * Get custom transaction parameters
+     */
+    getCustomTransactionParams(): CustomTransactionParams;
+    /**
+     * Override recipient getter for custom transactions
+     */
+    get recipient(): any;
+    /**
+     * Get validated full function name
+     */
+    private getValidatedFullFunctionName;
+    /**
+     * Check if a parameter type is a numeric type
+     */
+    private isNumericType;
+    /**
+     * Convert byte arrays to string numbers
+     * - Small types (U8/U16/U32): 1-4 bytes, parse manually
+     * - Large types (U64/U128/U256): 8+ bytes, use existing utility
+     * - Both return string for consistency
+     */
+    private convertNumericArgument;
+}
+//# sourceMappingURL=customTransaction.d.ts.map

package/dist/src/lib/transaction/customTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customTransaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/customTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAEhB,mCAAmC,EAEnC,kBAAkB,EAUnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,2BAA2B;IAChE,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,kBAAkB,CAA4E;IACtG,OAAO,CAAC,iBAAiB,CAAC,CAAmB;gBAEjC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C;;OAEG;IACH,0BAA0B,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI;IAWjE;;OAEG;IACH,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI;IAIhD;;OAEG;IACH,IAAI,gBAAgB,IAAI,MAAM,CAK7B;IAED;;;;;OAKG;IACH,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAyCpE;;OAEG;IACH,SAAS,CAAC,yBAAyB,IAAI,mCAAmC;IAc1E;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAoBhC;;;;;OAKG;IACH,OAAO,CAAC,+BAA+B;IAKvC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAO9B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAoChC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAUjC;;OAEG;IACH,0BAA0B,IAAI,uBAAuB;IAUrD;;OAEG;IACH,IAAI,SAAS,IAAI,GAAG,CAQnB;IAED;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAiBpC;;OAEG;IACH,OAAO,CAAC,aAAa;IAWrB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;CAkB/B"}

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

@@ -0,0 +1,278 @@
+"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 ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const utils_1 = __importDefault(require("../utils"));
+const validation_1 = require("../utils/validation");
+const abstractTransferTransaction_1 = require("./abstractTransferTransaction");
+/**
+ * Transaction class for custom Aptos transactions.
+ */
+class CustomTransaction extends abstractTransferTransaction_1.AbstractTransferTransaction {
+    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) {
+        // Handle primitive values (string, number, boolean)
+        if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {
+            return this.convertPrimitiveArgument(arg, paramType);
+        }
+        // Handle BCS-encoded data with 'data' property
+        if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {
+            return this.convertBcsDataArgument(arg, paramType);
+        }
+        // Handle nested BCS structures with 'value' property
+        if (arg && typeof arg === 'object' && 'value' in arg && arg.value) {
+            return this.convertNestedBcsArgument(arg, paramType);
+        }
+        // For anything else, return as-is
+        return arg;
+    }
+    /**
+     * Convert primitive argument values based on parameter type
+     */
+    convertPrimitiveArgument(arg, paramType) {
+        // Address conversion for hex strings
+        if (paramType instanceof ts_sdk_1.TypeTagAddress && typeof arg === 'string' && arg.startsWith('0x')) {
+            return utils_1.default.tryParseAccountAddress(arg);
+        }
+        // Type conversions based on parameter type
+        if (paramType instanceof ts_sdk_1.TypeTagBool)
+            return Boolean(arg);
+        // Use unified numeric type handling
+        if (this.isNumericType(paramType)) {
+            return this.convertPrimitiveNumericArgument(arg);
+        }
+        return arg;
+    }
+    /**
+     * Convert primitive numeric arguments to string
+     * - Big numbers break JavaScript (precision loss)
+     * - String safer for large U64/U128/U256 values
+     * - Aptos SDK converts string to correct type automatically
+     */
+    convertPrimitiveNumericArgument(arg) {
+        // Always string - safer for big numbers
+        return String(arg);
+    }
+    /**
+     * Convert BCS data argument with 'data' property
+     */
+    convertBcsDataArgument(arg, paramType) {
+        const bytes = Array.from(arg.data);
+        const hexString = utils_1.default.bytesToHex(bytes);
+        return paramType instanceof ts_sdk_1.TypeTagAddress ? utils_1.default.tryParseAccountAddress(hexString) : hexString;
+    }
+    /**
+     * Convert nested BCS argument with 'value' property
+     */
+    convertNestedBcsArgument(arg, paramType) {
+        // 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 utils_1.default.bytesToHex(bytes);
+        }
+        // Simple value wrapper - fix the bug in original implementation
+        if (typeof arg.value !== 'object' || !('value' in arg.value)) {
+            return this.convertArgumentByABI(arg.value, paramType);
+        }
+        // Double nested structure with numeric keys
+        const bytes = this.extractBytesFromBcsObject(arg.value.value);
+        if (bytes.length === 0)
+            return arg;
+        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 = utils_1.default.bytesToHex(bytes);
+        }
+        else if (paramType instanceof ts_sdk_1.TypeTagBool) {
+            extractedValue = bytes[0] === 1;
+        }
+        else {
+            extractedValue = utils_1.default.bytesToHex(bytes);
+        }
+        return this.convertArgumentByABI(extractedValue, paramType);
+    }
+    /**
+     * Extract bytes from BCS object with numeric keys
+     */
+    extractBytesFromBcsObject(bcsObject) {
+        const keys = Object.keys(bcsObject)
+            .filter((k) => !isNaN(parseInt(k, 10)))
+            .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+        if (keys.length === 0)
+            return [];
+        return keys.map((k) => bcsObject[k]);
+    }
+    /**
+     * 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 byte arrays to string numbers
+     * - Small types (U8/U16/U32): 1-4 bytes, parse manually
+     * - Large types (U64/U128/U256): 8+ bytes, use existing utility
+     * - Both return string for consistency
+     */
+    convertNumericArgument(bytes, paramType) {
+        if (paramType instanceof ts_sdk_1.TypeTagU8 || paramType instanceof ts_sdk_1.TypeTagU16 || paramType instanceof ts_sdk_1.TypeTagU32) {
+            // Small types: parse bytes manually (1-4 bytes)
+            let result = 0;
+            for (let i = bytes.length - 1; i >= 0; i--) {
+                result = result * 256 + bytes[i];
+            }
+            return result.toString();
+        }
+        if (paramType instanceof ts_sdk_1.TypeTagU64 || paramType instanceof ts_sdk_1.TypeTagU128 || paramType instanceof ts_sdk_1.TypeTagU256) {
+            // Large types: use existing method (needs 8+ bytes)
+            return utils_1.default.getAmountFromPayloadArgs(new Uint8Array(bytes));
+        }
+        // Unknown type: convert to hex
+        return utils_1.default.bytesToHex(bytes);
+    }
+}
+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 {\n  AccountAddress,\n  EntryFunctionABI,\n  EntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  SimpleEntryFunctionArgumentTypes,\n  TransactionPayload,\n  TransactionPayloadEntryFunction,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagU128,\n  TypeTagU16,\n  TypeTagU256,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU8,\n} from '@aptos-labs/ts-sdk';\nimport { InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { CustomTransactionParams } from '../iface';\nimport utils from '../utils';\nimport { validateFunctionName, validateModuleName } from '../utils/validation';\nimport { AbstractTransferTransaction } from './abstractTransferTransaction';\n\n/**\n * Transaction class for custom Aptos transactions.\n */\nexport class CustomTransaction extends AbstractTransferTransaction {\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    // Handle primitive values (string, number, boolean)\n    if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {\n      return this.convertPrimitiveArgument(arg, paramType);\n    }\n\n    // Handle BCS-encoded data with 'data' property\n    if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {\n      return this.convertBcsDataArgument(arg, paramType);\n    }\n\n    // Handle nested BCS structures with 'value' property\n    if (arg && typeof arg === 'object' && 'value' in arg && arg.value) {\n      return this.convertNestedBcsArgument(arg, paramType);\n    }\n\n    // For anything else, return as-is\n    return arg;\n  }\n\n  /**\n   * Convert primitive argument values based on parameter type\n   */\n  private convertPrimitiveArgument(\n    arg: string | number | boolean,\n    paramType: any\n  ): string | number | boolean | AccountAddress {\n    // Address conversion for hex strings\n    if (paramType instanceof TypeTagAddress && typeof arg === 'string' && arg.startsWith('0x')) {\n      return utils.tryParseAccountAddress(arg);\n    }\n\n    // Type conversions based on parameter type\n    if (paramType instanceof TypeTagBool) return Boolean(arg);\n\n    // Use unified numeric type handling\n    if (this.isNumericType(paramType)) {\n      return this.convertPrimitiveNumericArgument(arg);\n    }\n\n    return arg;\n  }\n\n  /**\n   * Convert primitive numeric arguments to string\n   * - Big numbers break JavaScript (precision loss)\n   * - String safer for large U64/U128/U256 values\n   * - Aptos SDK converts string to correct type automatically\n   */\n  private convertPrimitiveNumericArgument(arg: string | number | boolean): string {\n    // Always string - safer for big numbers\n    return String(arg);\n  }\n\n  /**\n   * Convert BCS data argument with 'data' property\n   */\n  private convertBcsDataArgument(arg: any, paramType: any): string | AccountAddress {\n    const bytes = Array.from(arg.data) as number[];\n    const hexString = utils.bytesToHex(bytes);\n\n    return paramType instanceof TypeTagAddress ? utils.tryParseAccountAddress(hexString) : hexString;\n  }\n\n  /**\n   * Convert nested BCS argument with 'value' property\n   */\n  private convertNestedBcsArgument(arg: any, paramType: any): any {\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 utils.bytesToHex(bytes);\n    }\n\n    // Simple value wrapper - fix the bug in original implementation\n    if (typeof arg.value !== 'object' || !('value' in arg.value)) {\n      return this.convertArgumentByABI(arg.value, paramType);\n    }\n\n    // Double nested structure with numeric keys\n    const bytes = this.extractBytesFromBcsObject(arg.value.value);\n    if (bytes.length === 0) return arg;\n\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 = utils.bytesToHex(bytes);\n    } else if (paramType instanceof TypeTagBool) {\n      extractedValue = bytes[0] === 1;\n    } else {\n      extractedValue = utils.bytesToHex(bytes);\n    }\n\n    return this.convertArgumentByABI(extractedValue, paramType);\n  }\n\n  /**\n   * Extract bytes from BCS object with numeric keys\n   */\n  private extractBytesFromBcsObject(bcsObject: any): number[] {\n    const keys = Object.keys(bcsObject)\n      .filter((k) => !isNaN(parseInt(k, 10)))\n      .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));\n\n    if (keys.length === 0) return [];\n\n    return keys.map((k) => bcsObject[k]);\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 byte arrays to string numbers\n   * - Small types (U8/U16/U32): 1-4 bytes, parse manually\n   * - Large types (U64/U128/U256): 8+ bytes, use existing utility\n   * - Both return string for consistency\n   */\n  private convertNumericArgument(bytes: number[], paramType: any): string {\n    if (paramType instanceof TypeTagU8 || paramType instanceof TypeTagU16 || paramType instanceof TypeTagU32) {\n      // Small types: parse bytes manually (1-4 bytes)\n      let result = 0;\n      for (let i = bytes.length - 1; i >= 0; i--) {\n        result = result * 256 + bytes[i];\n      }\n      return result.toString();\n    }\n\n    if (paramType instanceof TypeTagU64 || paramType instanceof TypeTagU128 || paramType instanceof TypeTagU256) {\n      // Large types: use existing method (needs 8+ bytes)\n      return utils.getAmountFromPayloadArgs(new Uint8Array(bytes));\n    }\n\n    // Unknown type: convert to hex\n    return utils.bytesToHex(bytes);\n  }\n}\n"]}

package/dist/src/lib/transaction/delegationPoolAddStakeTransaction.d.ts

@@ -0,0 +1,10 @@
+import { MoveFunctionId } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { AbstractDelegationPoolAmountBasedTransaction } from './abstractDelegationPoolAmountBasedTransaction';
+import { InputsAndOutputs } from './transaction';
+export declare class DelegationPoolAddStakeTransaction extends AbstractDelegationPoolAmountBasedTransaction {
+    constructor(coinConfig: Readonly<CoinConfig>);
+    moveFunctionId(): MoveFunctionId;
+    inputsAndOutputs(): InputsAndOutputs;
+}
+//# sourceMappingURL=delegationPoolAddStakeTransaction.d.ts.map

package/dist/src/lib/transaction/delegationPoolAddStakeTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegationPoolAddStakeTransaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/delegationPoolAddStakeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,4CAA4C,EAAE,MAAM,gDAAgD,CAAC;AAC9G,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,qBAAa,iCAAkC,SAAQ,4CAA4C;gBACrF,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAKnC,cAAc,IAAI,cAAc;IAIhC,gBAAgB,IAAI,gBAAgB;CA4B9C"}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegationPoolAddStakeTransaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const constants_1 = require("../constants");
+const abstractDelegationPoolAmountBasedTransaction_1 = require("./abstractDelegationPoolAmountBasedTransaction");
+class DelegationPoolAddStakeTransaction extends abstractDelegationPoolAmountBasedTransaction_1.AbstractDelegationPoolAmountBasedTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._type = sdk_core_1.TransactionType.StakingDelegate;
+    }
+    moveFunctionId() {
+        return constants_1.DELEGATION_POOL_ADD_STAKE_FUNCTION;
+    }
+    inputsAndOutputs() {
+        const { sender, validatorAddress, amount } = this;
+        if (sender === undefined)
+            throw new Error('sender is undefined');
+        if (validatorAddress === undefined)
+            throw new Error('validatorAddress is undefined');
+        if (amount === undefined)
+            throw new Error('amount is undefined');
+        return {
+            inputs: [
+                {
+                    address: sender,
+                    value: amount,
+                    coin: this._coinConfig.name,
+                },
+            ],
+            outputs: [
+                {
+                    address: validatorAddress,
+                    value: amount,
+                    coin: this._coinConfig.name,
+                },
+            ],
+            externalOutputs: [
+                {
+                    address: validatorAddress,
+                    amount: amount,
+                },
+            ],
+        };
+    }
+}
+exports.DelegationPoolAddStakeTransaction = DelegationPoolAddStakeTransaction;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/transaction/delegationPoolUnlockTransaction.d.ts

@@ -0,0 +1,10 @@
+import { MoveFunctionId } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { AbstractDelegationPoolAmountBasedTransaction } from './abstractDelegationPoolAmountBasedTransaction';
+import { InputsAndOutputs } from './transaction';
+export declare class DelegationPoolUnlockTransaction extends AbstractDelegationPoolAmountBasedTransaction {
+    constructor(coinConfig: Readonly<CoinConfig>);
+    moveFunctionId(): MoveFunctionId;
+    inputsAndOutputs(): InputsAndOutputs;
+}
+//# sourceMappingURL=delegationPoolUnlockTransaction.d.ts.map

package/dist/src/lib/transaction/delegationPoolUnlockTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegationPoolUnlockTransaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/delegationPoolUnlockTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,4CAA4C,EAAE,MAAM,gDAAgD,CAAC;AAC9G,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,qBAAa,+BAAgC,SAAQ,4CAA4C;gBACnF,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAKnC,cAAc,IAAI,cAAc;IAIhC,gBAAgB,IAAI,gBAAgB;CAO9C"}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegationPoolUnlockTransaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const constants_1 = require("../constants");
+const abstractDelegationPoolAmountBasedTransaction_1 = require("./abstractDelegationPoolAmountBasedTransaction");
+class DelegationPoolUnlockTransaction extends abstractDelegationPoolAmountBasedTransaction_1.AbstractDelegationPoolAmountBasedTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._type = sdk_core_1.TransactionType.StakingUnlock;
+    }
+    moveFunctionId() {
+        return constants_1.DELEGATION_POOL_UNLOCK_FUNCTION;
+    }
+    inputsAndOutputs() {
+        return {
+            inputs: [],
+            outputs: [],
+            externalOutputs: [],
+        };
+    }
+}
+exports.DelegationPoolUnlockTransaction = DelegationPoolUnlockTransaction;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZWdhdGlvblBvb2xVbmxvY2tUcmFuc2FjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdHJhbnNhY3Rpb24vZGVsZWdhdGlvblBvb2xVbmxvY2tUcmFuc2FjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxtREFBdUQ7QUFHdkQsNENBQStEO0FBQy9ELGlIQUE4RztBQUc5RyxNQUFhLCtCQUFnQyxTQUFRLDJGQUE0QztJQUMvRixZQUFZLFVBQWdDO1FBQzFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNsQixJQUFJLENBQUMsS0FBSyxHQUFHLDBCQUFlLENBQUMsYUFBYSxDQUFDO0lBQzdDLENBQUM7SUFFUSxjQUFjO1FBQ3JCLE9BQU8sMkNBQStCLENBQUM7SUFDekMsQ0FBQztJQUVRLGdCQUFnQjtRQUN2QixPQUFPO1lBQ0wsTUFBTSxFQUFFLEVBQUU7WUFDVixPQUFPLEVBQUUsRUFBRTtZQUNYLGVBQWUsRUFBRSxFQUFFO1NBQ3BCLENBQUM7SUFDSixDQUFDO0NBQ0Y7QUFqQkQsMEVBaUJDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTW92ZUZ1bmN0aW9uSWQgfSBmcm9tICdAYXB0b3MtbGFicy90cy1zZGsnO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb25UeXBlIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuXG5pbXBvcnQgeyBCYXNlQ29pbiBhcyBDb2luQ29uZmlnIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5pbXBvcnQgeyBERUxFR0FUSU9OX1BPT0xfVU5MT0NLX0ZVTkNUSU9OIH0gZnJvbSAnLi4vY29uc3RhbnRzJztcbmltcG9ydCB7IEFic3RyYWN0RGVsZWdhdGlvblBvb2xBbW91bnRCYXNlZFRyYW5zYWN0aW9uIH0gZnJvbSAnLi9hYnN0cmFjdERlbGVnYXRpb25Qb29sQW1vdW50QmFzZWRUcmFuc2FjdGlvbic7XG5pbXBvcnQgeyBJbnB1dHNBbmRPdXRwdXRzIH0gZnJvbSAnLi90cmFuc2FjdGlvbic7XG5cbmV4cG9ydCBjbGFzcyBEZWxlZ2F0aW9uUG9vbFVubG9ja1RyYW5zYWN0aW9uIGV4dGVuZHMgQWJzdHJhY3REZWxlZ2F0aW9uUG9vbEFtb3VudEJhc2VkVHJhbnNhY3Rpb24ge1xuICBjb25zdHJ1Y3Rvcihjb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKGNvaW5Db25maWcpO1xuICAgIHRoaXMuX3R5cGUgPSBUcmFuc2FjdGlvblR5cGUuU3Rha2luZ1VubG9jaztcbiAgfVxuXG4gIG92ZXJyaWRlIG1vdmVGdW5jdGlvbklkKCk6IE1vdmVGdW5jdGlvbklkIHtcbiAgICByZXR1cm4gREVMRUdBVElPTl9QT09MX1VOTE9DS19GVU5DVElPTjtcbiAgfVxuXG4gIG92ZXJyaWRlIGlucHV0c0FuZE91dHB1dHMoKTogSW5wdXRzQW5kT3V0cHV0cyB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGlucHV0czogW10sXG4gICAgICBvdXRwdXRzOiBbXSxcbiAgICAgIGV4dGVybmFsT3V0cHV0czogW10sXG4gICAgfTtcbiAgfVxufVxuIl19

package/dist/src/lib/transaction/delegationPoolWithdrawTransaction.d.ts

@@ -0,0 +1,10 @@
+import { MoveFunctionId } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { AbstractDelegationPoolAmountBasedTransaction } from './abstractDelegationPoolAmountBasedTransaction';
+import { InputsAndOutputs } from './transaction';
+export declare class DelegationPoolWithdrawTransaction extends AbstractDelegationPoolAmountBasedTransaction {
+    constructor(coinConfig: Readonly<CoinConfig>);
+    moveFunctionId(): MoveFunctionId;
+    inputsAndOutputs(): InputsAndOutputs;
+}
+//# sourceMappingURL=delegationPoolWithdrawTransaction.d.ts.map

package/dist/src/lib/transaction/delegationPoolWithdrawTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegationPoolWithdrawTransaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/delegationPoolWithdrawTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,4CAA4C,EAAE,MAAM,gDAAgD,CAAC;AAC9G,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,qBAAa,iCAAkC,SAAQ,4CAA4C;gBACrF,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAKnC,cAAc,IAAI,cAAc;IAIhC,gBAAgB,IAAI,gBAAgB;CAuB9C"}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegationPoolWithdrawTransaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const constants_1 = require("../constants");
+const abstractDelegationPoolAmountBasedTransaction_1 = require("./abstractDelegationPoolAmountBasedTransaction");
+class DelegationPoolWithdrawTransaction extends abstractDelegationPoolAmountBasedTransaction_1.AbstractDelegationPoolAmountBasedTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._type = sdk_core_1.TransactionType.StakingWithdraw;
+    }
+    moveFunctionId() {
+        return constants_1.DELEGATION_POOL_WITHDRAW_FUNCTION;
+    }
+    inputsAndOutputs() {
+        const { sender, validatorAddress, amount } = this;
+        if (sender === undefined)
+            throw new Error('sender is undefined');
+        if (validatorAddress === undefined)
+            throw new Error('validatorAddress is undefined');
+        if (amount === undefined)
+            throw new Error('amount is undefined');
+        return {
+            inputs: [
+                {
+                    address: validatorAddress,
+                    value: amount,
+                    coin: this._coinConfig.name,
+                },
+            ],
+            outputs: [
+                {
+                    address: sender,
+                    value: amount,
+                    coin: this._coinConfig.name,
+                },
+            ],
+            externalOutputs: [],
+        };
+    }
+}
+exports.DelegationPoolWithdrawTransaction = DelegationPoolWithdrawTransaction;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/transaction/digitalAssetTransfer.d.ts

@@ -0,0 +1,10 @@
+import { InputGenerateTransactionPayloadData, TransactionPayload } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { AbstractTransferTransaction } from './abstractTransferTransaction';
+export declare class DigitalAssetTransfer extends AbstractTransferTransaction {
+    constructor(coinConfig: Readonly<CoinConfig>);
+    protected parseTransactionPayload(payload: TransactionPayload): void;
+    protected getTransactionPayloadData(): InputGenerateTransactionPayloadData;
+    private transferDigitalAssetAbi;
+}
+//# sourceMappingURL=digitalAssetTransfer.d.ts.map

package/dist/src/lib/transaction/digitalAssetTransfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"digitalAssetTransfer.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/digitalAssetTransfer.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,mCAAmC,EAGnC,kBAAkB,EAKnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAM7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,qBAAa,oBAAqB,SAAQ,2BAA2B;gBACvD,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAmBpE,SAAS,CAAC,yBAAyB,IAAI,mCAAmC;IAY1E,OAAO,CAAC,uBAAuB,CAG7B;CACH"}