@typus/typus-perp-sdk 1.0.0

package/dist/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/index.d.ts

@@ -0,0 +1,8 @@
+export declare const PACKAGE_ID = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277";
+export declare const PUBLISHED_AT = "0x8c3b1f0720e9a7a618163a0f482d044e23d3c8ea0f19ced2be1e9610f0c7241d";
+export declare const PKG_V5 = "0x1840fac0c84618087065346acdbac28bdec4326c416fcd2dc6d2f1b7d86fe62";
+export declare const PKG_V16 = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8";
+export declare const PKG_V1 = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277";
+export declare const PKG_V11 = "0x564d4849de6831f1d4250992d3233d60c6d65c2b34c4d31a61b110004a615d4d";
+export declare const PKG_V2 = "0x9ae906bfba335c86e93498f8016c06943865bc81e2da82f7e25b6d0b32d31e44";
+export declare const PKG_V6 = "0xd017b56fbdc5cab91c8d24ff16de26130628cad2394e46bcbbf83e9a6263ce5f";

package/dist/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PKG_V6 = exports.PKG_V2 = exports.PKG_V11 = exports.PKG_V1 = exports.PKG_V16 = exports.PKG_V5 = exports.PUBLISHED_AT = exports.PACKAGE_ID = void 0;
+exports.PACKAGE_ID = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277";
+exports.PUBLISHED_AT = "0x8c3b1f0720e9a7a618163a0f482d044e23d3c8ea0f19ced2be1e9610f0c7241d";
+exports.PKG_V5 = "0x1840fac0c84618087065346acdbac28bdec4326c416fcd2dc6d2f1b7d86fe62";
+exports.PKG_V16 = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8";
+exports.PKG_V1 = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277";
+exports.PKG_V11 = "0x564d4849de6831f1d4250992d3233d60c6d65c2b34c4d31a61b110004a615d4d";
+exports.PKG_V2 = "0x9ae906bfba335c86e93498f8016c06943865bc81e2da82f7e25b6d0b32d31e44";
+exports.PKG_V6 = "0xd017b56fbdc5cab91c8d24ff16de26130628cad2394e46bcbbf83e9a6263ce5f";

package/dist/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/init.d.ts

@@ -0,0 +1,2 @@
+import { StructClassLoader } from "../../../_framework/loader";
+export declare function registerClasses(loader: StructClassLoader): void;

