@onekeyfe/onekey-aptos-provider 2.2.18 → 2.2.19

package/dist/serializer.js

@@ -0,0 +1,424 @@
+import { Serializer, Deserializer, MoveVector, MoveOption, U8, U64, U128, AccountAddress, Bool, U16, U32, U256, Serialized, MoveString, FixedBytes, TypeTag, standardizeTypeTags, } from '@aptos-labs/ts-sdk';
+import { hexToBytes, bytesToHex } from '@noble/hashes/utils';
+export var TransactionPayloadType;
+(function (TransactionPayloadType) {
+    TransactionPayloadType[TransactionPayloadType["SCRIPT"] = 0] = "SCRIPT";
+    TransactionPayloadType[TransactionPayloadType["ENTRY_FUNCTION"] = 1] = "ENTRY_FUNCTION";
+    TransactionPayloadType[TransactionPayloadType["SCRIPT_LEGACY"] = 2] = "SCRIPT_LEGACY";
+    TransactionPayloadType[TransactionPayloadType["ENTRY_FUNCTION_LEGACY"] = 3] = "ENTRY_FUNCTION_LEGACY";
+})(TransactionPayloadType || (TransactionPayloadType = {}));
+// OneKey Primitive Types
+export var ArgumentType;
+(function (ArgumentType) {
+    ArgumentType[ArgumentType["NULL"] = 10000] = "NULL";
+    ArgumentType[ArgumentType["UNDEFINED"] = 10001] = "UNDEFINED";
+    ArgumentType[ArgumentType["BOOLEAN"] = 10002] = "BOOLEAN";
+    ArgumentType[ArgumentType["NUMBER"] = 10003] = "NUMBER";
+    ArgumentType[ArgumentType["BIGINT"] = 10004] = "BIGINT";
+    ArgumentType[ArgumentType["STRING"] = 10005] = "STRING";
+    ArgumentType[ArgumentType["UINT8_ARRAY"] = 10006] = "UINT8_ARRAY";
+    ArgumentType[ArgumentType["ARRAY_BUFFER"] = 10007] = "ARRAY_BUFFER";
+    ArgumentType[ArgumentType["ARRAY"] = 10008] = "ARRAY";
+    ArgumentType[ArgumentType["MOVE_OPTION"] = 10009] = "MOVE_OPTION";
+    ArgumentType[ArgumentType["MOVE_STRING"] = 10010] = "MOVE_STRING";
+    ArgumentType[ArgumentType["MOVE_FIXED_BYTES"] = 10011] = "MOVE_FIXED_BYTES";
+    ArgumentType[ArgumentType["MOVE_VECTOR"] = 10012] = "MOVE_VECTOR";
+    ArgumentType[ArgumentType["V1SDK_ACCOUNT_ADDRESS"] = 10013] = "V1SDK_ACCOUNT_ADDRESS";
+})(ArgumentType || (ArgumentType = {}));
+/**
+ * Variants of script transaction arguments used in Rust, encompassing various data types for transaction processing.
+ * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/transaction_argument.rs#L11}
+ */
+export var ScriptArgumentType;
+(function (ScriptArgumentType) {
+    ScriptArgumentType[ScriptArgumentType["U8"] = 0] = "U8";
+    ScriptArgumentType[ScriptArgumentType["U64"] = 1] = "U64";
+    ScriptArgumentType[ScriptArgumentType["U128"] = 2] = "U128";
+    ScriptArgumentType[ScriptArgumentType["Address"] = 3] = "Address";
+    ScriptArgumentType[ScriptArgumentType["U8Vector"] = 4] = "U8Vector";
+    ScriptArgumentType[ScriptArgumentType["Bool"] = 5] = "Bool";
+    ScriptArgumentType[ScriptArgumentType["U16"] = 6] = "U16";
+    ScriptArgumentType[ScriptArgumentType["U32"] = 7] = "U32";
+    ScriptArgumentType[ScriptArgumentType["U256"] = 8] = "U256";
+    ScriptArgumentType[ScriptArgumentType["Serialized"] = 9] = "Serialized";
+})(ScriptArgumentType || (ScriptArgumentType = {}));
+export function serializeTransactionPayload(args) {
+    const serializer = new Serializer();
+    if (!('type' in args) && 'function' in args && !('multisigAddress' in args)) {
+        // V2 SDK Entry Function Params
+        serializeTransactionPayloadEntryFunction(args, serializer);
+    }
+    else if (!('type' in args) && 'bytecode' in args) {
+        // V2 SDK Script Params
+        serializeTransactionPayloadScript(args, serializer);
+    }
+    else if (!('type' in args) && 'value' in args) {
+        // fix wormhole v1 sdk
+        // not support complex type
+        const value = args.value;
+        if ('code' in value) {
+            serializableTransactionPayloadV1ScriptLegacy(value, serializer);
+        }
+        else {
+            throw new Error('Invalid transaction payload type');
+        }
+    }
+    else if ('type' in args) {
+        // V1 SDK Legacy Params
+        serializableTransactionPayloadV1Legacy(args, serializer);
+    }
+    else {
+        throw new Error('Invalid transaction payload type');
+    }
+    return bytesToHex(serializer.toUint8Array());
+}
+export function deserializeTransactionPayload(hex) {
+    const deserializer = new Deserializer(hexToBytes(hex));
+    const type = deserializer.deserializeUleb128AsU32();
+    if (type === TransactionPayloadType.ENTRY_FUNCTION) {
+        return deserializeTransactionPayloadEntryFunction(deserializer);
+    }
+    else if (type === TransactionPayloadType.SCRIPT) {
+        return deserializeTransactionPayloadScript(deserializer);
+    }
+    else if (type === TransactionPayloadType.ENTRY_FUNCTION_LEGACY) {
+        return deserializableTransactionPayloadV1EntryFunctionLegacy(deserializer);
+    }
+    else if (type === TransactionPayloadType.SCRIPT_LEGACY) {
+        return deserializableTransactionPayloadV1ScriptLegacy(deserializer);
+    }
+    else {
+        throw new Error('Invalid transaction payload type');
+    }
+}
+// https://github.com/aptos-labs/aptos-ts-sdk/blob/289f944ef157a6bd13b1cb0949065ee4330a8c36/src/transactions/instances/transactionPayload.ts#L28-L29
+function deserializeFromScriptArgument(index, deserializer) {
+    switch (index) {
+        case ScriptArgumentType.U8:
+            return U8.deserialize(deserializer);
+        case ScriptArgumentType.U64:
+            return U64.deserialize(deserializer);
+        case ScriptArgumentType.U128:
+            return U128.deserialize(deserializer);
+        case ScriptArgumentType.Address:
+            return AccountAddress.deserialize(deserializer);
+        case ScriptArgumentType.U8Vector:
+            return MoveVector.deserialize(deserializer, U8);
+        case ScriptArgumentType.Bool:
+            return Bool.deserialize(deserializer);
+        case ScriptArgumentType.U16:
+            return U16.deserialize(deserializer);
+        case ScriptArgumentType.U32:
+            return U32.deserialize(deserializer);
+        case ScriptArgumentType.U256:
+            return U256.deserialize(deserializer);
+        case ScriptArgumentType.Serialized:
+            return Serialized.deserialize(deserializer);
+        default:
+            throw new Error(`Unknown script argument type: ${index}`);
+    }
+}
+export function serializeArgument(serializer, arg) {
+    if (arg === null) {
+        serializer.serializeU32AsUleb128(ArgumentType.NULL);
+        return;
+    }
+    if (arg === undefined) {
+        serializer.serializeU32AsUleb128(ArgumentType.UNDEFINED);
+        return;
+    }
+    if (typeof arg === 'boolean') {
+        serializer.serializeU32AsUleb128(ArgumentType.BOOLEAN);
+        serializer.serializeBool(arg);
+        return;
+    }
+    if (typeof arg === 'number') {
+        if (arg > Number.MAX_SAFE_INTEGER) {
+            serializer.serializeU32AsUleb128(ArgumentType.BIGINT);
+            serializer.serializeU256(BigInt(arg));
+        }
+        else {
+            serializer.serializeU32AsUleb128(ArgumentType.NUMBER);
+            serializer.serializeU64(arg);
+        }
+        return;
+    }
+    if (typeof arg === 'bigint') {
+        serializer.serializeU32AsUleb128(ArgumentType.BIGINT);
+        serializer.serializeU256(arg);
+        return;
+    }
+    if (typeof arg === 'string') {
+        serializer.serializeU32AsUleb128(ArgumentType.STRING);
+        serializer.serializeOption(arg);
+        return;
+    }
+    if (arg instanceof Uint8Array) {
+        serializer.serializeU32AsUleb128(ArgumentType.UINT8_ARRAY);
+        serializer.serializeBytes(arg);
+        return;
+    }
+    if (arg instanceof ArrayBuffer) {
+        serializer.serializeU32AsUleb128(ArgumentType.ARRAY_BUFFER);
+        const uint8Array = new Uint8Array(arg);
+        serializer.serializeBytes(uint8Array);
+        return;
+    }
+    if (Array.isArray(arg)) {
+        serializer.serializeU32AsUleb128(ArgumentType.ARRAY);
+        serializer.serializeU32(arg.length);
+        arg.forEach((item) => serializeArgument(serializer, item));
+        return;
+    }
+    if (arg instanceof MoveOption) {
+        serializer.serializeU32AsUleb128(ArgumentType.MOVE_OPTION);
+        serializer.serializeU8(arg.isSome() ? 1 : 0);
+        if (arg.isSome()) {
+            serializeArgument(serializer, arg.value);
+        }
+        return;
+    }
+    if (arg instanceof MoveString) {
+        serializer.serializeU32AsUleb128(ArgumentType.MOVE_STRING);
+        serializer.serializeOption(arg.value);
+        return;
+    }
+    if (arg instanceof FixedBytes) {
+        serializer.serializeU32AsUleb128(ArgumentType.MOVE_FIXED_BYTES);
+        serializer.serializeBytes(arg.value);
+        return;
+    }
+    if (arg instanceof MoveVector) {
+        serializer.serializeU32AsUleb128(ArgumentType.MOVE_VECTOR);
+        serializer.serializeU32(arg.values.length);
+        arg.values.forEach((item) => serializeArgument(serializer, item));
+        return;
+    }
+    try {
+        if ('serializeForScriptFunction' in arg) {
+            // V2 SDK Serializer
+            arg.serializeForScriptFunction(serializer);
+        }
+        else if ('value' in arg) {
+            // fix wormhole v1 sdk
+            // @ts-expect-error
+            const value = arg.value;
+            if (typeof value === 'object' &&
+                value !== null &&
+                'address' in value &&
+                value.address instanceof Uint8Array) {
+                serializer.serializeU32AsUleb128(ArgumentType.V1SDK_ACCOUNT_ADDRESS);
+                serializer.serializeBytes(value.address);
+            }
+            else {
+                serializeArgument(serializer, value);
+            }
+        }
+    }
+    catch (error) {
+        console.log('==>> error ', typeof arg, arg, error);
+    }
+}
+export function deserializeArgument(deserializer) {
+    var _a;
+    const type = deserializer.deserializeUleb128AsU32();
+    switch (type) {
+        case ArgumentType.NULL:
+            return null;
+        case ArgumentType.UNDEFINED:
+            return undefined;
+        case ArgumentType.BOOLEAN:
+            return deserializer.deserializeBool();
+        case ArgumentType.NUMBER: {
+            const value = deserializer.deserializeU64();
+            if (value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+                return Number(value);
+            }
+            return value;
+        }
+        case ArgumentType.BIGINT: {
+            return deserializer.deserializeU256();
+        }
+        case ArgumentType.STRING: {
+            return deserializer.deserializeOption('string');
+        }
+        case ArgumentType.UINT8_ARRAY: {
+            const bytes = deserializer.deserializeBytes();
+            return new Uint8Array(bytes);
+        }
+        case ArgumentType.ARRAY_BUFFER: {
+            const bytes = deserializer.deserializeBytes();
+            return new Uint8Array(bytes).buffer;
+        }
+        case ArgumentType.ARRAY: {
+            const length = deserializer.deserializeU32();
+            const elements = [];
+            for (let i = 0; i < length; i++) {
+                elements.push(deserializeArgument(deserializer));
+            }
+            return elements;
+        }
+        case ArgumentType.MOVE_OPTION: {
+            const isSome = deserializer.deserializeU8() === 1;
+            if (!isSome) {
+                return new MoveOption();
+            }
+            const value = deserializeArgument(deserializer);
+            return new MoveOption(value);
+        }
+        case ArgumentType.MOVE_STRING: {
+            return new MoveString((_a = deserializer.deserializeOption('string')) !== null && _a !== void 0 ? _a : '');
+        }
+        case ArgumentType.MOVE_FIXED_BYTES: {
+            const bytes = deserializer.deserializeBytes();
+            return new FixedBytes(new Uint8Array(bytes));
+        }
+        case ArgumentType.MOVE_VECTOR: {
+            const length = deserializer.deserializeU32();
+            const values = [];
+            for (let i = 0; i < length; i++) {
+                values.push(deserializeArgument(deserializer));
+            }
+            return new MoveVector(values);
+        }
+        case ArgumentType.V1SDK_ACCOUNT_ADDRESS: {
+            return new AccountAddress(deserializer.deserializeBytes());
+        }
+        default: {
+            return deserializeFromScriptArgument(type, deserializer);
+        }
+    }
+}
+export function deserializeArguments(bytes) {
+    const deserializer = new Deserializer(hexToBytes(bytes));
+    const length = deserializer.deserializeU32();
+    const args = [];
+    for (let i = 0; i < length; i++) {
+        args.push(deserializeArgument(deserializer));
+    }
+    return args;
+}
+export function serializeArguments(args) {
+    const serializer = new Serializer();
+    serializer.serializeU32(args.length);
+    args.forEach((arg) => serializeArgument(serializer, arg));
+    return bytesToHex(serializer.toUint8Array());
+}
+function serializeTransactionPayloadScript(args, serializer) {
+    const { bytecode, typeArguments, functionArguments } = args;
+    serializer.serializeU32AsUleb128(TransactionPayloadType.SCRIPT);
+    const bytecodeBytes = typeof bytecode === 'string' ? bytecode : bytesToHex(bytecode);
+    serializer.serializeOption(bytecodeBytes);
+    serializer.serializeVector(standardizeTypeTags(typeArguments));
+    const hex = serializeArguments(functionArguments);
+    serializer.serializeOption(hex !== null && hex !== void 0 ? hex : '');
+}
+function deserializeTransactionPayloadScript(deserializer) {
+    var _a;
+    const bytecode = deserializer.deserializeOption('string');
+    const typeArguments = deserializer.deserializeVector(TypeTag);
+    const args = deserializeArguments((_a = deserializer.deserializeOption('string')) !== null && _a !== void 0 ? _a : '');
+    return {
+        bytecode: bytecode !== null && bytecode !== void 0 ? bytecode : '',
+        typeArguments,
+        functionArguments: args,
+    };
+}
+function serializeTransactionPayloadEntryFunction(args, serializer) {
+    const { function: functionName, typeArguments, functionArguments } = args;
+    serializer.serializeU32AsUleb128(TransactionPayloadType.ENTRY_FUNCTION);
+    serializer.serializeOption(functionName);
+    serializer.serializeVector(standardizeTypeTags(typeArguments));
+    const hex = serializeArguments(functionArguments);
+    serializer.serializeOption(hex !== null && hex !== void 0 ? hex : '');
+}
+function deserializeTransactionPayloadEntryFunction(deserializer) {
+    var _a;
+    const functionName = deserializer.deserializeOption('string');
+    const typeArguments = deserializer.deserializeVector(TypeTag);
+    const functionArguments = deserializeArguments((_a = deserializer.deserializeOption('string')) !== null && _a !== void 0 ? _a : '');
+    return {
+        function: functionName,
+        typeArguments,
+        functionArguments,
+    };
+}
+// V1 SDK Script Wormhole Params
+function serializableTransactionPayloadV1ScriptLegacy(args, serializer) {
+    serializer.serializeU32AsUleb128(TransactionPayloadType.SCRIPT_LEGACY);
+    serializer.serializeBytes(args.code);
+    serializer.serializeVector(args.ty_args);
+    serializer.serializeOption(serializeArguments(args.args));
+}
+function deserializableTransactionPayloadV1ScriptLegacy(deserializer) {
+    var _a;
+    const code = deserializer.deserializeBytes();
+    const ty_args = deserializer.deserializeVector(TypeTag);
+    const args = deserializeArguments((_a = deserializer.deserializeOption('string')) !== null && _a !== void 0 ? _a : '');
+    // @ts-expect-error
+    const convertArgs = args.map((arg) => {
+        if (typeof arg === 'number') {
+            if (arg > Number.MAX_SAFE_INTEGER) {
+                return new U256(arg);
+            }
+            return new U64(arg);
+        }
+        if (typeof arg === 'bigint') {
+            return new U256(arg);
+        }
+        if (typeof arg === 'string') {
+            return new MoveString(arg);
+        }
+        if (arg instanceof Uint8Array) {
+            return MoveVector.U8(arg);
+        }
+        if (arg instanceof ArrayBuffer) {
+            return MoveVector.U8(new Uint8Array(arg));
+        }
+        if (typeof arg === 'boolean') {
+            return new Bool(arg);
+        }
+        if (Array.isArray(arg)) {
+            // @ts-expect-error
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return new MoveVector(arg.map((item) => convertArgs(item)));
+        }
+        return arg;
+    });
+    return {
+        bytecode: code,
+        typeArguments: ty_args,
+        functionArguments: convertArgs,
+    };
+}
+// V1 SDK Legacy Params
+function serializableTransactionPayloadV1Legacy(args, serializer) {
+    if (args.type === 'entry_function_payload') {
+        serializer.serializeU32AsUleb128(TransactionPayloadType.ENTRY_FUNCTION_LEGACY);
+        const { function: functionName, type_arguments, arguments: functionArguments, } = args;
+        serializer.serializeOption(functionName);
+        const length = type_arguments.length;
+        serializer.serializeU32(length);
+        for (let i = 0; i < length; i++) {
+            serializer.serializeOption(type_arguments[i]);
+        }
+        serializer.serializeOption(serializeArguments(functionArguments));
+    }
+    // not exist type script_payload
+}
+function deserializableTransactionPayloadV1EntryFunctionLegacy(deserializer) {
+    var _a, _b, _c;
+    const function_name = (_a = deserializer.deserializeOption('string')) !== null && _a !== void 0 ? _a : '';
+    const length = deserializer.deserializeU32();
+    const typeArguments = [];
+    for (let i = 0; i < length; i++) {
+        typeArguments.push((_b = deserializer.deserializeOption('string')) !== null && _b !== void 0 ? _b : '');
+    }
+    const args = deserializeArguments((_c = deserializer.deserializeOption('string')) !== null && _c !== void 0 ? _c : '');
+    return {
+        // @ts-expect-error
+        function: function_name,
+        typeArguments,
+        functionArguments: args,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/onekey-aptos-provider",
-  "version": "2.2.18",
+  "version": "2.2.19",
   "keywords": [
     "cross-inpage-provider"
   ],
@@ -29,10 +29,10 @@
   },
   "dependencies": {
     "@aptos-labs/wallet-standard": "^0.2.0",
-    "@onekeyfe/cross-inpage-provider-core": "2.2.18",
-    "@onekeyfe/cross-inpage-provider-errors": "2.2.18",
-    "@onekeyfe/cross-inpage-provider-types": "2.2.18",
-    "@onekeyfe/extension-bridge-injected": "2.2.18",
+    "@onekeyfe/cross-inpage-provider-core": "2.2.19",
+    "@onekeyfe/cross-inpage-provider-errors": "2.2.19",
+    "@onekeyfe/cross-inpage-provider-types": "2.2.19",
+    "@onekeyfe/extension-bridge-injected": "2.2.19",
     "@wallet-standard/core": "1.0.3",
     "eth-rpc-errors": "^4.0.3"
   },
@@ -43,5 +43,5 @@
     "@aptos-labs/ts-sdk": "^1.30.0",
     "aptos": "^1.3.17"
   },
-  "gitHead": "1ce046ee55868c9e7cbaa5d22f6cfc5fbed7d1aa"
+  "gitHead": "f655c12ef639067becb3b9fede6000c864949538"
 }