@onekeyfe/onekey-aptos-provider 2.2.18 → 2.2.19

package/dist/OnekeyAptosProvider.d.ts

@@ -4,7 +4,7 @@ import { AptosAccountInfo, ProviderState, SignMessagePayload, SignMessagePayload
 import { IJsonRpcRequest } from '@onekeyfe/cross-inpage-provider-types';
 import type { Types } from 'aptos';
 import type { AccountAuthenticator } from '@aptos-labs/ts-sdk';
-import { AptosSignAndSubmitTransactionOutput } from '@aptos-labs/wallet-standard';
+import { AptosSignAndSubmitTransactionInput, AptosSignAndSubmitTransactionOutput } from '@aptos-labs/wallet-standard';
 export type AptosProviderType = 'petra' | 'martian';
 type SignTransactionV2Params = {
     transaction: string;
@@ -34,8 +34,8 @@ export type AptosRequest = {
     'network': () => Promise<string>;
     'getNetworkURL': () => Promise<string>;
     'signMessage': (payload: SignMessagePayloadCompatible) => Promise<SignMessageResponseCompatible>;
-    'signAndSubmitTransaction': (transactions: Types.TransactionPayload) => Promise<string>;
-    'signTransaction': (transactions: Types.TransactionPayload) => Promise<string>;
+    'signAndSubmitTransaction': (transactions: string) => Promise<string>;
+    'signTransaction': (transactions: string) => Promise<string>;
     'signTransactionV2': (params: SignTransactionV2Params) => Promise<{
         type: 'ed25519' | 'multi_ed25519' | 'secp256k1';
         signature: string;
@@ -67,7 +67,7 @@ export interface IProviderAptos extends ProviderAptosBase {
     signAndSubmitTransaction(transactions: any): Promise<any>;
     signTransaction(transactions: any): Promise<any>;
     signTransactionV2(params: SignTransactionV2Params): Promise<AccountAuthenticator>;
-    signAndSubmitTransactionV2(params: string): Promise<AptosSignAndSubmitTransactionOutput>;
+    signAndSubmitTransactionV2(params: AptosSignAndSubmitTransactionInput): Promise<AptosSignAndSubmitTransactionOutput>;
     /**
      * Sign message
      * @returns Transaction
@@ -100,9 +100,9 @@ declare class ProviderAptos extends ProviderAptosBase implements IProviderAptos
     isConnected(): boolean;
     account(): Promise<AptosAccountInfo>;
     signAndSubmitTransaction(transactions: any): Promise<any>;
-    signTransaction(transactions: any): Promise<any>;
+    signTransaction(transactions: Types.TransactionPayload): Promise<any>;
     signTransactionV2(params: SignTransactionV2Params): Promise<AccountAuthenticator>;
-    signAndSubmitTransactionV2(params: string): Promise<AptosSignAndSubmitTransactionOutput>;
+    signAndSubmitTransactionV2(params: AptosSignAndSubmitTransactionInput): Promise<AptosSignAndSubmitTransactionOutput>;
     signMessageCompatible(payload: SignMessagePayloadCompatible): Promise<SignMessageResponseCompatible>;
     signMessage(payload: SignMessagePayload): Promise<SignMessageResponse>;
     network(): Promise<string>;

package/dist/OnekeyAptosProvider.js

@@ -11,6 +11,7 @@ import { getOrCreateExtInjectedJsBridge } from '@onekeyfe/extension-bridge-injec
 import { ProviderAptosBase } from './ProviderAptosBase';
 import { web3Errors } from '@onekeyfe/cross-inpage-provider-errors';
 import { AccountAuthenticatorEd25519, Ed25519PublicKey, Ed25519Signature, } from '@aptos-labs/ts-sdk';
+import { serializeTransactionPayload } from './serializer';
 const PROVIDER_EVENTS = {
     'connect': 'connect',
     'disconnect': 'disconnect',
@@ -147,9 +148,10 @@ class ProviderAptos extends ProviderAptosBase {
     }
     signAndSubmitTransaction(transactions) {
         return __awaiter(this, void 0, void 0, function* () {
+            const serialize = serializeTransactionPayload(transactions);
             const res = yield this._callBridge({
                 method: 'signAndSubmitTransaction',
-                params: transactions,
+                params: serialize,
             });
             if (!res)
                 throw web3Errors.provider.unauthorized();
@@ -159,9 +161,10 @@ class ProviderAptos extends ProviderAptosBase {
     }
     signTransaction(transactions) {
         return __awaiter(this, void 0, void 0, function* () {
+            const serialize = serializeTransactionPayload(transactions);
             const res = yield this._callBridge({
                 method: 'signTransaction',
-                params: transactions,
+                params: serialize,
             });
             if (!res)
                 throw web3Errors.provider.unauthorized();
@@ -188,9 +191,15 @@ class ProviderAptos extends ProviderAptosBase {
     }
     signAndSubmitTransactionV2(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            const serialize = serializeTransactionPayload(params.payload);
+            const param = {
+                gasUnitPrice: params.gasUnitPrice,
+                maxGasAmount: params.maxGasAmount,
+                payload: serialize,
+            };
             return this._callBridge({
                 method: 'signAndSubmitTransactionV2',
-                params,
+                params: JSON.stringify(param),
             });
         });
     }

package/dist/OnekeyMartianAptosProvider.d.ts

@@ -43,6 +43,7 @@ declare class ProviderAptosMartian extends ProviderAptos {
     get publicKey(): string | null;
     constructor(props: OneKeyAptosProviderProps);
     private _callMartianBridge;
+    hasStandardV2SignAndSubmitTransaction(transaction: string | Types.TransactionPayload): boolean;
     signAndSubmitTransaction(transaction: string | Types.TransactionPayload): Promise<string | Types.Transaction>;
     hasStandardV2SignTransaction(transaction: string | Types.TransactionPayload): boolean;
     signTransaction(transaction: string | Types.TransactionPayload, asFeePayer?: boolean): Promise<string | Uint8Array>;

package/dist/OnekeyMartianAptosProvider.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { getOrCreateExtInjectedJsBridge } from '@onekeyfe/extension-bridge-injected';
 import { ProviderAptos } from './OnekeyAptosProvider';
-import { web3Errors } from '@onekeyfe/cross-inpage-provider-errors';
 import { get } from 'lodash';
 class ProviderAptosMartian extends ProviderAptos {
     get publicKey() {
@@ -25,7 +24,16 @@ class ProviderAptosMartian extends ProviderAptos {
         params.aptosProviderType = this.aptosProviderType;
         return this.bridgeRequest(params);
     }
+    hasStandardV2SignAndSubmitTransaction(transaction) {
+        if (typeof transaction === 'object' && 'payload' in transaction && !('type' in transaction)) {
+            return true;
+        }
+        return false;
+    }
     signAndSubmitTransaction(transaction) {
+        const _super = Object.create(null, {
+            signAndSubmitTransaction: { get: () => super.signAndSubmitTransaction }
+        });
         return __awaiter(this, void 0, void 0, function* () {
             if (typeof transaction === 'string') {
                 return yield this._callMartianBridge({
@@ -34,14 +42,12 @@ class ProviderAptosMartian extends ProviderAptos {
                 });
             }
             else {
-                const res = yield this._callMartianBridge({
-                    method: 'signAndSubmitTransaction',
-                    params: transaction,
-                });
-                if (!res)
-                    throw web3Errors.provider.unauthorized();
+                if (this.hasStandardV2SignAndSubmitTransaction(transaction)) {
+                    // @ts-expect-error
+                    return yield this.signAndSubmitTransactionV2(transaction);
+                }
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return JSON.parse(res);
+                return _super.signAndSubmitTransaction.call(this, transaction);
             }
         });
     }
@@ -56,6 +62,9 @@ class ProviderAptosMartian extends ProviderAptos {
     signTransaction(transaction, 
     // V2 sign transaction as fee payer
     asFeePayer) {
+        const _super = Object.create(null, {
+            signTransaction: { get: () => super.signTransaction }
+        });
         return __awaiter(this, void 0, void 0, function* () {
             if (typeof transaction === 'string') {
                 return this._callMartianBridge({
@@ -85,13 +94,8 @@ class ProviderAptosMartian extends ProviderAptos {
                 }
                 else {
                     // aptos V1 sign transaction
-                    const res = yield this._callMartianBridge({
-                        method: 'signTransaction',
-                        params: transaction,
-                    });
-                    if (!res)
-                        throw web3Errors.provider.unauthorized();
-                    return new Uint8Array(Buffer.from(res, 'hex'));
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                    return _super.signTransaction.call(this, transaction);
                 }
             }
         });

package/dist/StandardProvider.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Ed25519Signature, Ed25519PublicKey, Network, AccountAddress, isEncodedEntryFunctionArgument, } from '@aptos-labs/ts-sdk';
+import { Ed25519Signature, Ed25519PublicKey, Network, AccountAddress } from '@aptos-labs/ts-sdk';
 import { APTOS_CHAINS, AccountInfo, registerWallet, UserResponseStatus, } from '@aptos-labs/wallet-standard';
 import { stripHexPrefix } from './utils';
 export class WalletAccount {
@@ -105,12 +105,7 @@ export class AptosStandardProvider {
             });
         });
         this.signAndSubmitTransaction = (input) => __awaiter(this, void 0, void 0, function* () {
-            const { payload } = input;
-            const existsBscEncodedArg = payload.functionArguments.find((arg) => isEncodedEntryFunctionArgument(arg));
-            if (existsBscEncodedArg) {
-                throw new Error('Unsupported Function Arguments type');
-            }
-            const result = yield this.provider.signAndSubmitTransactionV2(JSON.stringify(input));
+            const result = yield this.provider.signAndSubmitTransactionV2(input);
             return Promise.resolve({
                 status: UserResponseStatus.APPROVED,
                 args: result,

package/dist/__tests__/fixtures/payloadSerializer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/fixtures/payloadSerializer.test.js

@@ -0,0 +1,94 @@
+import { TextEncoder, TextDecoder } from 'util';
+global.TextEncoder = TextEncoder;
+// @ts-expect-error
+global.TextDecoder = TextDecoder;
+import { Bool, U8, U16, U32, U64, U128, U256, AccountAddress, MoveVector, MoveOption, MoveString, } from '@aptos-labs/ts-sdk';
+import { serializeTransactionPayload, deserializeTransactionPayload } from '../../serializer';
+import { hexToBytes } from '@noble/hashes/utils';
+import { TxnBuilderTypes } from 'aptos';
+import { get } from 'lodash';
+describe('TransactionPayloadSerializer', () => {
+    it('serialize v1 payload', () => {
+        const payload = {
+            type: 'script_payload',
+            code: {
+                bytecode: '0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20',
+            },
+            type_arguments: [],
+            arguments: [
+                1,
+                '18446744073709551615',
+                '340282366920938463463374607431768211455',
+                true,
+                '1'.repeat(64),
+                '0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20',
+            ],
+        };
+        const serialized = serializeTransactionPayload(payload);
+        const deserialized = deserializeTransactionPayload(serialized);
+        expect(get(deserialized, 'bytecode')).toEqual(payload.code.bytecode);
+        const sourceArgs = payload.arguments;
+        const deserializedArgs = deserialized.functionArguments;
+        expect(deserializedArgs.length).toEqual(sourceArgs.length);
+        for (let i = 0; i < sourceArgs.length; i++) {
+            const currentSourceArg = sourceArgs[i];
+            const currentDeserializedArg = deserializedArgs[i];
+            expect(currentDeserializedArg === null || currentDeserializedArg === void 0 ? void 0 : currentDeserializedArg.toString()).toEqual(currentSourceArg.toString());
+        }
+    });
+    it('serialize v1 wormhole payload', () => {
+        const script = new TxnBuilderTypes.Script(hexToBytes('0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20'), [], [
+            new TxnBuilderTypes.TransactionArgumentU8(1),
+            new TxnBuilderTypes.TransactionArgumentU64(BigInt('18446744073709551615')),
+            new TxnBuilderTypes.TransactionArgumentU128(BigInt('340282366920938463463374607431768211455')),
+            new TxnBuilderTypes.TransactionArgumentBool(true),
+            new TxnBuilderTypes.TransactionArgumentAddress(new TxnBuilderTypes.AccountAddress(hexToBytes('1'.repeat(64)))),
+            new TxnBuilderTypes.TransactionArgumentU8Vector(hexToBytes('0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20')),
+        ]);
+        const payload = new TxnBuilderTypes.TransactionPayloadScript(script);
+        // @ts-expect-error
+        const serialized = serializeTransactionPayload(payload);
+        const deserialized = deserializeTransactionPayload(serialized);
+        expect(get(deserialized, 'bytecode')).toEqual(script.code);
+        const sourceArgs = script.args;
+        const deserializedArgs = deserialized.functionArguments;
+        expect(deserializedArgs.length).toEqual(sourceArgs.length);
+        for (let i = 0; i < sourceArgs.length; i++) {
+            const currentSourceArg = sourceArgs[i];
+            const currentDeserializedArg = deserializedArgs[i];
+            if (currentDeserializedArg instanceof MoveVector) {
+                // @ts-expect-error
+                const currentSourceArgValues = currentSourceArg.value;
+                const currentDeserializedArgValues = currentDeserializedArg.values;
+                for (let j = 0; j < currentSourceArgValues.length; j++) {
+                    expect(currentDeserializedArgValues[j].value).toEqual(currentSourceArgValues[j]);
+                }
+            }
+            else if (currentDeserializedArg instanceof MoveOption) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.value).toEqual(currentSourceArg.value);
+            }
+            else if (currentDeserializedArg instanceof MoveString ||
+                currentDeserializedArg instanceof Bool) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.value).toEqual(currentSourceArg.value);
+            }
+            else if (currentDeserializedArg instanceof U8 ||
+                currentDeserializedArg instanceof U16 ||
+                currentDeserializedArg instanceof U32 ||
+                currentDeserializedArg instanceof U64 ||
+                currentDeserializedArg instanceof U128 ||
+                currentDeserializedArg instanceof U256) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.value.toString()).toEqual(currentSourceArg.value.toString());
+            }
+            else if (currentDeserializedArg instanceof AccountAddress) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.data).toEqual(currentSourceArg.value.address);
+            }
+            else {
+                throw new Error('Unknown argument type');
+            }
+        }
+    });
+});

package/dist/__tests__/fixtures/serializer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/fixtures/serializer.test.js

@@ -0,0 +1,256 @@
+import { TextEncoder, TextDecoder } from 'util';
+global.TextEncoder = TextEncoder;
+// @ts-expect-error
+global.TextDecoder = TextDecoder;
+import { Bool, U8, U16, U32, U64, U128, U256, AccountAddress, MoveVector, MoveOption, MoveString, FixedBytes, } from '@aptos-labs/ts-sdk';
+import { serializeArguments, deserializeArguments } from '../../serializer';
+import { hexToBytes } from '@noble/hashes/utils';
+function deepCompare(input, output) {
+    if (input instanceof MoveVector && output instanceof MoveVector) {
+        if (input.values.length !== output.values.length) {
+            return false;
+        }
+        return input.values.every((val, index) => deepCompare(val, output.values[index]));
+    }
+    else if (input instanceof MoveOption && output instanceof MoveOption) {
+        if (input.isSome() !== output.isSome()) {
+            return false;
+        }
+        return input.isSome() ? deepCompare(input.value, output.value) : true;
+    }
+    else if (input instanceof Object && output instanceof Object) {
+        return input.constructor === output.constructor && input.value === output.value;
+    }
+    else {
+        return input === output;
+    }
+}
+describe('Serializer', () => {
+    describe('SimpleEntryFunctionArgumentTypes', () => {
+        it('should handle primitive types', () => {
+            const inputs = [
+                null,
+                undefined,
+                true,
+                false,
+                42,
+                BigInt('0x1234567890'),
+                'hello world',
+                new Uint8Array([1, 2, 3]),
+                new ArrayBuffer(3),
+            ];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            expect(deserialized[0]).toBeNull();
+            expect(deserialized[1]).toBeUndefined();
+            expect(deserialized[2]).toBe(true);
+            expect(deserialized[3]).toBe(false);
+            expect(deserialized[4]).toBe(42);
+            expect(deserialized[5]).toBe(BigInt('0x1234567890'));
+            expect(deserialized[6]).toBe('hello world');
+            expect(deserialized[7]).toEqual(new Uint8Array([1, 2, 3]));
+            expect(deserialized[8]).toBeInstanceOf(ArrayBuffer);
+        });
+        it('should handle nested arrays of primitive types', () => {
+            const inputs = [
+                [1, 2, 3],
+                ['a', 'b', 'c'],
+                [true, false],
+                [BigInt(1), BigInt(2)],
+                [
+                    [1, 2],
+                    [3, 4],
+                ],
+            ];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            expect(deserialized).toEqual(inputs);
+        });
+    });
+    describe('EntryFunctionArgumentTypes', () => {
+        it('should handle Move types', () => {
+            const inputs = [
+                new Bool(true),
+                new U8(255),
+                new U16(65535),
+                new U32(4294967295),
+                new U64(BigInt('18446744073709551615')),
+                new U128(BigInt('340282366920938463463374607431768211455')),
+                new U256(BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')),
+                new AccountAddress(hexToBytes('1'.repeat(64))),
+                new MoveString('SDK'),
+                new FixedBytes(hexToBytes('010203')),
+            ];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            deepCompare(inputs, deserialized);
+        });
+        it('should handle MoveVector with different element types', () => {
+            const inputs = [
+                new MoveVector([new U8(1), new U8(2), new U8(3)]),
+                new MoveVector([new Bool(true), new Bool(false)]),
+                new MoveVector([
+                    new AccountAddress(hexToBytes('1'.repeat(64))),
+                    new AccountAddress(hexToBytes('2'.repeat(64))),
+                ]),
+                new MoveVector([
+                    new MoveString('SDK'),
+                    new MoveVector([new Bool(true), new Bool(false)]),
+                    new MoveVector([new U8(1), new U8(2), new U8(3)]),
+                    new MoveVector([
+                        new MoveVector([new U8(1), new U8(2), new U8(3)]),
+                        new MoveVector([new Bool(true), new Bool(false)]),
+                    ]),
+                ]),
+            ];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            deepCompare(inputs, deserialized);
+        });
+        it('should handle nested MoveOption', () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const inputs = [
+                new MoveOption(), // None
+                new MoveOption(new U64(BigInt(42))), // Some(U64)
+                new MoveOption(new MoveOption(new Bool(true))), // Some(Some(Bool))
+                new MoveOption(new MoveVector([new U8(1), new U8(2)])), // Some(Vector<U8>)
+            ];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            // None
+            expect(deserialized[0]).toBeInstanceOf(MoveOption);
+            expect(deserialized[0].isSome()).toBe(false);
+            // Some(U64)
+            expect(deserialized[1]).toBeInstanceOf(MoveOption);
+            expect(deserialized[1].isSome()).toBe(true);
+            expect(deserialized[1].value).toBeInstanceOf(U64);
+            expect((_a = deserialized[1].value) === null || _a === void 0 ? void 0 : _a.value).toBe(BigInt(42));
+            // Some(Some(Bool))
+            const nestedOption = deserialized[2];
+            expect(nestedOption.isSome()).toBe(true);
+            expect(nestedOption.value).toBeInstanceOf(MoveOption);
+            expect((_b = nestedOption.value) === null || _b === void 0 ? void 0 : _b.isSome()).toBe(true);
+            expect((_c = nestedOption.value) === null || _c === void 0 ? void 0 : _c.value).toBeInstanceOf(Bool);
+            expect((_e = (_d = nestedOption.value) === null || _d === void 0 ? void 0 : _d.value) === null || _e === void 0 ? void 0 : _e.value).toBe(true);
+            // Some(Vector<U8>)
+            const optionVector = deserialized[3];
+            expect(optionVector.isSome()).toBe(true);
+            expect(optionVector.value).toBeInstanceOf(MoveVector);
+            expect((_f = optionVector.value) === null || _f === void 0 ? void 0 : _f.values.length).toBe(2);
+            expect((_g = optionVector.value) === null || _g === void 0 ? void 0 : _g.values[0].value).toBe(1);
+            expect((_h = optionVector.value) === null || _h === void 0 ? void 0 : _h.values[1].value).toBe(2);
+        });
+        it('should handle large numbers for U64, U128, and U256', () => {
+            const inputs = [
+                new U64(BigInt('18446744073709551615')), // U64 max value
+                new U128(BigInt('340282366920938463463374607431768211455')), // U128 max value
+                new U256(BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')), // U256 max value
+            ];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            deepCompare(inputs, deserialized);
+        });
+        it('should handle large MoveVector', () => {
+            const largeArray = Array.from({ length: 10000 }, (_, i) => new U8(i % 256));
+            const inputs = [new MoveVector(largeArray)];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            deepCompare(inputs, deserialized);
+        });
+    });
+    describe('Mixed Types', () => {
+        it('should handle mixture of simple and Move types', () => {
+            var _a;
+            const inputs = [
+                42,
+                new U64(BigInt(42)),
+                'hello',
+                new MoveString('hello'),
+                [1, 2, new U8(3)],
+                new MoveVector([new U8(1), new U8(2)]),
+                new MoveOption(new FixedBytes(hexToBytes('010203'))),
+                [
+                    new MoveOption(new U64(BigInt(42))),
+                    new MoveVector([new Bool(true), new Bool(false)]),
+                    'simple string',
+                    456,
+                ],
+            ];
+            const serialized = serializeArguments(inputs);
+            const deserialized = deserializeArguments(serialized);
+            // 验证简单类型
+            expect(deserialized[0]).toBe(42);
+            expect(deserialized[2]).toBe('hello');
+            // 验证 Move 类型
+            expect(deserialized[1]).toBeInstanceOf(U64);
+            expect(deserialized[1].value).toBe(BigInt(42));
+            expect(deserialized[3]).toBeInstanceOf(MoveString);
+            expect(deserialized[3].value).toBe('hello');
+            // 验证混合数组
+            const mixedArray = deserialized[4];
+            expect(mixedArray[0]).toBe(1);
+            expect(mixedArray[1]).toBe(2);
+            expect(mixedArray[2]).toBeInstanceOf(U8);
+            expect(mixedArray[2].value).toBe(3);
+            // 验证 MoveVector
+            expect(deserialized[5]).toBeInstanceOf(MoveVector);
+            // 验证 MoveOption
+            expect(deserialized[6]).toBeInstanceOf(MoveOption);
+            expect(deserialized[6].isSome()).toBe(true);
+            const fixedBytes = deserialized[6].value;
+            expect(fixedBytes).toBeInstanceOf(FixedBytes);
+            expect(fixedBytes === null || fixedBytes === void 0 ? void 0 : fixedBytes.toString()).toEqual(new FixedBytes(hexToBytes('010203')).toString());
+            // 验证复杂嵌套结构
+            const complexArray = deserialized[7];
+            expect(complexArray[0]).toBeInstanceOf(MoveOption);
+            expect(complexArray[0].isSome()).toBe(true);
+            const index70 = complexArray[0];
+            expect(index70).toBeInstanceOf(MoveOption);
+            expect(index70.isSome()).toBe(true);
+            expect(index70.value).toBeInstanceOf(U64);
+            expect((_a = index70.value) === null || _a === void 0 ? void 0 : _a.value).toBe(BigInt(42));
+            const index71 = complexArray[1];
+            expect(index71).toBeInstanceOf(MoveVector);
+            expect(index71.values[0]).toBeInstanceOf(Bool);
+            expect(index71.values[0].value).toBe(true);
+            expect(index71.values[1]).toBeInstanceOf(Bool);
+            expect(index71.values[1].value).toBe(false);
+            expect(complexArray[2]).toBe('simple string');
+            expect(complexArray[3]).toBe(456);
+        });
+        it('should handle complex nested structures', () => {
+            var _a, _b;
+            const complexStruct = [
+                new MoveVector([
+                    new MoveOption(new U64(BigInt(1))),
+                    new MoveOption(new U64(BigInt(2))),
+                    new MoveOption(),
+                ]),
+                [
+                    new AccountAddress(hexToBytes('1'.repeat(64))),
+                    123,
+                    new MoveVector([new Bool(true), new Bool(false)]),
+                    [new MoveOption(new MoveVector([new U8(1), new U8(2)])), 'nested string', BigInt(456)],
+                ],
+            ];
+            const serialized = serializeArguments(complexStruct);
+            const deserialized = deserializeArguments(serialized);
+            // 验证第一个元素：MoveVector<MoveOption<U64>>
+            const vectorOfOptions = deserialized[0];
+            expect(vectorOfOptions).toBeInstanceOf(MoveVector);
+            expect((_a = vectorOfOptions.values[0].value) === null || _a === void 0 ? void 0 : _a.value).toBe(BigInt(1));
+            expect((_b = vectorOfOptions.values[1].value) === null || _b === void 0 ? void 0 : _b.value).toBe(BigInt(2));
+            expect(vectorOfOptions.values[2].isSome()).toBe(false);
+            // 验证第二个元素：混合数组
+            const mixedArray = deserialized[1];
+            expect(mixedArray[0]).toBeInstanceOf(AccountAddress);
+            expect(mixedArray[1]).toBe(123);
+            expect(mixedArray[2]).toBeInstanceOf(MoveVector);
+            // 验证深层嵌套
+            const nestedArray = mixedArray[3];
+            expect(nestedArray[0]).toBeInstanceOf(MoveOption);
+            expect(nestedArray[1]).toBe('nested string');
+            expect(nestedArray[2]).toBe(BigInt(456));
+        });
+    });
+});

package/dist/cjs/OnekeyAptosProvider.js

@@ -14,6 +14,7 @@ const extension_bridge_injected_1 = require("@onekeyfe/extension-bridge-injected
 const ProviderAptosBase_1 = require("./ProviderAptosBase");
 const cross_inpage_provider_errors_1 = require("@onekeyfe/cross-inpage-provider-errors");
 const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const serializer_1 = require("./serializer");
 const PROVIDER_EVENTS = {
     'connect': 'connect',
     'disconnect': 'disconnect',
@@ -150,9 +151,10 @@ class ProviderAptos extends ProviderAptosBase_1.ProviderAptosBase {
     }
     signAndSubmitTransaction(transactions) {
         return __awaiter(this, void 0, void 0, function* () {
+            const serialize = (0, serializer_1.serializeTransactionPayload)(transactions);
             const res = yield this._callBridge({
                 method: 'signAndSubmitTransaction',
-                params: transactions,
+                params: serialize,
             });
             if (!res)
                 throw cross_inpage_provider_errors_1.web3Errors.provider.unauthorized();
@@ -162,9 +164,10 @@ class ProviderAptos extends ProviderAptosBase_1.ProviderAptosBase {
     }
     signTransaction(transactions) {
         return __awaiter(this, void 0, void 0, function* () {
+            const serialize = (0, serializer_1.serializeTransactionPayload)(transactions);
             const res = yield this._callBridge({
                 method: 'signTransaction',
-                params: transactions,
+                params: serialize,
             });
             if (!res)
                 throw cross_inpage_provider_errors_1.web3Errors.provider.unauthorized();
@@ -191,9 +194,15 @@ class ProviderAptos extends ProviderAptosBase_1.ProviderAptosBase {
     }
     signAndSubmitTransactionV2(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            const serialize = (0, serializer_1.serializeTransactionPayload)(params.payload);
+            const param = {
+                gasUnitPrice: params.gasUnitPrice,
+                maxGasAmount: params.maxGasAmount,
+                payload: serialize,
+            };
             return this._callBridge({
                 method: 'signAndSubmitTransactionV2',
-                params,
+                params: JSON.stringify(param),
             });
         });
     }