@typus/typus-sdk 1.4.3-d → 1.4.3-f

package/src/_framework/init-source.ts

@@ -0,0 +1,39 @@
+import * as package_1 from "../_dependencies/source/0x1/init";
+import * as package_1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73 from "../_dependencies/source/0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73/init";
+import * as package_2 from "../_dependencies/source/0x2/init";
+import * as package_277f90d256d1015a78cad646db091bec451c5bbab834b9fb70bace7885b5c698 from "../_dependencies/source/0x277f90d256d1015a78cad646db091bec451c5bbab834b9fb70bace7885b5c698/init";
+import * as package_2fdff17b86e34ab722c8ba5e63f0da070d9a4163705b3fdc6a95802cab40a72a from "../_dependencies/source/0x2fdff17b86e34ab722c8ba5e63f0da070d9a4163705b3fdc6a95802cab40a72a/init";
+import * as package_4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277 from "../_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/init";
+import * as package_5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828 from "../_dependencies/source/0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828/init";
+import * as package_6c9a394a43844fc09d9617bc8a8e775a4521f0e28e83de1da780d043a498671f from "../_dependencies/source/0x6c9a394a43844fc09d9617bc8a8e775a4521f0e28e83de1da780d043a498671f/init";
+import * as package_7237ec8436ef7e927c45470db6db3a834dd84cf903aedee3844e847fe4805399 from "../_dependencies/source/0x7237ec8436ef7e927c45470db6db3a834dd84cf903aedee3844e847fe4805399/init";
+import * as package_908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded from "../_dependencies/source/0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded/init";
+import * as package_98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e from "../_dependencies/source/0x98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e/init";
+import * as package_bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585 from "../_dependencies/source/0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585/init";
+import * as package_cc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e from "../_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/init";
+import * as package_e76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3 from "../_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/init";
+import * as package_4c83d54c5b4fa3096550131d62cc28f01594a88e3a7ed2acb3fda8888ec653df from "../typus-perp/init";
+import { structClassLoaderSource as structClassLoader } from "./loader";
+
+let initialized = false;
+export function initLoaderIfNeeded() {
+    if (initialized) {
+        return;
+    }
+    initialized = true;
+    package_1.registerClasses(structClassLoader);
+    package_2.registerClasses(structClassLoader);
+    package_1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73.registerClasses(structClassLoader);
+    package_277f90d256d1015a78cad646db091bec451c5bbab834b9fb70bace7885b5c698.registerClasses(structClassLoader);
+    package_2fdff17b86e34ab722c8ba5e63f0da070d9a4163705b3fdc6a95802cab40a72a.registerClasses(structClassLoader);
+    package_4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277.registerClasses(structClassLoader);
+    package_4c83d54c5b4fa3096550131d62cc28f01594a88e3a7ed2acb3fda8888ec653df.registerClasses(structClassLoader);
+    package_5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828.registerClasses(structClassLoader);
+    package_6c9a394a43844fc09d9617bc8a8e775a4521f0e28e83de1da780d043a498671f.registerClasses(structClassLoader);
+    package_7237ec8436ef7e927c45470db6db3a834dd84cf903aedee3844e847fe4805399.registerClasses(structClassLoader);
+    package_908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded.registerClasses(structClassLoader);
+    package_98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e.registerClasses(structClassLoader);
+    package_bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585.registerClasses(structClassLoader);
+    package_cc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e.registerClasses(structClassLoader);
+    package_e76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3.registerClasses(structClassLoader);
+}

package/src/_framework/loader.ts

