@bitgo-beta/sdk-coin-apt 1.0.1-beta.77 → 1.0.1-beta.771

package/dist/src/lib/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Utils = exports.Interface = exports.TransactionBuilderFactory = exports.TransferBuilder = exports.TransactionBuilder = exports.TransferTransaction = exports.Transaction = exports.KeyPair = void 0;
+exports.Utils = exports.Interface = exports.TransactionBuilderFactory = exports.CustomTransactionBuilder = exports.DigitalAssetTransferBuilder = exports.FungibleAssetTransferBuilder = exports.TransferBuilder = exports.TransactionBuilder = exports.CustomTransaction = exports.DigitalAssetTransfer = exports.FungibleAssetTransfer = exports.TransferTransaction = exports.Transaction = exports.KeyPair = void 0;
 const Utils = __importStar(require("./utils"));
 exports.Utils = Utils;
 const Interface = __importStar(require("./iface"));
@@ -44,10 +44,22 @@ var transaction_1 = require("./transaction/transaction");
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_1.Transaction; } });
 var transferTransaction_1 = require("./transaction/transferTransaction");
 Object.defineProperty(exports, "TransferTransaction", { enumerable: true, get: function () { return transferTransaction_1.TransferTransaction; } });
-var transactionBuilder_1 = require("./transactionBuilder");
+var fungibleAssetTransfer_1 = require("./transaction/fungibleAssetTransfer");
+Object.defineProperty(exports, "FungibleAssetTransfer", { enumerable: true, get: function () { return fungibleAssetTransfer_1.FungibleAssetTransfer; } });
+var digitalAssetTransfer_1 = require("./transaction/digitalAssetTransfer");
+Object.defineProperty(exports, "DigitalAssetTransfer", { enumerable: true, get: function () { return digitalAssetTransfer_1.DigitalAssetTransfer; } });
+var customTransaction_1 = require("./transaction/customTransaction");
+Object.defineProperty(exports, "CustomTransaction", { enumerable: true, get: function () { return customTransaction_1.CustomTransaction; } });
+var transactionBuilder_1 = require("./transactionBuilder/transactionBuilder");
 Object.defineProperty(exports, "TransactionBuilder", { enumerable: true, get: function () { return transactionBuilder_1.TransactionBuilder; } });
-var transferBuilder_1 = require("./transferBuilder");
+var transferBuilder_1 = require("./transactionBuilder/transferBuilder");
 Object.defineProperty(exports, "TransferBuilder", { enumerable: true, get: function () { return transferBuilder_1.TransferBuilder; } });
