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

package/src/typus-perp/symbol/functions.ts

@@ -0,0 +1,24 @@
+import { PUBLISHED_AT } from "..";
+import { ObjectArg, obj } from "../../_framework/util";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+
+export function new_(txb: TransactionBlock, typeArgs: [string, string]) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::symbol::new`, typeArguments: typeArgs, arguments: [] });
+}
+
+export interface CreateArgs {
+    baseToken: ObjectArg;
+    quoteToken: ObjectArg;
+}
+
+export function create(txb: TransactionBlock, args: CreateArgs) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::symbol::create`, arguments: [obj(txb, args.baseToken), obj(txb, args.quoteToken)] });
+}
+
+export function baseToken(txb: TransactionBlock, self: ObjectArg) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::symbol::base_token`, arguments: [obj(txb, self)] });
+}
+
+export function quoteToken(txb: TransactionBlock, self: ObjectArg) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::symbol::quote_token`, arguments: [obj(txb, self)] });
+}

package/src/typus-perp/symbol/structs.ts

@@ -0,0 +1,165 @@
+import { TypeName } from "../../_dependencies/source/0x1/type-name/structs";
+import {
+    PhantomReified,
+    Reified,
+    StructClass,
+    ToField,
+    ToTypeStr,
+    decodeFromFields,
+    decodeFromFieldsWithTypes,
+    decodeFromJSONField,
+    phantom,
+} from "../../_framework/reified";
+import { FieldsWithTypes, composeSuiType, compressSuiType } from "../../_framework/util";
+import { bcs, fromB64 } from "@mysten/bcs";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+
+/* ============================== Symbol =============================== */
+
+export function isSymbol(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::symbol::Symbol";
+}
+
+export interface SymbolFields {
+    baseToken: ToField<TypeName>;
+    quoteToken: ToField<TypeName>;
+}
+
+export type SymbolReified = Reified<Symbol, SymbolFields>;
+
+export class Symbol implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::symbol::Symbol";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = Symbol.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::symbol::Symbol";
+
+    readonly $typeArgs: [];
+
+    readonly baseToken: ToField<TypeName>;
+    readonly quoteToken: ToField<TypeName>;
+
+    private constructor(typeArgs: [], fields: SymbolFields) {
+        this.$fullTypeName = composeSuiType(
+            Symbol.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::symbol::Symbol";
+        this.$typeArgs = typeArgs;
+
+        this.baseToken = fields.baseToken;
+        this.quoteToken = fields.quoteToken;
+    }
+
+    static reified(): SymbolReified {
+        return {
+            typeName: Symbol.$typeName,
+            fullTypeName: composeSuiType(
+                Symbol.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::symbol::Symbol",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => Symbol.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => Symbol.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => Symbol.fromBcs(data),
+            bcs: Symbol.bcs,
+            fromJSONField: (field: any) => Symbol.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => Symbol.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => Symbol.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => Symbol.fetch(client, id),
+            new: (fields: SymbolFields) => {
+                return new Symbol([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return Symbol.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<Symbol>> {
+        return phantom(Symbol.reified());
+    }
+    static get p() {
+        return Symbol.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("Symbol", {
+            base_token: TypeName.bcs,
+            quote_token: TypeName.bcs,
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): Symbol {
+        return Symbol.reified().new({
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            quoteToken: decodeFromFields(TypeName.reified(), fields.quote_token),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): Symbol {
+        if (!isSymbol(item.type)) {
+            throw new Error("not a Symbol type");
+        }
+
+        return Symbol.reified().new({
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            quoteToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.quote_token),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): Symbol {
+        return Symbol.fromFields(Symbol.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            baseToken: this.baseToken.toJSONField(),
+            quoteToken: this.quoteToken.toJSONField(),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): Symbol {
+        return Symbol.reified().new({
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            quoteToken: decodeFromJSONField(TypeName.reified(), field.quoteToken),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): Symbol {
+        if (json.$typeName !== Symbol.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return Symbol.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): Symbol {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSymbol(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a Symbol object`);
+        }
+        return Symbol.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<Symbol> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching Symbol object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSymbol(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a Symbol object`);
+        }
+        return Symbol.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}

package/src/typus-perp/tlp/functions.ts

@@ -0,0 +1,50 @@
+import { PUBLISHED_AT } from "..";
+import { ObjectArg, obj, pure } from "../../_framework/util";
+import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
+
+export interface BurnArgs {
+    treasuryCap: ObjectArg;
+    coin: ObjectArg;
+}
+
+export function burn(txb: TransactionBlock, typeArg: string, args: BurnArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::tlp::burn`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.treasuryCap), obj(txb, args.coin)],
+    });
+}
+
+export interface MintArgs {
+    treasuryCap: ObjectArg;
+    value: bigint | TransactionArgument;
+}
+
+export function mint(txb: TransactionBlock, typeArg: string, args: MintArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::tlp::mint`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.treasuryCap), pure(txb, args.value, `u64`)],
+    });
+}
+
+export function totalSupply(txb: TransactionBlock, treasuryCap: ObjectArg) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::tlp::total_supply`, arguments: [obj(txb, treasuryCap)] });
+}
+
+export function init(txb: TransactionBlock, witness: ObjectArg) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::tlp::init`, arguments: [obj(txb, witness)] });
+}
+
+export interface TransferTreasuryCapArgs {
+    version: ObjectArg;
+    lpRegistry: ObjectArg;
+    treasuryCaps: ObjectArg;
+}
+
+export function transferTreasuryCap(txb: TransactionBlock, args: TransferTreasuryCapArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::tlp::transfer_treasury_cap`,
+        arguments: [obj(txb, args.version), obj(txb, args.lpRegistry), obj(txb, args.treasuryCaps)],
+    });
+}

package/src/typus-perp/tlp/structs.ts

@@ -0,0 +1,287 @@
+import { UID } from "../../_dependencies/source/0x2/object/structs";
+import {
+    PhantomReified,
+    Reified,
+    StructClass,
+    ToField,
+    ToTypeStr,
+    decodeFromFields,
+    decodeFromFieldsWithTypes,
+    decodeFromJSONField,
+    phantom,
+} from "../../_framework/reified";
+import { FieldsWithTypes, composeSuiType, compressSuiType } from "../../_framework/util";
+import { bcs, fromB64 } from "@mysten/bcs";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+
+/* ============================== LpRegistry =============================== */
+
+export function isLpRegistry(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::LpRegistry";
+}
+
+export interface LpRegistryFields {
+    id: ToField<UID>;
+}
+
+export type LpRegistryReified = Reified<LpRegistry, LpRegistryFields>;
+
+export class LpRegistry implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::LpRegistry";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = LpRegistry.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::LpRegistry";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+
+    private constructor(typeArgs: [], fields: LpRegistryFields) {
+        this.$fullTypeName = composeSuiType(
+            LpRegistry.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::LpRegistry";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+    }
+
+    static reified(): LpRegistryReified {
+        return {
+            typeName: LpRegistry.$typeName,
+            fullTypeName: composeSuiType(
+                LpRegistry.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::LpRegistry",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => LpRegistry.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => LpRegistry.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => LpRegistry.fromBcs(data),
+            bcs: LpRegistry.bcs,
+            fromJSONField: (field: any) => LpRegistry.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => LpRegistry.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => LpRegistry.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => LpRegistry.fetch(client, id),
+            new: (fields: LpRegistryFields) => {
+                return new LpRegistry([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return LpRegistry.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<LpRegistry>> {
+        return phantom(LpRegistry.reified());
+    }
+    static get p() {
+        return LpRegistry.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("LpRegistry", {
+            id: UID.bcs,
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): LpRegistry {
+        return LpRegistry.reified().new({ id: decodeFromFields(UID.reified(), fields.id) });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): LpRegistry {
+        if (!isLpRegistry(item.type)) {
+            throw new Error("not a LpRegistry type");
+        }
+
+        return LpRegistry.reified().new({ id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id) });
+    }
+
+    static fromBcs(data: Uint8Array): LpRegistry {
+        return LpRegistry.fromFields(LpRegistry.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): LpRegistry {
+        return LpRegistry.reified().new({ id: decodeFromJSONField(UID.reified(), field.id) });
+    }
+
+    static fromJSON(json: Record<string, any>): LpRegistry {
+        if (json.$typeName !== LpRegistry.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return LpRegistry.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): LpRegistry {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isLpRegistry(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a LpRegistry object`);
+        }
+        return LpRegistry.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<LpRegistry> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching LpRegistry object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isLpRegistry(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a LpRegistry object`);
+        }
+        return LpRegistry.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== TLP =============================== */
+
+export function isTLP(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::TLP";
+}
+
+export interface TLPFields {
+    dummyField: ToField<"bool">;
+}
+
+export type TLPReified = Reified<TLP, TLPFields>;
+
+export class TLP implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::TLP";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = TLP.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::TLP";
+
+    readonly $typeArgs: [];
+
+    readonly dummyField: ToField<"bool">;
+
+    private constructor(typeArgs: [], fields: TLPFields) {
+        this.$fullTypeName = composeSuiType(
+            TLP.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::TLP";
+        this.$typeArgs = typeArgs;
+
+        this.dummyField = fields.dummyField;
+    }
+
+    static reified(): TLPReified {
+        return {
+            typeName: TLP.$typeName,
+            fullTypeName: composeSuiType(
+                TLP.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::tlp::TLP",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => TLP.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => TLP.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => TLP.fromBcs(data),
+            bcs: TLP.bcs,
+            fromJSONField: (field: any) => TLP.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => TLP.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => TLP.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => TLP.fetch(client, id),
+            new: (fields: TLPFields) => {
+                return new TLP([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return TLP.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<TLP>> {
+        return phantom(TLP.reified());
+    }
+    static get p() {
+        return TLP.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("TLP", {
+            dummy_field: bcs.bool(),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): TLP {
+        return TLP.reified().new({ dummyField: decodeFromFields("bool", fields.dummy_field) });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): TLP {
+        if (!isTLP(item.type)) {
+            throw new Error("not a TLP type");
+        }
+
+        return TLP.reified().new({ dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) });
+    }
+
+    static fromBcs(data: Uint8Array): TLP {
+        return TLP.fromFields(TLP.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): TLP {
+        return TLP.reified().new({ dummyField: decodeFromJSONField("bool", field.dummyField) });
+    }
+
+    static fromJSON(json: Record<string, any>): TLP {
+        if (json.$typeName !== TLP.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return TLP.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): TLP {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isTLP(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a TLP object`);
+        }
+        return TLP.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<TLP> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching TLP object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isTLP(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a TLP object`);
+        }
+        return TLP.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}

package/src/typus-perp/token-interface/functions.ts

@@ -0,0 +1,29 @@
+import { PUBLISHED_AT } from "..";
+import { ObjectArg, obj, pure } from "../../_framework/util";
+import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
+
+export interface BurnArgs {
+    treasuryCap: ObjectArg;
+    coin: ObjectArg;
+}
+
+export function burn(txb: TransactionBlock, typeArg: string, args: BurnArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::token_interface::burn`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.treasuryCap), obj(txb, args.coin)],
+    });
+}
+
+export interface MintArgs {
+    treasuryCap: ObjectArg;
+    value: bigint | TransactionArgument;
+}
+
+export function mint(txb: TransactionBlock, typeArg: string, args: MintArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::token_interface::mint`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.treasuryCap), pure(txb, args.value, `u64`)],
+    });
+}