@onekeyfe/onekey-aptos-provider 2.2.18 → 2.2.19

package/dist/cjs/OnekeyMartianAptosProvider.js

@@ -12,7 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderAptosMartian = void 0;
 const extension_bridge_injected_1 = require("@onekeyfe/extension-bridge-injected");
 const OnekeyAptosProvider_1 = require("./OnekeyAptosProvider");
-const cross_inpage_provider_errors_1 = require("@onekeyfe/cross-inpage-provider-errors");
 const lodash_1 = require("lodash");
 class ProviderAptosMartian extends OnekeyAptosProvider_1.ProviderAptos {
     get publicKey() {
@@ -28,7 +27,16 @@ class ProviderAptosMartian extends OnekeyAptosProvider_1.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({
@@ -37,14 +45,12 @@ class ProviderAptosMartian extends OnekeyAptosProvider_1.ProviderAptos {
                 });
             }
             else {
-                const res = yield this._callMartianBridge({
-                    method: 'signAndSubmitTransaction',
-                    params: transaction,
-                });
-                if (!res)
-                    throw cross_inpage_provider_errors_1.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);
             }
         });
     }
@@ -59,6 +65,9 @@ class ProviderAptosMartian extends OnekeyAptosProvider_1.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({
@@ -88,13 +97,8 @@ class ProviderAptosMartian extends OnekeyAptosProvider_1.ProviderAptos {
                 }
                 else {
                     // aptos V1 sign transaction
-                    const res = yield this._callMartianBridge({
-                        method: 'signTransaction',
-                        params: transaction,
-                    });
-                    if (!res)
-                        throw cross_inpage_provider_errors_1.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/cjs/StandardProvider.js

@@ -110,12 +110,7 @@ class AptosStandardProvider {
             });
         });
         this.signAndSubmitTransaction = (input) => __awaiter(this, void 0, void 0, function* () {
-            const { payload } = input;
-            const existsBscEncodedArg = payload.functionArguments.find((arg) => (0, ts_sdk_1.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: wallet_standard_1.UserResponseStatus.APPROVED,
                 args: result,

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
+global.TextEncoder = util_1.TextEncoder;
+// @ts-expect-error
+global.TextDecoder = util_1.TextDecoder;
+const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const serializer_1 = require("../../serializer");
+const utils_1 = require("@noble/hashes/utils");
+const aptos_1 = require("aptos");
+const lodash_1 = require("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 = (0, serializer_1.serializeTransactionPayload)(payload);
+        const deserialized = (0, serializer_1.deserializeTransactionPayload)(serialized);
+        expect((0, lodash_1.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 aptos_1.TxnBuilderTypes.Script((0, utils_1.hexToBytes)('0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20'), [], [
+            new aptos_1.TxnBuilderTypes.TransactionArgumentU8(1),
+            new aptos_1.TxnBuilderTypes.TransactionArgumentU64(BigInt('18446744073709551615')),
+            new aptos_1.TxnBuilderTypes.TransactionArgumentU128(BigInt('340282366920938463463374607431768211455')),
+            new aptos_1.TxnBuilderTypes.TransactionArgumentBool(true),
+            new aptos_1.TxnBuilderTypes.TransactionArgumentAddress(new aptos_1.TxnBuilderTypes.AccountAddress((0, utils_1.hexToBytes)('1'.repeat(64)))),
+            new aptos_1.TxnBuilderTypes.TransactionArgumentU8Vector((0, utils_1.hexToBytes)('0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20')),
+        ]);
+        const payload = new aptos_1.TxnBuilderTypes.TransactionPayloadScript(script);
+        // @ts-expect-error
+        const serialized = (0, serializer_1.serializeTransactionPayload)(payload);
+        const deserialized = (0, serializer_1.deserializeTransactionPayload)(serialized);
+        expect((0, lodash_1.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 ts_sdk_1.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 ts_sdk_1.MoveOption) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.value).toEqual(currentSourceArg.value);
+            }
+            else if (currentDeserializedArg instanceof ts_sdk_1.MoveString ||
+                currentDeserializedArg instanceof ts_sdk_1.Bool) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.value).toEqual(currentSourceArg.value);
+            }
+            else if (currentDeserializedArg instanceof ts_sdk_1.U8 ||
+                currentDeserializedArg instanceof ts_sdk_1.U16 ||
+                currentDeserializedArg instanceof ts_sdk_1.U32 ||
+                currentDeserializedArg instanceof ts_sdk_1.U64 ||
+                currentDeserializedArg instanceof ts_sdk_1.U128 ||
+                currentDeserializedArg instanceof ts_sdk_1.U256) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.value.toString()).toEqual(currentSourceArg.value.toString());
+            }
+            else if (currentDeserializedArg instanceof ts_sdk_1.AccountAddress) {
+                // @ts-expect-error
+                expect(currentDeserializedArg.data).toEqual(currentSourceArg.value.address);
+            }
+            else {
+                throw new Error('Unknown argument type');
+            }
+        }
+    });
+});

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

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
+global.TextEncoder = util_1.TextEncoder;
+// @ts-expect-error
+global.TextDecoder = util_1.TextDecoder;
+const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const serializer_1 = require("../../serializer");
+const utils_1 = require("@noble/hashes/utils");
+function deepCompare(input, output) {
+    if (input instanceof ts_sdk_1.MoveVector && output instanceof ts_sdk_1.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 ts_sdk_1.MoveOption && output instanceof ts_sdk_1.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 = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.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 = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            expect(deserialized).toEqual(inputs);
+        });
+    });
+    describe('EntryFunctionArgumentTypes', () => {
+        it('should handle Move types', () => {
+            const inputs = [
+                new ts_sdk_1.Bool(true),
+                new ts_sdk_1.U8(255),
+                new ts_sdk_1.U16(65535),
+                new ts_sdk_1.U32(4294967295),
+                new ts_sdk_1.U64(BigInt('18446744073709551615')),
+                new ts_sdk_1.U128(BigInt('340282366920938463463374607431768211455')),
+                new ts_sdk_1.U256(BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')),
+                new ts_sdk_1.AccountAddress((0, utils_1.hexToBytes)('1'.repeat(64))),
+                new ts_sdk_1.MoveString('SDK'),
+                new ts_sdk_1.FixedBytes((0, utils_1.hexToBytes)('010203')),
+            ];
+            const serialized = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            deepCompare(inputs, deserialized);
+        });
+        it('should handle MoveVector with different element types', () => {
+            const inputs = [
+                new ts_sdk_1.MoveVector([new ts_sdk_1.U8(1), new ts_sdk_1.U8(2), new ts_sdk_1.U8(3)]),
+                new ts_sdk_1.MoveVector([new ts_sdk_1.Bool(true), new ts_sdk_1.Bool(false)]),
+                new ts_sdk_1.MoveVector([
+                    new ts_sdk_1.AccountAddress((0, utils_1.hexToBytes)('1'.repeat(64))),
+                    new ts_sdk_1.AccountAddress((0, utils_1.hexToBytes)('2'.repeat(64))),
+                ]),
+                new ts_sdk_1.MoveVector([
+                    new ts_sdk_1.MoveString('SDK'),
+                    new ts_sdk_1.MoveVector([new ts_sdk_1.Bool(true), new ts_sdk_1.Bool(false)]),
+                    new ts_sdk_1.MoveVector([new ts_sdk_1.U8(1), new ts_sdk_1.U8(2), new ts_sdk_1.U8(3)]),
+                    new ts_sdk_1.MoveVector([
+                        new ts_sdk_1.MoveVector([new ts_sdk_1.U8(1), new ts_sdk_1.U8(2), new ts_sdk_1.U8(3)]),
+                        new ts_sdk_1.MoveVector([new ts_sdk_1.Bool(true), new ts_sdk_1.Bool(false)]),
+                    ]),
+                ]),
+            ];
+            const serialized = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            deepCompare(inputs, deserialized);
+        });
+        it('should handle nested MoveOption', () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const inputs = [
+                new ts_sdk_1.MoveOption(), // None
+                new ts_sdk_1.MoveOption(new ts_sdk_1.U64(BigInt(42))), // Some(U64)
+                new ts_sdk_1.MoveOption(new ts_sdk_1.MoveOption(new ts_sdk_1.Bool(true))), // Some(Some(Bool))
+                new ts_sdk_1.MoveOption(new ts_sdk_1.MoveVector([new ts_sdk_1.U8(1), new ts_sdk_1.U8(2)])), // Some(Vector<U8>)
+            ];
+            const serialized = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            // None
+            expect(deserialized[0]).toBeInstanceOf(ts_sdk_1.MoveOption);
+            expect(deserialized[0].isSome()).toBe(false);
+            // Some(U64)
+            expect(deserialized[1]).toBeInstanceOf(ts_sdk_1.MoveOption);
+            expect(deserialized[1].isSome()).toBe(true);
+            expect(deserialized[1].value).toBeInstanceOf(ts_sdk_1.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(ts_sdk_1.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(ts_sdk_1.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(ts_sdk_1.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 ts_sdk_1.U64(BigInt('18446744073709551615')), // U64 max value
+                new ts_sdk_1.U128(BigInt('340282366920938463463374607431768211455')), // U128 max value
+                new ts_sdk_1.U256(BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')), // U256 max value
+            ];
+            const serialized = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            deepCompare(inputs, deserialized);
+        });
+        it('should handle large MoveVector', () => {
+            const largeArray = Array.from({ length: 10000 }, (_, i) => new ts_sdk_1.U8(i % 256));
+            const inputs = [new ts_sdk_1.MoveVector(largeArray)];
+            const serialized = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            deepCompare(inputs, deserialized);
+        });
+    });
+    describe('Mixed Types', () => {
+        it('should handle mixture of simple and Move types', () => {
+            var _a;
+            const inputs = [
+                42,
+                new ts_sdk_1.U64(BigInt(42)),
+                'hello',
+                new ts_sdk_1.MoveString('hello'),
+                [1, 2, new ts_sdk_1.U8(3)],
+                new ts_sdk_1.MoveVector([new ts_sdk_1.U8(1), new ts_sdk_1.U8(2)]),
+                new ts_sdk_1.MoveOption(new ts_sdk_1.FixedBytes((0, utils_1.hexToBytes)('010203'))),
+                [
+                    new ts_sdk_1.MoveOption(new ts_sdk_1.U64(BigInt(42))),
+                    new ts_sdk_1.MoveVector([new ts_sdk_1.Bool(true), new ts_sdk_1.Bool(false)]),
+                    'simple string',
+                    456,
+                ],
+            ];
+            const serialized = (0, serializer_1.serializeArguments)(inputs);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            // 验证简单类型
+            expect(deserialized[0]).toBe(42);
+            expect(deserialized[2]).toBe('hello');
+            // 验证 Move 类型
+            expect(deserialized[1]).toBeInstanceOf(ts_sdk_1.U64);
+            expect(deserialized[1].value).toBe(BigInt(42));
+            expect(deserialized[3]).toBeInstanceOf(ts_sdk_1.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(ts_sdk_1.U8);
+            expect(mixedArray[2].value).toBe(3);
+            // 验证 MoveVector
+            expect(deserialized[5]).toBeInstanceOf(ts_sdk_1.MoveVector);
+            // 验证 MoveOption
+            expect(deserialized[6]).toBeInstanceOf(ts_sdk_1.MoveOption);
+            expect(deserialized[6].isSome()).toBe(true);
+            const fixedBytes = deserialized[6].value;
+            expect(fixedBytes).toBeInstanceOf(ts_sdk_1.FixedBytes);
+            expect(fixedBytes === null || fixedBytes === void 0 ? void 0 : fixedBytes.toString()).toEqual(new ts_sdk_1.FixedBytes((0, utils_1.hexToBytes)('010203')).toString());
+            // 验证复杂嵌套结构
+            const complexArray = deserialized[7];
+            expect(complexArray[0]).toBeInstanceOf(ts_sdk_1.MoveOption);
+            expect(complexArray[0].isSome()).toBe(true);
+            const index70 = complexArray[0];
+            expect(index70).toBeInstanceOf(ts_sdk_1.MoveOption);
+            expect(index70.isSome()).toBe(true);
+            expect(index70.value).toBeInstanceOf(ts_sdk_1.U64);
+            expect((_a = index70.value) === null || _a === void 0 ? void 0 : _a.value).toBe(BigInt(42));
+            const index71 = complexArray[1];
+            expect(index71).toBeInstanceOf(ts_sdk_1.MoveVector);
+            expect(index71.values[0]).toBeInstanceOf(ts_sdk_1.Bool);
+            expect(index71.values[0].value).toBe(true);
+            expect(index71.values[1]).toBeInstanceOf(ts_sdk_1.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 ts_sdk_1.MoveVector([
+                    new ts_sdk_1.MoveOption(new ts_sdk_1.U64(BigInt(1))),
+                    new ts_sdk_1.MoveOption(new ts_sdk_1.U64(BigInt(2))),
+                    new ts_sdk_1.MoveOption(),
+                ]),
+                [
+                    new ts_sdk_1.AccountAddress((0, utils_1.hexToBytes)('1'.repeat(64))),
+                    123,
+                    new ts_sdk_1.MoveVector([new ts_sdk_1.Bool(true), new ts_sdk_1.Bool(false)]),
+                    [new ts_sdk_1.MoveOption(new ts_sdk_1.MoveVector([new ts_sdk_1.U8(1), new ts_sdk_1.U8(2)])), 'nested string', BigInt(456)],
+                ],
+            ];
+            const serialized = (0, serializer_1.serializeArguments)(complexStruct);
+            const deserialized = (0, serializer_1.deserializeArguments)(serialized);
+            // 验证第一个元素：MoveVector<MoveOption<U64>>
+            const vectorOfOptions = deserialized[0];
+            expect(vectorOfOptions).toBeInstanceOf(ts_sdk_1.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(ts_sdk_1.AccountAddress);
+            expect(mixedArray[1]).toBe(123);
+            expect(mixedArray[2]).toBeInstanceOf(ts_sdk_1.MoveVector);
+            // 验证深层嵌套
+            const nestedArray = mixedArray[3];
+            expect(nestedArray[0]).toBeInstanceOf(ts_sdk_1.MoveOption);
+            expect(nestedArray[1]).toBe('nested string');
+            expect(nestedArray[2]).toBe(BigInt(456));
+        });
+    });
+});

package/dist/cjs/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./OnekeyAptosProvider"), exports);
 __exportStar(require("./OnekeyMartianAptosProvider"), exports);
 __exportStar(require("./ProviderAptosBase"), exports);
 __exportStar(require("./StandardProvider"), exports);
+__exportStar(require("./serializer"), exports);