@typus/typus-perp-sdk 1.1.32-codegen-exp3 → 1.1.32-testnet-exp1

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

@@ -0,0 +1,8 @@
+export declare const PACKAGE_ID = "0x4b0f4ee1a40ce37ec81c987cc4e76a665419e74b863319492fc7d26f708b835a";
+export declare const PUBLISHED_AT = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294";
+export declare const PKG_V2 = "0x19fe3a0a4a831515a6801c51fdf0800e2428777b4e29cbc8355b7939a009893";
+export declare const PKG_V1 = "0x4b0f4ee1a40ce37ec81c987cc4e76a665419e74b863319492fc7d26f708b835a";
+export declare const PKG_V12 = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294";
+export declare const PKG_V5 = "0x892a5846a4466eaa68edce2613d48f880dfe3caccd47467a8ba718b2ad89cdac";
+export declare const PKG_V6 = "0xea14501c603e8fcd907087d3aa7cb7adb4d7b3a7ea5e078cc9e8f05c67bc8034";
+export declare const PKG_V3 = "0xf5c7e61fd28d1ed38711f03e1c5ffc6c5b8435eff386132fc5822efe6d90b138";

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PKG_V3 = exports.PKG_V6 = exports.PKG_V5 = exports.PKG_V12 = exports.PKG_V1 = exports.PKG_V2 = exports.PUBLISHED_AT = exports.PACKAGE_ID = void 0;
+exports.PACKAGE_ID = "0x4b0f4ee1a40ce37ec81c987cc4e76a665419e74b863319492fc7d26f708b835a";
+exports.PUBLISHED_AT = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294";
+exports.PKG_V2 = "0x19fe3a0a4a831515a6801c51fdf0800e2428777b4e29cbc8355b7939a009893";
+exports.PKG_V1 = "0x4b0f4ee1a40ce37ec81c987cc4e76a665419e74b863319492fc7d26f708b835a";
+exports.PKG_V12 = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294";
+exports.PKG_V5 = "0x892a5846a4466eaa68edce2613d48f880dfe3caccd47467a8ba718b2ad89cdac";
+exports.PKG_V6 = "0xea14501c603e8fcd907087d3aa7cb7adb4d7b3a7ea5e078cc9e8f05c67bc8034";
+exports.PKG_V3 = "0xf5c7e61fd28d1ed38711f03e1c5ffc6c5b8435eff386132fc5822efe6d90b138";

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

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

package/dist/src/_dependencies/source/0x4b0f4ee1a40ce37ec81c987cc4e76a665419e74b863319492fc7d26f708b835a/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(airdrop.Airdrop);
+    loader.register(airdrop.AirdropInfo);
+    loader.register(airdrop.ClaimAirdropEvent);
+    loader.register(airdrop.RemoveAirdropEvent);
+    loader.register(airdrop.SetAirdropEvent);
+    loader.register(airdrop.TypusAirdropRegistry);
+    loader.register(bigVector.BigVector);
+    loader.register(bigVector.Slice);
+    loader.register(critbit.CritbitTree);
+    loader.register(critbit.InternalNode);
+    loader.register(critbit.Leaf);
+    loader.register(ecosystem.FeeInfo);
+    loader.register(ecosystem.FeePool);
+    loader.register(ecosystem.ManagerCap);
+    loader.register(ecosystem.SendFeeEvent);
+    loader.register(ecosystem.Version);
+    loader.register(keyedBigVector.Element);
+    loader.register(keyedBigVector.KeyedBigVector);
+    loader.register(keyedBigVector.Slice);
+    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(linkedObjectTable.LinkedObjectTable);
+    loader.register(linkedObjectTable.Node);
+    loader.register(linkedSet.LinkedSet);
+    loader.register(linkedSet.Node);
+    loader.register(tailsStaking.ClaimProfitSharingEvent);
+    loader.register(tailsStaking.DailySignUpEvent);
+    loader.register(tailsStaking.ExpDownEvent);
+    loader.register(tailsStaking.ExpUpEvent);
+    loader.register(tailsStaking.LevelUpEvent);
+    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);
+    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);
+}

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

@@ -0,0 +1,202 @@
+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_V12 } 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 = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294::keyed_big_vector::Element";
+    static readonly $numTypeParams = 2;
+    static readonly $isPhantom: readonly [false, false];
+    readonly $typeName = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294::keyed_big_vector::Element";
+    readonly $fullTypeName: `${typeof PKG_V12}::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) => import("@mysten/sui/bcs").BcsStruct<{
+        key: K;
+        value: V;
+    }, string>;
+    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 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 = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294::keyed_big_vector::KeyedBigVector";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294::keyed_big_vector::KeyedBigVector";
+    readonly $fullTypeName: `${typeof PKG_V12}::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<"0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294::keyed_big_vector::KeyedBigVector">;
+    static get bcs(): import("@mysten/sui/bcs").BcsStruct<{
+        id: import("@mysten/sui/bcs").BcsStruct<{
+            id: import("@mysten/sui/bcs").BcsStruct<{
+                bytes: BcsType<string, string, string>;
+            }, string>;
+        }, string>;
+        key_type: import("@mysten/sui/bcs").BcsStruct<{
+            name: import("@mysten/sui/bcs").BcsStruct<{
+                bytes: BcsType<number[], Iterable<number> & {
+                    length: number;
+                }, string>;
+            }, string>;
+        }, string>;
+        value_type: import("@mysten/sui/bcs").BcsStruct<{
+            name: import("@mysten/sui/bcs").BcsStruct<{
+                bytes: BcsType<number[], Iterable<number> & {
+                    length: number;
+                }, string>;
+            }, string>;
+        }, string>;
+        slice_idx: BcsType<number, number, "u16">;
+        slice_size: BcsType<number, number, "u32">;
+        length: BcsType<string, string | number | bigint, "u64">;
+    }, string>;
+    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>;
+}
+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 = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294::keyed_big_vector::Slice";
+    static readonly $numTypeParams = 2;
+    static readonly $isPhantom: readonly [false, false];
+    readonly $typeName = "0x72cff6c9853237f97d28aeaa2c14a2258a40321d592570bff9ccafc9a3589294::keyed_big_vector::Slice";
+    readonly $fullTypeName: `${typeof PKG_V12}::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) => import("@mysten/sui/bcs").BcsStruct<{
+        idx: BcsType<number, number, "u16">;
+        vector: BcsType<{
+            key: K extends BcsType<infer U, any, string> ? U : never;
+            value: V extends BcsType<infer U, any, string> ? U : never;
+        }[], Iterable<{
+            key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+            value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+        }> & {
+            length: number;
+        }, string>;
+    }, string>;
+    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>>>;
+}