@typus/typus-sdk 1.4.3-e → 1.4.3-g

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

@@ -1,24 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,287 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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`)],
-    });
-}