@waterx/sdk 2.4.1 → 3.0.1

package/dist/src/prediction/generated/utils/index.d.ts

@@ -1,30 +0,0 @@
-import { type BcsType, type TypeTag, BcsStruct, BcsEnum, BcsTuple } from '@mysten/sui/bcs';
-import { type TransactionArgument } from '@mysten/sui/transactions';
-import { type ClientWithCoreApi, type SuiClientTypes } from '@mysten/sui/client';
-export type RawTransactionArgument<T> = T | TransactionArgument;
-export type GetOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> = SuiClientTypes.GetObjectOptions<Include> & {
-    client: ClientWithCoreApi;
-};
-export type GetManyOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> = SuiClientTypes.GetObjectsOptions<Include> & {
-    client: ClientWithCoreApi;
-};
-export declare function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null;
-export declare function normalizeMoveArguments(args: unknown[] | object, argTypes: readonly (string | null)[], parameterNames?: string[]): TransactionArgument[];
-export declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
-    get<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ objectId, ...options }: GetOptions<Include>): Promise<SuiClientTypes.Object<Include & {
-        content: true;
-        json: true;
-    }> & {
-        json: BcsStruct<T>['$inferType'];
-    }>;
-    getMany<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ client, ...options }: GetManyOptions<Include>): Promise<Array<SuiClientTypes.Object<Include & {
-        content: true;
-        json: true;
-    }> & {
-        json: BcsStruct<T>['$inferType'];
-    }>>;
-}
-export declare class MoveEnum<T extends Record<string, BcsType<any> | null>, const Name extends string> extends BcsEnum<T, Name> {
-}
-export declare class MoveTuple<const T extends readonly BcsType<any>[], const Name extends string> extends BcsTuple<T, Name> {
-}

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

@@ -1,160 +0,0 @@
-import { bcs, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple, } from '@mysten/sui/bcs';
-import { normalizeSuiAddress } from '@mysten/sui/utils';
-import { isArgument } from '@mysten/sui/transactions';
-const MOVE_STDLIB_ADDRESS = normalizeSuiAddress('0x1');
-const SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress('0x2');
-export function getPureBcsSchema(typeTag) {
-    const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
-    if ('u8' in parsedTag) {
-        return bcs.U8;
-    }
-    else if ('u16' in parsedTag) {
-        return bcs.U16;
-    }
-    else if ('u32' in parsedTag) {
-        return bcs.U32;
-    }
-    else if ('u64' in parsedTag) {
-        return bcs.U64;
-    }
-    else if ('u128' in parsedTag) {
-        return bcs.U128;
-    }
-    else if ('u256' in parsedTag) {
-        return bcs.U256;
-    }
-    else if ('address' in parsedTag) {
-        return bcs.Address;
-    }
-    else if ('bool' in parsedTag) {
-        return bcs.Bool;
-    }
-    else if ('vector' in parsedTag) {
-        const type = getPureBcsSchema(parsedTag.vector);
-        return type ? bcs.vector(type) : null;
-    }
-    else if ('struct' in parsedTag) {
-        const structTag = parsedTag.struct;
-        const pkg = normalizeSuiAddress(structTag.address);
-        if (pkg === MOVE_STDLIB_ADDRESS) {
-            if ((structTag.module === 'ascii' || structTag.module === 'string') &&
-                structTag.name === 'String') {
-                return bcs.String;
-            }
-            if (structTag.module === 'option' && structTag.name === 'Option') {
-                const inner = structTag.typeParams[0];
-                const type = inner ? getPureBcsSchema(inner) : null;
-                return type ? bcs.option(type) : null;
-            }
-        }
-        if (pkg === SUI_FRAMEWORK_ADDRESS &&
-            structTag.module === 'object' &&
-            (structTag.name === 'ID' || structTag.name === 'UID')) {
-            return bcs.Address;
-        }
-    }
-    return null;
-}
-export 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' || 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;
-}
-export class MoveStruct extends 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),
-            };
-        });
-    }
-}
-export class MoveEnum extends BcsEnum {
-}
-export class MoveTuple extends BcsTuple {
-}
-function stringify(val) {
-    if (typeof val === 'object') {
-        return JSON.stringify(val, (val) => val);
-    }
-    if (typeof val === 'bigint') {
-        return val.toString();
-    }
-    return val;
-}