@@ -0,0 +1,69 @@
+import { compressSuiType, parseTypeName } from "./util";
+import {
+    PhantomReified,
+    PhantomTypeArgument,
+    Primitive,
+    Reified,
+    StructClass,
+    StructClassReified,
+    TypeArgument,
+    VectorClass,
+    VectorClassReified,
+    vector,
+} from "./reified";
+
+export type PrimitiveValue = string | number | boolean | bigint;
+
+interface _StructClass {
+    $typeName: string;
+    $numTypeParams: number;
+    reified(...Ts: Array<Reified<TypeArgument, any> | PhantomReified<PhantomTypeArgument>>): StructClassReified<StructClass, any>;
+}
+
+export class StructClassLoader {
+    private map: Map<string, _StructClass> = new Map();
+
+    register(...classes: _StructClass[]) {
+        for (const cls of classes) {
+            this.map.set(cls.$typeName, cls);
+        }
+    }
+
+    reified<T extends Primitive>(type: T): T;
+    reified(type: `vector<${string}>`): VectorClassReified<VectorClass>;
+    reified(type: string): StructClassReified<StructClass, any>;
+    reified(type: string): StructClassReified<StructClass, any> | VectorClassReified<VectorClass> | string {
+        const { typeName, typeArgs } = parseTypeName(compressSuiType(type));
+        switch (typeName) {
+            case "bool":
+            case "u8":
+            case "u16":
+            case "u32":
+            case "u64":
+            case "u128":
+            case "u256":
+            case "address":
+                return typeName;
+            case "vector": {
+                if (typeArgs.length !== 1) {
+                    throw new Error(`Vector expects 1 type argument, but got ${typeArgs.length}`);
+                }
+                return vector(this.reified(typeArgs[0]));
+            }
+        }
+
+        if (!this.map.has(typeName)) {
+            throw new Error(`Unknown type ${typeName}`);
+        }
+
+        const cls = this.map.get(typeName)!;
+        if (cls.$numTypeParams !== typeArgs.length) {
+            throw new Error(`Type ${typeName} expects ${cls.$numTypeParams} type arguments, but got ${typeArgs.length}`);
+        }
+
+        return cls.reified(...typeArgs.map((t) => this.reified(t)));
+    }
+}
+
+export const structClassLoaderSource = new StructClassLoader();
+export const structClassLoaderOnchain = new StructClassLoader();

package/src/_framework/reified.ts