+var fungibleAssetTransferBuilder_1 = require("./transactionBuilder/fungibleAssetTransferBuilder");
+Object.defineProperty(exports, "FungibleAssetTransferBuilder", { enumerable: true, get: function () { return fungibleAssetTransferBuilder_1.FungibleAssetTransferBuilder; } });
+var digitalAssetTransferBuilder_1 = require("./transactionBuilder/digitalAssetTransferBuilder");
+Object.defineProperty(exports, "DigitalAssetTransferBuilder", { enumerable: true, get: function () { return digitalAssetTransferBuilder_1.DigitalAssetTransferBuilder; } });
+var customTransactionBuilder_1 = require("./transactionBuilder/customTransactionBuilder");
+Object.defineProperty(exports, "CustomTransactionBuilder", { enumerable: true, get: function () { return customTransactionBuilder_1.CustomTransactionBuilder; } });
 var transactionBuilderFactory_1 = require("./transactionBuilderFactory");
 Object.defineProperty(exports, "TransactionBuilderFactory", { enumerable: true, get: function () { return transactionBuilderFactory_1.TransactionBuilderFactory; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtDQUFpQztBQVNiLHNCQUFLO0FBUnpCLG1EQUFxQztBQVE1Qiw4QkFBUztBQU5sQixxQ0FBb0M7QUFBM0Isa0dBQUEsT0FBTyxPQUFBO0FBQ2hCLHlEQUF3RDtBQUEvQywwR0FBQSxXQUFXLE9BQUE7QUFDcEIseUVBQXdFO0FBQS9ELDBIQUFBLG1CQUFtQixPQUFBO0FBQzVCLDJEQUEwRDtBQUFqRCx3SEFBQSxrQkFBa0IsT0FBQTtBQUMzQixxREFBb0Q7QUFBM0Msa0hBQUEsZUFBZSxPQUFBO0FBQ3hCLHlFQUF3RTtBQUEvRCxzSUFBQSx5QkFBeUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFV0aWxzIGZyb20gJy4vdXRpbHMnO1xuaW1wb3J0ICogYXMgSW50ZXJmYWNlIGZyb20gJy4vaWZhY2UnO1xuXG5leHBvcnQgeyBLZXlQYWlyIH0gZnJvbSAnLi9rZXlQYWlyJztcbmV4cG9ydCB7IFRyYW5zYWN0aW9uIH0gZnJvbSAnLi90cmFuc2FjdGlvbi90cmFuc2FjdGlvbic7XG5leHBvcnQgeyBUcmFuc2ZlclRyYW5zYWN0aW9uIH0gZnJvbSAnLi90cmFuc2FjdGlvbi90cmFuc2ZlclRyYW5zYWN0aW9uJztcbmV4cG9ydCB7IFRyYW5zYWN0aW9uQnVpbGRlciB9IGZyb20gJy4vdHJhbnNhY3Rpb25CdWlsZGVyJztcbmV4cG9ydCB7IFRyYW5zZmVyQnVpbGRlciB9IGZyb20gJy4vdHJhbnNmZXJCdWlsZGVyJztcbmV4cG9ydCB7IFRyYW5zYWN0aW9uQnVpbGRlckZhY3RvcnkgfSBmcm9tICcuL3RyYW5zYWN0aW9uQnVpbGRlckZhY3RvcnknO1xuZXhwb3J0IHsgSW50ZXJmYWNlLCBVdGlscyB9O1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,89 @@
+import { Transaction } from './transaction';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { EntryFunctionABI, InputGenerateTransactionPayloadData, TransactionPayload } from '@aptos-labs/ts-sdk';
+import { CustomTransactionParams } from '../iface';
+/**
+ * Transaction class for custom Aptos transactions.
+ */
+export declare class CustomTransaction extends Transaction {
+    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,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAEL,gBAAgB,EAGhB,mCAAmC,EACnC,kBAAkB,EAUnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAInD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,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 transaction_1 = require("./transaction");
+const sdk_core_1 = require("@bitgo-beta/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) {
+        // 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 { Transaction } from './transaction';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport {\n  AccountAddress,\n  EntryFunctionABI,\n  EntryFunctionArgumentTypes,\n  SimpleEntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  TransactionPayload,\n  TransactionPayloadEntryFunction,\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    // 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,11 @@
+import { Transaction } from './transaction';
+import { InputGenerateTransactionPayloadData, TransactionPayload } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+export declare class DelegationPoolAddStakeTransaction extends Transaction {
+    constructor(coinConfig: Readonly<CoinConfig>);
+    protected parseTransactionPayload(payload: TransactionPayload): void;
+    protected getTransactionPayloadData(): InputGenerateTransactionPayloadData;
+    private isValidPayload;
+    private abi;
+}
+//# 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,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAGL,mCAAmC,EACnC,kBAAkB,EAInB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAI7D,qBAAa,iCAAkC,SAAQ,WAAW;gBACpD,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAM5C,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAUpE,SAAS,CAAC,yBAAyB,IAAI,mCAAmC;IAS1E,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,GAAG,CAGT;CACH"}

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

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegationPoolAddStakeTransaction = void 0;
+const transaction_1 = require("./transaction");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const constants_1 = require("../constants");
+const utils_1 = __importDefault(require("../utils"));
+class DelegationPoolAddStakeTransaction extends transaction_1.Transaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this.abi = {
+            typeParameters: [],
+            parameters: [new ts_sdk_1.TypeTagAddress(), new ts_sdk_1.TypeTagU64()],
+        };
+        this._type = sdk_core_1.TransactionType.StakingDelegate;
+        this._assetId = constants_1.APTOS_COIN;
+    }
+    parseTransactionPayload(payload) {
+        if (!this.isValidPayload(payload)) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid transaction payload');
+        }
+        const { entryFunction } = payload;
+        const addressArg = entryFunction.args[0];
+        const amountArg = entryFunction.args[1];
+        this.recipients = utils_1.default.parseRecipients(addressArg, amountArg);
+    }
+    getTransactionPayloadData() {
+        return {
+            function: constants_1.DELEGATION_POOL_ADD_STAKE_FUNCTION,
+            typeArguments: [],
+            functionArguments: [ts_sdk_1.AccountAddress.fromString(this.recipients[0].address), this.recipients[0].amount],
+            abi: this.abi,
+        };
+    }
+    isValidPayload(payload) {
+        return (payload instanceof ts_sdk_1.TransactionPayloadEntryFunction &&
+            payload.entryFunction.args.length === 2 &&
+            payload.entryFunction.type_args.length === 0);
+    }
+}
+exports.DelegationPoolAddStakeTransaction = DelegationPoolAddStakeTransaction;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import { Transaction } from './transaction';
+import { InputGenerateTransactionPayloadData, TransactionPayload } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+export declare class DigitalAssetTransfer extends Transaction {
+    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,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAGL,mCAAmC,EAGnC,kBAAkB,EAKnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAO7D,qBAAa,oBAAqB,SAAQ,WAAW;gBACvC,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"}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalAssetTransfer = void 0;
+const transaction_1 = require("./transaction");
+const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const constants_1 = require("../constants");
+class DigitalAssetTransfer extends transaction_1.Transaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this.transferDigitalAssetAbi = {
+            typeParameters: [{ constraints: [ts_sdk_1.MoveAbility.KEY] }],
+            parameters: [new ts_sdk_1.TypeTagStruct((0, ts_sdk_1.objectStructTag)(new ts_sdk_1.TypeTagGeneric(0))), new ts_sdk_1.TypeTagAddress()],
+        };
+        this._type = sdk_core_1.TransactionType.SendNFT;
+    }
+    parseTransactionPayload(payload) {
+        if (!(payload instanceof ts_sdk_1.TransactionPayloadEntryFunction) ||
+            payload.entryFunction.args.length !== 2 ||
+            payload.entryFunction.type_args.length !== 1 ||
+            constants_1.DIGITAL_ASSET_TYPE_ARGUMENT !== payload.entryFunction.type_args[0].toString()) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid transaction payload');
+        }
+        const entryFunction = payload.entryFunction;
+        this._assetId = entryFunction.args[0].toString();
+        this.recipients = [
+            {
+                address: entryFunction.args[1].toString(),
+                amount: constants_1.DIGITAL_ASSET_TRANSFER_AMOUNT,
+            },
+        ];
+    }
+    getTransactionPayloadData() {
+        const recipientAddress = ts_sdk_1.AccountAddress.fromString(this.recipients[0].address);
+        const digitalAssetAddress = ts_sdk_1.AccountAddress.fromString(this._assetId);
+        return {
+            function: constants_1.DIGITAL_ASSET_TRANSFER_FUNCTION,
+            typeArguments: [constants_1.DIGITAL_ASSET_TYPE_ARGUMENT],
+            functionArguments: [digitalAssetAddress, recipientAddress],
+            abi: this.transferDigitalAssetAbi,
+        };
+    }
+}
+exports.DigitalAssetTransfer = DigitalAssetTransfer;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import { Transaction } from './transaction';
+import { InputGenerateTransactionPayloadData, TransactionPayload } from '@aptos-labs/ts-sdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+export declare class FungibleAssetTransfer extends Transaction {
+    constructor(coinConfig: Readonly<CoinConfig>);
+    protected parseTransactionPayload(payload: TransactionPayload): void;
+    protected getTransactionPayloadData(): InputGenerateTransactionPayloadData;
+    private isValidPayload;
+    private faTransferAbi;
+    private batchFaTransferAbi;
+}
+//# sourceMappingURL=fungibleAssetTransfer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fungibleAssetTransfer.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/fungibleAssetTransfer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAGL,mCAAmC,EAEnC,kBAAkB,EAKnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAU7D,qBAAa,qBAAsB,SAAQ,WAAW;gBACxC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAWpE,SAAS,CAAC,yBAAyB,IAAI,mCAAmC;IA2B1E,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,aAAa,CAGnB;IAEF,OAAO,CAAC,kBAAkB,CAOxB;CACH"}