@typus/typus-perp-sdk 1.0.0

package/dist/src/_framework/reified.d.ts

@@ -0,0 +1,108 @@
+import { BcsType } from "@mysten/sui/bcs";
+import { FieldsWithTypes } from "./util";
+import { SuiClient, SuiParsedData, SuiObjectData } from "@mysten/sui/client";
+export { vector } from "./vector";
+export interface StructClass {
+    readonly $typeName: string;
+    readonly $fullTypeName: string;
+    readonly $typeArgs: string[];
+    readonly $isPhantom: readonly boolean[];
+    toJSONField(): Record<string, any>;
+    toJSON(): Record<string, any>;
+    __StructClass: true;
+}
+export interface VectorClass {
+    readonly $typeName: "vector";
+    readonly $fullTypeName: string;
+    readonly $typeArgs: [string];
+    readonly $isPhantom: readonly [false];
+    toJSONField(): any[];
+    toJSON(): Record<string, any>;
+    readonly elements: any;
+    __VectorClass: true;
+}
+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"];
+    fullTypeName: ToTypeStr<T>;
+    typeArgs: T["$typeArgs"];
+    isPhantom: T["$isPhantom"];
+    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;
+    fromSuiObjectData: (data: SuiObjectData) => T;
+    fetch: (client: SuiClient, id: string) => Promise<T>;
+    new: (fields: Fields) => T;
+    kind: "StructClassReified";
+}
+export interface VectorClassReified<T extends VectorClass, Elements> {
+    typeName: T["$typeName"];
+    fullTypeName: ToTypeStr<T>;
+    typeArgs: T["$typeArgs"];
+    isPhantom: readonly [false];
+    reifiedTypeArgs: Array<Reified<TypeArgument, any>>;
+    bcs: BcsType<any>;
+    fromFields(fields: any[]): T;
+    fromFieldsWithTypes(item: FieldsWithTypes): T;
+    fromBcs(data: Uint8Array): T;
+    fromJSONField: (field: any) => T;
+    fromJSON: (json: Record<string, any>) => T;
+    new: (elements: Elements) => 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, Fields> : never;
+export type ToTypeArgument<T extends Primitive | StructClassReified<StructClass, any> | VectorClassReified<VectorClass, any>> = T extends Primitive ? T : T extends StructClassReified<infer U, any> ? U : T extends VectorClassReified<infer U, any> ? 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 declare function phantom<T extends Reified<TypeArgument, any>>(reified: T): PhantomReified<ToTypeStr<ToTypeArgument<T>>>;
+export declare function phantom<P extends PhantomTypeArgument>(phantomType: P): PhantomReified<P>;
+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 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["elements"] : T extends StructClass ? T : never;
+export declare function toBcs<T extends Reified<TypeArgument, any>>(arg: T): BcsType<any>;
+export declare function extractType<T extends Reified<TypeArgument, any>>(reified: T): ToTypeStr<ToTypeArgument<T>>;
+export declare function extractType<T extends PhantomReified<PhantomTypeArgument>>(reified: T): PhantomToTypeStr<ToPhantomTypeArgument<T>>;
+export declare function extractType<T extends Reified<TypeArgument, any> | PhantomReified<PhantomTypeArgument>>(reified: T): string;
+export declare function decodeFromFields(reified: Reified<TypeArgument, any>, field: any): any;
+export declare function decodeFromFieldsWithTypes(reified: Reified<TypeArgument, any>, item: any): any;
+export declare function assertReifiedTypeArgsMatch(fullType: string, typeArgs: string[], reifiedTypeArgs: Array<Reified<TypeArgument, any> | PhantomReified<string>>): void;
+export declare function assertFieldsWithTypesArgsMatch(item: FieldsWithTypes, reifiedTypeArgs: Array<Reified<TypeArgument, any> | PhantomReified<string>>): void;
+export declare function fieldToJSON<T extends TypeArgument>(type: string, field: ToField<T>): ToJSON<T>;
+export declare function decodeFromJSONField(typeArg: Reified<TypeArgument, any>, field: any): any;

package/dist/src/_framework/reified.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vector = void 0;
+exports.phantom = phantom;
+exports.toBcs = toBcs;
+exports.extractType = extractType;
+exports.decodeFromFields = decodeFromFields;
+exports.decodeFromFieldsWithTypes = decodeFromFieldsWithTypes;
+exports.assertReifiedTypeArgsMatch = assertReifiedTypeArgsMatch;
+exports.assertFieldsWithTypesArgsMatch = assertFieldsWithTypesArgsMatch;
+exports.fieldToJSON = fieldToJSON;
+exports.decodeFromJSONField = decodeFromJSONField;
+var bcs_1 = require("@mysten/sui/bcs");
+var utils_1 = require("@mysten/sui/utils");
+var util_1 = require("./util");
+// for backwards compatibility
+var vector_1 = require("./vector");
+Object.defineProperty(exports, "vector", { enumerable: true, get: function () { return vector_1.vector; } });
+function phantom(type) {
+    if (typeof type === "string") {
+        return {
+            phantomType: type,
+            kind: "PhantomReified",
+        };
+    }
+    else {
+        return {
+            phantomType: type.fullTypeName,
+            kind: "PhantomReified",
+        };
+    }
+}
+var Address = bcs_1.bcs.bytes(32).transform({
+    input: function (val) { return (0, utils_1.fromHEX)(val); },
+    output: function (val) { return (0, utils_1.toHEX)(val); },
+});
+function toBcs(arg) {
+    switch (arg) {
+        case "bool":
+            return bcs_1.bcs.bool();
+        case "u8":
+            return bcs_1.bcs.u8();
+        case "u16":
+            return bcs_1.bcs.u16();
+        case "u32":
+            return bcs_1.bcs.u32();
+        case "u64":
+            return bcs_1.bcs.u64();
+        case "u128":
+            return bcs_1.bcs.u128();
+        case "u256":
+            return bcs_1.bcs.u256();
+        case "address":
+            return Address;
+        default:
+            return arg.bcs;
+    }
+}
+function extractType(reified) {
+    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");
+}
+function decodeFromFields(reified, field) {
+    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".concat(field);
+    }
+    if (reified.kind === "VectorClassReified") {
+        return reified.fromFields(field).elements;
+    }
+    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".concat(field.bytes);
+        case "0x2::object::UID":
+            return "0x".concat(field.id.bytes);
+        case "0x1::option::Option": {
+            if (field.vec.length === 0) {
+                return null;
+            }
+            return reified.fromFields(field).vec[0];
+        }
+        default:
+            return reified.fromFields(field);
+    }
+}
+function decodeFromFieldsWithTypes(reified, item) {
+    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).elements;
+    }
+    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.reifiedTypeArgs[0], item);
+        }
+        default:
+            return reified.fromFieldsWithTypes(item);
+    }
+}
+function assertReifiedTypeArgsMatch(fullType, typeArgs, reifiedTypeArgs) {
+    if (reifiedTypeArgs.length !== typeArgs.length) {
+        throw new Error("provided item has mismatching number of type argments ".concat(fullType, " (expected ").concat(reifiedTypeArgs.length, ", got ").concat(typeArgs.length, "))"));
+    }
+    for (var i = 0; i < typeArgs.length; i++) {
+        if ((0, util_1.compressSuiType)(typeArgs[i]) !== (0, util_1.compressSuiType)(extractType(reifiedTypeArgs[i]))) {
+            throw new Error("provided item has mismatching type argments ".concat(fullType, " (expected ").concat(extractType(reifiedTypeArgs[i]), ", got ").concat(typeArgs[i], "))"));
+        }
+    }
+}
+function assertFieldsWithTypesArgsMatch(item, reifiedTypeArgs) {
+    var itemTypeArgs = (0, util_1.parseTypeName)(item.type).typeArgs;
+    assertReifiedTypeArgsMatch(item.type, itemTypeArgs, reifiedTypeArgs);
+}
+function fieldToJSON(type, field) {
+    var _a = (0, util_1.parseTypeName)(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+    switch (typeName) {
+        case "bool":
+            return field;
+        case "u8":
+        case "u16":
+        case "u32":
+            return field;
+        case "u64":
+        case "u128":
+        case "u256":
+            return field.toString();
+        case "address":
+        case "signer":
+            return field;
+        case "vector":
+            return field.map(function (item) { return fieldToJSON(typeArgs[0], item); });
+        // 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;
+        case "0x1::option::Option": {
+            if (field === null) {
+                return null;
+            }
+            return fieldToJSON(typeArgs[0], field);
+        }
+        default:
+            return field.toJSONField();
+    }
+}
+function decodeFromJSONField(typeArg, field) {
+    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).elements;
+    }
+    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], field);
+        }
+        default:
+            return typeArg.fromJSONField(field);
+    }
+}