@@ -0,0 +1,442 @@
+import { BcsType, bcs, fromHEX, toHEX } from "@mysten/bcs";
+import { FieldsWithTypes, compressSuiType, parseTypeName } from "./util";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+
+export interface StructClass {
+    $typeName: string;
+    $fullTypeName: string;
+    $typeArgs: string[];
+    toJSONField(): Record<string, any>;
+    toJSON(): Record<string, any>;
+}
+
+export interface VectorClass {
+    $fullTypeName: string;
+    toJSONField(): any[];
+
+    readonly vec: any;
+
+    readonly kind: "VectorClass";
+}
+
+export class Vector<T extends TypeArgument> implements VectorClass {
+    readonly $fullTypeName: `vector<${ToTypeStr<T>}>`;
+
+    readonly vec: Array<ToField<T>>;
+    constructor(fullTypeName: string, vec: Array<ToField<T>>) {
+        this.$fullTypeName = fullTypeName as `vector<${ToTypeStr<T>}>`;
+        this.vec = vec;
+    }
+
+    toJSONField(): Array<ToJSON<T>> {
+        return null as any;
+    }
+
+    readonly kind = "VectorClass";
+}
+
+export type Primitive = "bool" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "address";
+export type TypeArgument = StructClass | Primitive | VectorClass;
+
+export interface StructClassReified<T extends StructClass, Fields> {
+    typeName: T["$typeName"]; // e.g., '0x2::balance::Balance', without type arguments
+    fullTypeName: ToTypeStr<T>; // e.g., '0x2::balance::Balance<0x2::sui:SUI>'
+    typeArgs: T["$typeArgs"]; // e.g., ['0x2::sui:SUI']
+    reifiedTypeArgs: Array<Reified<TypeArgument, any> | PhantomReified<PhantomTypeArgument>>;
+    bcs: BcsType<any>;
+    fromFields(fields: Record<string, any>): T;
+    fromFieldsWithTypes(item: FieldsWithTypes): T;
+    fromBcs(data: Uint8Array): T;
+    fromJSONField: (field: any) => T;
+    fromJSON: (json: Record<string, any>) => T;
+    fromSuiParsedData: (content: SuiParsedData) => T;
+    fetch: (client: SuiClient, id: string) => Promise<T>;
+    new: (fields: Fields) => T;
+    kind: "StructClassReified";
+}
+
+export interface VectorClassReified<T extends VectorClass> {
+    fullTypeName: ToTypeStr<T>;
+    bcs: BcsType<any>;
+    fromFields(fields: any[]): T;
+    fromFieldsWithTypes(item: FieldsWithTypes): T;
+    fromJSONField: (field: any) => T;
+    kind: "VectorClassReified";
+}
+
+export type Reified<T extends TypeArgument, Fields> = T extends Primitive
+    ? Primitive
+    : T extends StructClass
+      ? StructClassReified<T, Fields>
+      : T extends VectorClass
+        ? VectorClassReified<T>
+        : never;
+
+export type ToTypeArgument<T extends Primitive | StructClassReified<StructClass, any> | VectorClassReified<VectorClass>> =
+    T extends Primitive ? T : T extends StructClassReified<infer U, any> ? U : T extends VectorClassReified<infer U> ? U : never;
+
+export type ToPhantomTypeArgument<T extends PhantomReified<PhantomTypeArgument>> = T extends PhantomReified<infer U> ? U : never;
+
+export type PhantomTypeArgument = string;
+
+export interface PhantomReified<P> {
+    phantomType: P;
+    kind: "PhantomReified";
+}
+
+export function phantom<T extends Reified<TypeArgument, any>>(reified: T): PhantomReified<ToTypeStr<ToTypeArgument<T>>>;
+export function phantom<P extends PhantomTypeArgument>(phantomType: P): PhantomReified<P>;
+export function phantom(type: string | Reified<TypeArgument, any>): PhantomReified<string> {
+    if (typeof type === "string") {
+        return {
+            phantomType: type,
+            kind: "PhantomReified",
+        };
+    } else {
+        return {
+            phantomType: type.fullTypeName,
+            kind: "PhantomReified",
+        };
+    }
+}
+
+export type ToTypeStr<T extends TypeArgument> = T extends Primitive
+    ? T
+    : T extends StructClass
+      ? T["$fullTypeName"]
+      : T extends VectorClass
+        ? T["$fullTypeName"]
+        : never;
+
+export type PhantomToTypeStr<T extends PhantomTypeArgument> = T extends PhantomTypeArgument ? T : never;
+
+export function vector<T extends Reified<TypeArgument, any>>(T: T): VectorClassReified<Vector<ToTypeArgument<T>>> {
+    const fullTypeName = `vector<${extractType(T)}>` as `vector<${ToTypeStr<ToTypeArgument<T>>}>`;
+
+    return {
+        fullTypeName,
+        bcs: bcs.vector(toBcs(T)),
+        fromFieldsWithTypes: (item: FieldsWithTypes) => {
+            return new Vector(
+                fullTypeName,
+                (item as unknown as any[]).map((field: any) => decodeFromFieldsWithTypes(T, field))
+            );
+        },
+        fromFields: (fields: any[]) => {
+            return new Vector(
+                fullTypeName,
+                fields.map((field) => decodeFromFields(T, field))
+            );
+        },
+
+        fromJSONField: (field: any) =>
+            new Vector(
+                fullTypeName,
+                field.map((field: any) => decodeFromJSONField(T, field))
+            ),
+        kind: "VectorClassReified",
+    };
+}
+
+export type ToJSON<T extends TypeArgument> = T extends "bool"
+    ? boolean
+    : T extends "u8"
+      ? number
+      : T extends "u16"
+        ? number
+        : T extends "u32"
+          ? number
+          : T extends "u64"
+            ? string
+            : T extends "u128"
+              ? string
+              : T extends "u256"
+                ? string
+                : T extends "address"
+                  ? string
+                  : T extends { $typeName: "0x1::string::String" }
+                    ? string
+                    : T extends { $typeName: "0x1::ascii::String" }
+                      ? string
+                      : T extends { $typeName: "0x2::object::UID" }
+                        ? string
+                        : T extends { $typeName: "0x2::object::ID" }
+                          ? string
+                          : T extends { $typeName: "0x2::url::Url" }
+                            ? string
+                            : T extends {
+                                    $typeName: "0x1::option::Option";
+                                    __inner: infer U extends TypeArgument;
+                                }
+                              ? ToJSON<U> | null
+                              : T extends VectorClass
+                                ? ReturnType<T["toJSONField"]>
+                                : T extends StructClass
+                                  ? ReturnType<T["toJSONField"]>
+                                  : never;
+
+export type ToField<T extends TypeArgument> = T extends "bool"
+    ? boolean
+    : T extends "u8"
+      ? number
+      : T extends "u16"
+        ? number
+        : T extends "u32"
+          ? number
+          : T extends "u64"
+            ? bigint
+            : T extends "u128"
+              ? bigint
+              : T extends "u256"
+                ? bigint
+                : T extends "address"
+                  ? string
+                  : T extends { $typeName: "0x1::string::String" }
+                    ? string
+                    : T extends { $typeName: "0x1::ascii::String" }
+                      ? string
+                      : T extends { $typeName: "0x2::object::UID" }
+                        ? string
+                        : T extends { $typeName: "0x2::object::ID" }
+                          ? string
+                          : T extends { $typeName: "0x2::url::Url" }
+                            ? string
+                            : T extends {
+                                    $typeName: "0x1::option::Option";
+                                    __inner: infer U extends TypeArgument;
+                                }
+                              ? ToField<U> | null
+                              : T extends VectorClass
+                                ? T["vec"]
+                                : T extends StructClass
+                                  ? T
+                                  : never;
+
+const Address = bcs.bytes(32).transform({
+    input: (val: string) => fromHEX(val),
+    output: (val) => toHEX(val),
+});
+
+export function toBcs<T extends Reified<TypeArgument, any>>(arg: T): BcsType<any> {
+    switch (arg) {
+        case "bool":
+            return bcs.bool();
+        case "u8":
+            return bcs.u8();
+        case "u16":
+            return bcs.u16();
+        case "u32":
+            return bcs.u32();
+        case "u64":
+            return bcs.u64();
+        case "u128":
+            return bcs.u128();
+        case "u256":
+            return bcs.u256();
+        case "address":
+            return Address;
+        default:
+            return arg.bcs;
+    }
+}
+
+export function extractType<T extends Reified<TypeArgument, any>>(reified: T): ToTypeStr<ToTypeArgument<T>>;
+export function extractType<T extends PhantomReified<PhantomTypeArgument>>(reified: T): PhantomToTypeStr<ToPhantomTypeArgument<T>>;
+export function extractType<T extends Reified<TypeArgument, any> | PhantomReified<PhantomTypeArgument>>(reified: T): string;
+export function extractType(reified: Reified<TypeArgument, any> | PhantomReified<string>): string {
+    switch (reified) {
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "bool":
+        case "address":
+            return reified;
+    }
+    switch (reified.kind) {
+        case "PhantomReified":
+            return reified.phantomType;
+        case "StructClassReified":
+            return reified.fullTypeName;
+        case "VectorClassReified":
+            return reified.fullTypeName;
+    }
+
+    throw new Error("unreachable");
+}
+
+export function decodeFromFields(reified: Reified<TypeArgument, any>, field: any) {
+    switch (reified) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+            return field;
+        case "u64":
+        case "u128":
+        case "u256":
+            return BigInt(field);
+        case "address":
+            return `0x${field}`;
+    }
+    if (reified.kind === "VectorClassReified") {
+        return reified.fromFields(field).vec;
+    }
+    switch (reified.typeName) {
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+            return new TextDecoder().decode(Uint8Array.from(field.bytes)).toString();
+        case "0x2::url::Url":
+            return new TextDecoder().decode(Uint8Array.from(field.url.bytes)).toString();
+        case "0x2::object::ID":
+            return `0x${field.bytes}`;
+        case "0x2::object::UID":
+            return `0x${field.id.bytes}`;
+        case "0x1::option::Option": {
+            if (field.vec.length === 0) {
+                return null;
+            }
+            return (reified.fromFields(field) as any).vec[0];
+        }
+        default:
+            return reified.fromFields(field);
+    }
+}
+
+export function decodeFromFieldsWithTypes(reified: Reified<TypeArgument, any>, item: any) {
+    switch (reified) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+            return item;
+        case "u64":
+        case "u128":
+        case "u256":
+            return BigInt(item);
+        case "address":
+            return item;
+    }
+    if (reified.kind === "VectorClassReified") {
+        return reified.fromFieldsWithTypes(item).vec;
+    }
+    switch (reified.typeName) {
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::url::Url":
+        case "0x2::object::ID":
+            return item;
+        case "0x2::object::UID":
+            return item.id;
+        case "0x2::balance::Balance":
+            return reified.fromFields({ value: BigInt(item) });
+        case "0x1::option::Option": {
+            if (item === null) {
+                return null;
+            }
+            return decodeFromFieldsWithTypes((reified as any).reifiedTypeArgs[0], item);
+        }
+        default:
+            return reified.fromFieldsWithTypes(item);
+    }
+}
+
+export function assertReifiedTypeArgsMatch(
+    fullType: string,
+    typeArgs: string[],
+    reifiedTypeArgs: Array<Reified<TypeArgument, any> | PhantomReified<string>>
+) {
+    if (reifiedTypeArgs.length !== typeArgs.length) {
+        throw new Error(
+            `provided item has mismatching number of type argments ${fullType} (expected ${reifiedTypeArgs.length}, got ${typeArgs.length}))`
+        );
+    }
+    for (let i = 0; i < typeArgs.length; i++) {
+        if (compressSuiType(typeArgs[i]) !== compressSuiType(extractType(reifiedTypeArgs[i]))) {
+            throw new Error(
+                `provided item has mismatching type argments ${fullType} (expected ${extractType(reifiedTypeArgs[i])}, got ${typeArgs[i]}))`
+            );
+        }
+    }
+}
+
+export function assertFieldsWithTypesArgsMatch(
+    item: FieldsWithTypes,
+    reifiedTypeArgs: Array<Reified<TypeArgument, any> | PhantomReified<string>>
+) {
+    const { typeArgs: itemTypeArgs } = parseTypeName(item.type);
+    assertReifiedTypeArgsMatch(item.type, itemTypeArgs, reifiedTypeArgs);
+}
+
+export function fieldToJSON<T extends TypeArgument>(type: string, field: ToField<T>): ToJSON<T> {
+    const { typeName, typeArgs } = parseTypeName(type);
+    switch (typeName) {
+        case "bool":
+            return field as any;
+        case "u8":
+        case "u16":
+        case "u32":
+            return field as any;
+        case "u64":
+        case "u128":
+        case "u256":
+            return field.toString() as any;
+        case "address":
+        case "signer":
+            return field as any;
+        case "vector":
+            return (field as any[]).map((item: any) => fieldToJSON(typeArgs[0], item)) as any;
+        // handle special types
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::url::Url":
+        case "0x2::object::ID":
+        case "0x2::object::UID":
+            return field as any;
+        case "0x1::option::Option": {
+            if (field === null) {
+                return null as any;
+            }
+            return fieldToJSON(typeArgs[0], field);
+        }
+        default:
+            return (field as any).toJSONField();
+    }
+}
+
+export function decodeFromJSONField(typeArg: Reified<TypeArgument, any>, field: any) {
+    switch (typeArg) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+            return field;
+        case "u64":
+        case "u128":
+        case "u256":
+            return BigInt(field);
+        case "address":
+            return field;
+    }
+    if (typeArg.kind === "VectorClassReified") {
+        return typeArg.fromJSONField(field).vec;
+    }
+    switch (typeArg.typeName) {
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::url::Url":
+        case "0x2::object::ID":
+        case "0x2::object::UID":
+            return field;
+        case "0x1::option::Option": {
+            if (field === null) {
+                return null;
+            }
+            return decodeFromJSONField(typeArg.reifiedTypeArgs[0] as any, field);
+        }
+        default:
+            return typeArg.fromJSONField(field);
+    }
+}