@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/utils/index.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveTuple = exports.MoveEnum = exports.MoveStruct = void 0;
+exports.getPureBcsSchema = getPureBcsSchema;
+exports.normalizeMoveArguments = normalizeMoveArguments;
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+const transactions_1 = require("@mysten/sui/transactions");
+const MOVE_STDLIB_ADDRESS = (0, utils_1.normalizeSuiAddress)('0x1');
+const SUI_FRAMEWORK_ADDRESS = (0, utils_1.normalizeSuiAddress)('0x2');
+function getPureBcsSchema(typeTag) {
+    const parsedTag = typeof typeTag === 'string' ? bcs_1.TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+    if ('u8' in parsedTag) {
+        return bcs_1.bcs.U8;
+    }
+    else if ('u16' in parsedTag) {
+        return bcs_1.bcs.U16;
+    }
+    else if ('u32' in parsedTag) {
+        return bcs_1.bcs.U32;
+    }
+    else if ('u64' in parsedTag) {
+        return bcs_1.bcs.U64;
+    }
+    else if ('u128' in parsedTag) {
+        return bcs_1.bcs.U128;
+    }
+    else if ('u256' in parsedTag) {
+        return bcs_1.bcs.U256;
+    }
+    else if ('address' in parsedTag) {
+        return bcs_1.bcs.Address;
+    }
+    else if ('bool' in parsedTag) {
+        return bcs_1.bcs.Bool;
+    }
+    else if ('vector' in parsedTag) {
+        const type = getPureBcsSchema(parsedTag.vector);
+        return type ? bcs_1.bcs.vector(type) : null;
+    }
+    else if ('struct' in parsedTag) {
+        const structTag = parsedTag.struct;
+        const pkg = (0, utils_1.normalizeSuiAddress)(structTag.address);
+        if (pkg === MOVE_STDLIB_ADDRESS) {
+            if ((structTag.module === 'ascii' || structTag.module === 'string') &&
+                structTag.name === 'String') {
+                return bcs_1.bcs.String;
+            }
+            if (structTag.module === 'option' && structTag.name === 'Option') {
+                const inner = structTag.typeParams[0];
+                const type = inner ? getPureBcsSchema(inner) : null;
+                return type ? bcs_1.bcs.option(type) : null;
+            }
+        }
+        if (pkg === SUI_FRAMEWORK_ADDRESS &&
+            structTag.module === 'object' &&
+            (structTag.name === 'ID' || structTag.name === 'UID')) {
+            return bcs_1.bcs.Address;
+        }
+    }
+    return null;
+}
+function normalizeMoveArguments(args, argTypes, parameterNames) {
+    const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+    if (parameterNames && argLen !== parameterNames.length) {
+        throw new Error(`Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`);
+    }
+    const normalizedArgs = [];
+    let index = 0;
+    for (const argType of argTypes) {
+        if (argType === '0x2::clock::Clock') {
+            normalizedArgs.push((tx) => tx.object.clock());
+            continue;
+        }
+        if (argType === '0x2::random::Random') {
+            normalizedArgs.push((tx) => tx.object.random());
+            continue;
+        }
+        if (argType === '0x2::deny_list::DenyList') {
+            normalizedArgs.push((tx) => tx.object.denyList());
+            continue;
+        }
+        if (argType === '0x3::sui_system::SuiSystemState') {
+            normalizedArgs.push((tx) => tx.object.system());
+            continue;
+        }
+        let arg;
+        if (Array.isArray(args)) {
+            if (index >= args.length) {
+                throw new Error(`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`);
+            }
+            arg = args[index];
+        }
+        else {
+            if (!parameterNames) {
+                throw new Error(`Expected arguments to be passed as an array`);
+            }
+            const name = parameterNames[index];
+            arg = args[name];
+            if (arg === undefined) {
+                throw new Error(`Parameter ${name} is required`);
+            }
+        }
+        index += 1;
+        if (typeof arg === 'function' || (0, transactions_1.isArgument)(arg)) {
+            normalizedArgs.push(arg);
+            continue;
+        }
+        const bcsType = argType === null ? null : getPureBcsSchema(argType);
+        if (bcsType) {
+            const bytes = bcsType.serialize(arg);
+            normalizedArgs.push((tx) => tx.pure(bytes));
+            continue;
+        }
+        if (typeof arg === 'string') {
+            normalizedArgs.push((tx) => tx.object(arg));
+            continue;
+        }
+        throw new Error(`Invalid argument ${stringify(arg)} for type ${argType}`);
+    }
+    return normalizedArgs;
+}
+class MoveStruct extends bcs_1.BcsStruct {
+    async get({ objectId, ...options }) {
+        const [res] = await this.getMany({
+            ...options,
+            objectIds: [objectId],
+        });
+        if (!res) {
+            throw new Error(`No object found for id ${objectId}`);
+        }
+        return res;
+    }
+    async getMany({ client, ...options }) {
+        const response = (await client.core.getObjects({
+            ...options,
+            include: {
+                ...options.include,
+                content: true,
+            },
+        }));
+        return response.objects.map((obj) => {
+            if (obj instanceof Error) {
+                throw obj;
+            }
+            return {
+                ...obj,
+                json: this.parse(obj.content),
+            };
+        });
+    }
+}
+exports.MoveStruct = MoveStruct;
+class MoveEnum extends bcs_1.BcsEnum {
+}
+exports.MoveEnum = MoveEnum;
+class MoveTuple extends bcs_1.BcsTuple {
+}
+exports.MoveTuple = MoveTuple;
+function stringify(val) {
+    if (typeof val === 'object') {
+        return JSON.stringify(val, (val) => val);
+    }
+    if (typeof val === 'bigint') {
+        return val.toString();
+    }
+    return val;
+}