package/dist/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/init.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerClasses = registerClasses;
+var airdrop = __importStar(require("./airdrop/structs"));
+var bigVector = __importStar(require("./big-vector/structs"));
+var critbit = __importStar(require("./critbit/structs"));
+var ecosystem = __importStar(require("./ecosystem/structs"));
+var keyedBigVector = __importStar(require("./keyed-big-vector/structs"));
+var leaderboard = __importStar(require("./leaderboard/structs"));
+var linkedObjectTable = __importStar(require("./linked-object-table/structs"));
+var linkedSet = __importStar(require("./linked-set/structs"));
+var tailsStaking = __importStar(require("./tails-staking/structs"));
+var tgld = __importStar(require("./tgld/structs"));
+var user = __importStar(require("./user/structs"));
+function registerClasses(loader) {
+    loader.register(ecosystem.Version);
+    loader.register(ecosystem.ManagerCap);
+    loader.register(ecosystem.FeeInfo);
+    loader.register(ecosystem.FeePool);
+    loader.register(ecosystem.SendFeeEvent);
+    loader.register(tgld.BurnEvent);
+    loader.register(tgld.MintEvent);
+    loader.register(tgld.TGLD);
+    loader.register(tgld.TgldRegistry);
+    loader.register(user.AddAccumulatedTgldAmount);
+    loader.register(user.AddTailsExpAmount);
+    loader.register(user.Metadata);
+    loader.register(user.RemoveTailsExpAmount);
+    loader.register(user.TypusUserRegistry);
+    loader.register(linkedSet.Node);
+    loader.register(linkedSet.LinkedSet);
+    loader.register(linkedObjectTable.Node);
+    loader.register(linkedObjectTable.LinkedObjectTable);
+    loader.register(critbit.CritbitTree);
+    loader.register(critbit.InternalNode);
+    loader.register(critbit.Leaf);
+    loader.register(leaderboard.ActivateLeaderboardEvent);
+    loader.register(leaderboard.DeactivateLeaderboardEvent);
+    loader.register(leaderboard.DeductEvent);
+    loader.register(leaderboard.ExtendLeaderboardEvent);
+    loader.register(leaderboard.Leaderboard);
+    loader.register(leaderboard.RemoveLeaderboardEvent);
+    loader.register(leaderboard.ScoreEvent);
+    loader.register(leaderboard.TypusLeaderboardRegistry);
+    loader.register(bigVector.BigVector);
+    loader.register(bigVector.Slice);
+    loader.register(airdrop.Airdrop);
+    loader.register(airdrop.AirdropInfo);
+    loader.register(airdrop.ClaimAirdropEvent);
+    loader.register(airdrop.RemoveAirdropEvent);
+    loader.register(airdrop.SetAirdropEvent);
+    loader.register(airdrop.TypusAirdropRegistry);
+    loader.register(keyedBigVector.Element);
+    loader.register(keyedBigVector.Slice);
+    loader.register(keyedBigVector.KeyedBigVector);
+    loader.register(tailsStaking.ExpDownEvent);
+    loader.register(tailsStaking.ExpUpEvent);
+    loader.register(tailsStaking.LevelUpEvent);
+    loader.register(tailsStaking.ClaimProfitSharingEvent);
+    loader.register(tailsStaking.DailySignUpEvent);
+    loader.register(tailsStaking.RemoveProfitSharingEvent);
+    loader.register(tailsStaking.SetProfitSharingEvent);
+    loader.register(tailsStaking.StakeTailsEvent);
+    loader.register(tailsStaking.StakingInfo);
+    loader.register(tailsStaking.TailsStakingRegistry);
+    loader.register(tailsStaking.TransferTailsEvent);
+    loader.register(tailsStaking.UnstakeTailsEvent);
+    loader.register(tailsStaking.UpdateTailsStakingRegistryConfigEvent);
+}

package/dist/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/keyed-big-vector/structs.d.ts