package/dist/src/_framework/util.d.ts

@@ -0,0 +1,35 @@
+import { Transaction, TransactionArgument, TransactionObjectInput } from "@mysten/sui/transactions";
+export interface FieldsWithTypes {
+    fields: Record<string, any>;
+    type: string;
+}
+export type ObjectId = string;
+export type PureArg = bigint | string | number | boolean | null | TransactionArgument | Array<PureArg>;
+export type GenericArg = TransactionObjectInput | PureArg | Array<TransactionObjectInput> | Array<PureArg> | Array<GenericArg>;
+export declare function splitGenericParameters(str: string, genericSeparators?: [string, string]): string[];
+export declare function parseTypeName(name: string): {
+    typeName: string;
+    typeArgs: string[];
+};
+export declare function isTransactionArgument(arg: GenericArg): arg is TransactionArgument;
+export declare function obj(tx: Transaction, arg: TransactionObjectInput): {
+    GasCoin: true;
+} | {
+    Input: number;
+    type?: "pure" | "object";
+} | {
+    Result: number;
+} | {
+    NestedResult: [number, number];
+} | ((tx: Transaction) => Exclude<import("valibot").InferInput<typeof import("@mysten/sui/transactions").Argument>, {
+    Input: unknown;
+    type?: "pure";
+}>);
+export declare function pure(tx: Transaction, arg: PureArg, type: string): TransactionArgument;
+export declare function option(tx: Transaction, type: string, arg: GenericArg | null): TransactionArgument;
+export declare function generic(tx: Transaction, type: string, arg: GenericArg): TransactionArgument;
+export declare function vector(tx: Transaction, itemType: string, items: Array<GenericArg> | TransactionArgument): TransactionArgument;
+export declare function typeArgIsPure(type: string): boolean;
+export declare function compressSuiAddress(addr: string): string;
+export declare function compressSuiType(type: string): string;
+export declare function composeSuiType(typeName: string, ...typeArgs: string[]): string;