@@ -0,0 +1,227 @@
+import * as reified from "../../../../_framework/reified";
+import { PhantomReified, Reified, StructClass, ToField, ToTypeArgument, ToTypeStr, TypeArgument } from "../../../../_framework/reified";
+import { FieldsWithTypes } from "../../../../_framework/util";
+import { Vector } from "../../../../_framework/vector";
+import { TypeName } from "../../0x1/type-name/structs";
+import { UID } from "../../0x2/object/structs";
+import { PKG_V16 } from "../index";
+import { BcsType } from "@mysten/sui/bcs";
+import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+export declare function isElement(type: string): boolean;
+export interface ElementFields<K extends TypeArgument, V extends TypeArgument> {
+    key: ToField<K>;
+    value: ToField<V>;
+}
+export type ElementReified<K extends TypeArgument, V extends TypeArgument> = Reified<Element<K, V>, ElementFields<K, V>>;
+export declare class Element<K extends TypeArgument, V extends TypeArgument> implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8::keyed_big_vector::Element";
+    static readonly $numTypeParams = 2;
+    static readonly $isPhantom: readonly [false, false];
+    readonly $typeName = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8::keyed_big_vector::Element";
+    readonly $fullTypeName: `${typeof PKG_V16}::keyed_big_vector::Element<${ToTypeStr<K>}, ${ToTypeStr<V>}>`;
+    readonly $typeArgs: [ToTypeStr<K>, ToTypeStr<V>];
+    readonly $isPhantom: readonly [false, false];
+    readonly key: ToField<K>;
+    readonly value: ToField<V>;
+    private constructor();
+    static reified<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(K: K, V: V): ElementReified<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static get r(): typeof Element.reified;
+    static phantom<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(K: K, V: V): PhantomReified<ToTypeStr<Element<ToTypeArgument<K>, ToTypeArgument<V>>>>;
+    static get p(): typeof Element.phantom;
+    static get bcs(): <K extends BcsType<any>, V extends BcsType<any>>(K: K, V: V) => BcsType<{
+        key: K extends BcsType<infer U, any> ? U : never;
+        value: V extends BcsType<infer U, any> ? U : never;
+    }, {
+        key: K extends BcsType<any, infer U_1> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1> ? U_1 : never;
+    }>;
+    static fromFields<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], fields: Record<string, any>): Element<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromFieldsWithTypes<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], item: FieldsWithTypes): Element<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromBcs<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], data: Uint8Array): Element<ToTypeArgument<K>, ToTypeArgument<V>>;
+    toJSONField(): {
+        key: reified.ToJSON<K>;
+        value: reified.ToJSON<V>;
+    };
+    toJSON(): {
+        key: reified.ToJSON<K>;
+        value: reified.ToJSON<V>;
+        $typeName: string;
+        $typeArgs: [reified.ToTypeStr<K>, reified.ToTypeStr<V>];
+    };
+    static fromJSONField<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], field: any): Element<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromJSON<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], json: Record<string, any>): Element<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromSuiParsedData<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], content: SuiParsedData): Element<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromSuiObjectData<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], data: SuiObjectData): Element<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fetch<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(client: SuiClient, typeArgs: [K, V], id: string): Promise<Element<ToTypeArgument<K>, ToTypeArgument<V>>>;
+}
+export declare function isSlice(type: string): boolean;
+export interface SliceFields<K extends TypeArgument, V extends TypeArgument> {
+    idx: ToField<"u16">;
+    vector: ToField<Vector<Element<K, V>>>;
+}
+export type SliceReified<K extends TypeArgument, V extends TypeArgument> = Reified<Slice<K, V>, SliceFields<K, V>>;
+export declare class Slice<K extends TypeArgument, V extends TypeArgument> implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8::keyed_big_vector::Slice";
+    static readonly $numTypeParams = 2;
+    static readonly $isPhantom: readonly [false, false];
+    readonly $typeName = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8::keyed_big_vector::Slice";
+    readonly $fullTypeName: `${typeof PKG_V16}::keyed_big_vector::Slice<${ToTypeStr<K>}, ${ToTypeStr<V>}>`;
+    readonly $typeArgs: [ToTypeStr<K>, ToTypeStr<V>];
+    readonly $isPhantom: readonly [false, false];
+    readonly idx: ToField<"u16">;
+    readonly vector: ToField<Vector<Element<K, V>>>;
+    private constructor();
+    static reified<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(K: K, V: V): SliceReified<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static get r(): typeof Slice.reified;
+    static phantom<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(K: K, V: V): PhantomReified<ToTypeStr<Slice<ToTypeArgument<K>, ToTypeArgument<V>>>>;
+    static get p(): typeof Slice.phantom;
+    static get bcs(): <K extends BcsType<any>, V extends BcsType<any>>(K: K, V: V) => BcsType<{
+        idx: number;
+        vector: {
+            key: K extends BcsType<infer U, any> ? U : never;
+            value: V extends BcsType<infer U, any> ? U : never;
+        }[];
+    }, {
+        idx: number;
+        vector: Iterable<{
+            key: K extends BcsType<any, infer U_1> ? U_1 : never;
+            value: V extends BcsType<any, infer U_1> ? U_1 : never;
+        }> & {
+            length: number;
+        };
+    }>;
+    static fromFields<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], fields: Record<string, any>): Slice<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromFieldsWithTypes<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], item: FieldsWithTypes): Slice<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromBcs<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], data: Uint8Array): Slice<ToTypeArgument<K>, ToTypeArgument<V>>;
+    toJSONField(): {
+        idx: number;
+        vector: {
+            key: reified.ToJSON<K>;
+            value: reified.ToJSON<V>;
+        }[];
+    };
+    toJSON(): {
+        idx: number;
+        vector: {
+            key: reified.ToJSON<K>;
+            value: reified.ToJSON<V>;
+        }[];
+        $typeName: string;
+        $typeArgs: [reified.ToTypeStr<K>, reified.ToTypeStr<V>];
+    };
+    static fromJSONField<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], field: any): Slice<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromJSON<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], json: Record<string, any>): Slice<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromSuiParsedData<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], content: SuiParsedData): Slice<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fromSuiObjectData<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(typeArgs: [K, V], data: SuiObjectData): Slice<ToTypeArgument<K>, ToTypeArgument<V>>;
+    static fetch<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>(client: SuiClient, typeArgs: [K, V], id: string): Promise<Slice<ToTypeArgument<K>, ToTypeArgument<V>>>;
+}
+export declare function isKeyedBigVector(type: string): boolean;
+export interface KeyedBigVectorFields {
+    id: ToField<UID>;
+    keyType: ToField<TypeName>;
+    valueType: ToField<TypeName>;
+    sliceIdx: ToField<"u16">;
+    sliceSize: ToField<"u32">;
+    length: ToField<"u64">;
+}
+export type KeyedBigVectorReified = Reified<KeyedBigVector, KeyedBigVectorFields>;
+export declare class KeyedBigVector implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8::keyed_big_vector::KeyedBigVector";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8::keyed_big_vector::KeyedBigVector";
+    readonly $fullTypeName: `${typeof PKG_V16}::keyed_big_vector::KeyedBigVector`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly id: ToField<UID>;
+    readonly keyType: ToField<TypeName>;
+    readonly valueType: ToField<TypeName>;
+    readonly sliceIdx: ToField<"u16">;
+    readonly sliceSize: ToField<"u32">;
+    readonly length: ToField<"u64">;
+    private constructor();
+    static reified(): KeyedBigVectorReified;
+    static get r(): reified.StructClassReified<KeyedBigVector, KeyedBigVectorFields>;
+    static phantom(): PhantomReified<ToTypeStr<KeyedBigVector>>;
+    static get p(): reified.PhantomReified<"0x3896abb0c9c46aca621fe0d03ae5a4ac83c734a79a8a37cf0f5c97bb6762d9a8::keyed_big_vector::KeyedBigVector">;
+    static get bcs(): BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        key_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        value_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        slice_idx: number;
+        slice_size: number;
+        length: string;
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        key_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        value_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        slice_idx: number;
+        slice_size: number;
+        length: string | number | bigint;
+    }>;
+    static fromFields(fields: Record<string, any>): KeyedBigVector;
+    static fromFieldsWithTypes(item: FieldsWithTypes): KeyedBigVector;
+    static fromBcs(data: Uint8Array): KeyedBigVector;
+    toJSONField(): {
+        id: string;
+        keyType: {
+            name: string;
+        };
+        valueType: {
+            name: string;
+        };
+        sliceIdx: number;
+        sliceSize: number;
+        length: string;
+    };
+    toJSON(): {
+        id: string;
+        keyType: {
+            name: string;
+        };
+        valueType: {
+            name: string;
+        };
+        sliceIdx: number;
+        sliceSize: number;
+        length: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): KeyedBigVector;
+    static fromJSON(json: Record<string, any>): KeyedBigVector;
+    static fromSuiParsedData(content: SuiParsedData): KeyedBigVector;
+    static fromSuiObjectData(data: SuiObjectData): KeyedBigVector;
+    static fetch(client: SuiClient, id: string): Promise<KeyedBigVector>;
+}