@suilend/springsui-cli 1.0.0

package/sdk/src/_generated/_dependencies/source/0x3/staking-pool/structs.d.ts

@@ -0,0 +1,487 @@
+import * as reified from "../../../../_framework/reified";
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr, ToTypeStr as ToPhantom } from "../../../../_framework/reified";
+import { FieldsWithTypes } from "../../../../_framework/util";
+import { Option } from "../../0x1/option/structs";
+import { Bag } from "../../0x2/bag/structs";
+import { Balance } from "../../0x2/balance/structs";
+import { ID, UID } from "../../0x2/object/structs";
+import { SUI } from "../../0x2/sui/structs";
+import { Table } from "../../0x2/table/structs";
+import { PKG_V16 } from "../index";
+import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+export declare function isFungibleStakedSui(type: string): boolean;
+export interface FungibleStakedSuiFields {
+    id: ToField<UID>;
+    poolId: ToField<ID>;
+    value: ToField<"u64">;
+}
+export type FungibleStakedSuiReified = Reified<FungibleStakedSui, FungibleStakedSuiFields>;
+export declare class FungibleStakedSui implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3::staking_pool::FungibleStakedSui";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x3::staking_pool::FungibleStakedSui";
+    readonly $fullTypeName: `${typeof PKG_V16}::staking_pool::FungibleStakedSui`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly id: ToField<UID>;
+    readonly poolId: ToField<ID>;
+    readonly value: ToField<"u64">;
+    private constructor();
+    static reified(): FungibleStakedSuiReified;
+    static get r(): reified.StructClassReified<FungibleStakedSui, FungibleStakedSuiFields>;
+    static phantom(): PhantomReified<ToTypeStr<FungibleStakedSui>>;
+    static get p(): reified.PhantomReified<"0x3::staking_pool::FungibleStakedSui">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        pool_id: {
+            bytes: string;
+        };
+        value: string;
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        pool_id: {
+            bytes: string;
+        };
+        value: string | number | bigint;
+    }>;
+    static fromFields(fields: Record<string, any>): FungibleStakedSui;
+    static fromFieldsWithTypes(item: FieldsWithTypes): FungibleStakedSui;
+    static fromBcs(data: Uint8Array): FungibleStakedSui;
+    toJSONField(): {
+        id: string;
+        poolId: string;
+        value: string;
+    };
+    toJSON(): {
+        id: string;
+        poolId: string;
+        value: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): FungibleStakedSui;
+    static fromJSON(json: Record<string, any>): FungibleStakedSui;
+    static fromSuiParsedData(content: SuiParsedData): FungibleStakedSui;
+    static fromSuiObjectData(data: SuiObjectData): FungibleStakedSui;
+    static fetch(client: SuiClient, id: string): Promise<FungibleStakedSui>;
+}
+export declare function isFungibleStakedSuiData(type: string): boolean;
+export interface FungibleStakedSuiDataFields {
+    id: ToField<UID>;
+    totalSupply: ToField<"u64">;
+    principal: ToField<Balance<ToPhantom<SUI>>>;
+}
+export type FungibleStakedSuiDataReified = Reified<FungibleStakedSuiData, FungibleStakedSuiDataFields>;
+export declare class FungibleStakedSuiData implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3::staking_pool::FungibleStakedSuiData";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x3::staking_pool::FungibleStakedSuiData";
+    readonly $fullTypeName: `${typeof PKG_V16}::staking_pool::FungibleStakedSuiData`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly id: ToField<UID>;
+    readonly totalSupply: ToField<"u64">;
+    readonly principal: ToField<Balance<ToPhantom<SUI>>>;
+    private constructor();
+    static reified(): FungibleStakedSuiDataReified;
+    static get r(): reified.StructClassReified<FungibleStakedSuiData, FungibleStakedSuiDataFields>;
+    static phantom(): PhantomReified<ToTypeStr<FungibleStakedSuiData>>;
+    static get p(): reified.PhantomReified<"0x3::staking_pool::FungibleStakedSuiData">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        total_supply: string;
+        principal: {
+            value: string;
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        total_supply: string | number | bigint;
+        principal: {
+            value: string | number | bigint;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): FungibleStakedSuiData;
+    static fromFieldsWithTypes(item: FieldsWithTypes): FungibleStakedSuiData;
+    static fromBcs(data: Uint8Array): FungibleStakedSuiData;
+    toJSONField(): {
+        id: string;
+        totalSupply: string;
+        principal: {
+            value: string;
+        };
+    };
+    toJSON(): {
+        id: string;
+        totalSupply: string;
+        principal: {
+            value: string;
+        };
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): FungibleStakedSuiData;
+    static fromJSON(json: Record<string, any>): FungibleStakedSuiData;
+    static fromSuiParsedData(content: SuiParsedData): FungibleStakedSuiData;
+    static fromSuiObjectData(data: SuiObjectData): FungibleStakedSuiData;
+    static fetch(client: SuiClient, id: string): Promise<FungibleStakedSuiData>;
+}
+export declare function isFungibleStakedSuiDataKey(type: string): boolean;
+export interface FungibleStakedSuiDataKeyFields {
+    dummyField: ToField<"bool">;
+}
+export type FungibleStakedSuiDataKeyReified = Reified<FungibleStakedSuiDataKey, FungibleStakedSuiDataKeyFields>;
+export declare class FungibleStakedSuiDataKey implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3::staking_pool::FungibleStakedSuiDataKey";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x3::staking_pool::FungibleStakedSuiDataKey";
+    readonly $fullTypeName: `${typeof PKG_V16}::staking_pool::FungibleStakedSuiDataKey`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly dummyField: ToField<"bool">;
+    private constructor();
+    static reified(): FungibleStakedSuiDataKeyReified;
+    static get r(): reified.StructClassReified<FungibleStakedSuiDataKey, FungibleStakedSuiDataKeyFields>;
+    static phantom(): PhantomReified<ToTypeStr<FungibleStakedSuiDataKey>>;
+    static get p(): reified.PhantomReified<"0x3::staking_pool::FungibleStakedSuiDataKey">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        dummy_field: boolean;
+    }, {
+        dummy_field: boolean;
+    }>;
+    static fromFields(fields: Record<string, any>): FungibleStakedSuiDataKey;
+    static fromFieldsWithTypes(item: FieldsWithTypes): FungibleStakedSuiDataKey;
+    static fromBcs(data: Uint8Array): FungibleStakedSuiDataKey;
+    toJSONField(): {
+        dummyField: boolean;
+    };
+    toJSON(): {
+        dummyField: boolean;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): FungibleStakedSuiDataKey;
+    static fromJSON(json: Record<string, any>): FungibleStakedSuiDataKey;
+    static fromSuiParsedData(content: SuiParsedData): FungibleStakedSuiDataKey;
+    static fromSuiObjectData(data: SuiObjectData): FungibleStakedSuiDataKey;
+    static fetch(client: SuiClient, id: string): Promise<FungibleStakedSuiDataKey>;
+}
+export declare function isPoolTokenExchangeRate(type: string): boolean;
+export interface PoolTokenExchangeRateFields {
+    suiAmount: ToField<"u64">;
+    poolTokenAmount: ToField<"u64">;
+}
+export type PoolTokenExchangeRateReified = Reified<PoolTokenExchangeRate, PoolTokenExchangeRateFields>;
+export declare class PoolTokenExchangeRate implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3::staking_pool::PoolTokenExchangeRate";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x3::staking_pool::PoolTokenExchangeRate";
+    readonly $fullTypeName: `${typeof PKG_V16}::staking_pool::PoolTokenExchangeRate`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly suiAmount: ToField<"u64">;
+    readonly poolTokenAmount: ToField<"u64">;
+    private constructor();
+    static reified(): PoolTokenExchangeRateReified;
+    static get r(): reified.StructClassReified<PoolTokenExchangeRate, PoolTokenExchangeRateFields>;
+    static phantom(): PhantomReified<ToTypeStr<PoolTokenExchangeRate>>;
+    static get p(): reified.PhantomReified<"0x3::staking_pool::PoolTokenExchangeRate">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        sui_amount: string;
+        pool_token_amount: string;
+    }, {
+        sui_amount: string | number | bigint;
+        pool_token_amount: string | number | bigint;
+    }>;
+    static fromFields(fields: Record<string, any>): PoolTokenExchangeRate;
+    static fromFieldsWithTypes(item: FieldsWithTypes): PoolTokenExchangeRate;
+    static fromBcs(data: Uint8Array): PoolTokenExchangeRate;
+    toJSONField(): {
+        suiAmount: string;
+        poolTokenAmount: string;
+    };
+    toJSON(): {
+        suiAmount: string;
+        poolTokenAmount: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): PoolTokenExchangeRate;
+    static fromJSON(json: Record<string, any>): PoolTokenExchangeRate;
+    static fromSuiParsedData(content: SuiParsedData): PoolTokenExchangeRate;
+    static fromSuiObjectData(data: SuiObjectData): PoolTokenExchangeRate;
+    static fetch(client: SuiClient, id: string): Promise<PoolTokenExchangeRate>;
+}
+export declare function isStakedSui(type: string): boolean;
+export interface StakedSuiFields {
+    id: ToField<UID>;
+    poolId: ToField<ID>;
+    stakeActivationEpoch: ToField<"u64">;
+    principal: ToField<Balance<ToPhantom<SUI>>>;
+}
+export type StakedSuiReified = Reified<StakedSui, StakedSuiFields>;
+export declare class StakedSui implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3::staking_pool::StakedSui";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x3::staking_pool::StakedSui";
+    readonly $fullTypeName: `${typeof PKG_V16}::staking_pool::StakedSui`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly id: ToField<UID>;
+    readonly poolId: ToField<ID>;
+    readonly stakeActivationEpoch: ToField<"u64">;
+    readonly principal: ToField<Balance<ToPhantom<SUI>>>;
+    private constructor();
+    static reified(): StakedSuiReified;
+    static get r(): reified.StructClassReified<StakedSui, StakedSuiFields>;
+    static phantom(): PhantomReified<ToTypeStr<StakedSui>>;
+    static get p(): reified.PhantomReified<"0x3::staking_pool::StakedSui">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        pool_id: {
+            bytes: string;
+        };
+        stake_activation_epoch: string;
+        principal: {
+            value: string;
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        pool_id: {
+            bytes: string;
+        };
+        stake_activation_epoch: string | number | bigint;
+        principal: {
+            value: string | number | bigint;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): StakedSui;
+    static fromFieldsWithTypes(item: FieldsWithTypes): StakedSui;
+    static fromBcs(data: Uint8Array): StakedSui;
+    toJSONField(): {
+        id: string;
+        poolId: string;
+        stakeActivationEpoch: string;
+        principal: {
+            value: string;
+        };
+    };
+    toJSON(): {
+        id: string;
+        poolId: string;
+        stakeActivationEpoch: string;
+        principal: {
+            value: string;
+        };
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): StakedSui;
+    static fromJSON(json: Record<string, any>): StakedSui;
+    static fromSuiParsedData(content: SuiParsedData): StakedSui;
+    static fromSuiObjectData(data: SuiObjectData): StakedSui;
+    static fetch(client: SuiClient, id: string): Promise<StakedSui>;
+}
+export declare function isStakingPool(type: string): boolean;
+export interface StakingPoolFields {
+    id: ToField<UID>;
+    activationEpoch: ToField<Option<"u64">>;
+    deactivationEpoch: ToField<Option<"u64">>;
+    suiBalance: ToField<"u64">;
+    rewardsPool: ToField<Balance<ToPhantom<SUI>>>;
+    poolTokenBalance: ToField<"u64">;
+    exchangeRates: ToField<Table<"u64", ToPhantom<PoolTokenExchangeRate>>>;
+    pendingStake: ToField<"u64">;
+    pendingTotalSuiWithdraw: ToField<"u64">;
+    pendingPoolTokenWithdraw: ToField<"u64">;
+    extraFields: ToField<Bag>;
+}
+export type StakingPoolReified = Reified<StakingPool, StakingPoolFields>;
+export declare class StakingPool implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x3::staking_pool::StakingPool";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x3::staking_pool::StakingPool";
+    readonly $fullTypeName: `${typeof PKG_V16}::staking_pool::StakingPool`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly id: ToField<UID>;
+    readonly activationEpoch: ToField<Option<"u64">>;
+    readonly deactivationEpoch: ToField<Option<"u64">>;
+    readonly suiBalance: ToField<"u64">;
+    readonly rewardsPool: ToField<Balance<ToPhantom<SUI>>>;
+    readonly poolTokenBalance: ToField<"u64">;
+    readonly exchangeRates: ToField<Table<"u64", ToPhantom<PoolTokenExchangeRate>>>;
+    readonly pendingStake: ToField<"u64">;
+    readonly pendingTotalSuiWithdraw: ToField<"u64">;
+    readonly pendingPoolTokenWithdraw: ToField<"u64">;
+    readonly extraFields: ToField<Bag>;
+    private constructor();
+    static reified(): StakingPoolReified;
+    static get r(): reified.StructClassReified<StakingPool, StakingPoolFields>;
+    static phantom(): PhantomReified<ToTypeStr<StakingPool>>;
+    static get p(): reified.PhantomReified<"0x3::staking_pool::StakingPool">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        activation_epoch: {
+            vec: any[];
+        };
+        deactivation_epoch: {
+            vec: any[];
+        };
+        sui_balance: string;
+        rewards_pool: {
+            value: string;
+        };
+        pool_token_balance: string;
+        exchange_rates: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+        pending_stake: string;
+        pending_total_sui_withdraw: string;
+        pending_pool_token_withdraw: string;
+        extra_fields: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        activation_epoch: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+        deactivation_epoch: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+        sui_balance: string | number | bigint;
+        rewards_pool: {
+            value: string | number | bigint;
+        };
+        pool_token_balance: string | number | bigint;
+        exchange_rates: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+        pending_stake: string | number | bigint;
+        pending_total_sui_withdraw: string | number | bigint;
+        pending_pool_token_withdraw: string | number | bigint;
+        extra_fields: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): StakingPool;
+    static fromFieldsWithTypes(item: FieldsWithTypes): StakingPool;
+    static fromBcs(data: Uint8Array): StakingPool;
+    toJSONField(): {
+        id: string;
+        activationEpoch: string | null;
+        deactivationEpoch: string | null;
+        suiBalance: string;
+        rewardsPool: {
+            value: string;
+        };
+        poolTokenBalance: string;
+        exchangeRates: {
+            id: string;
+            size: string;
+        };
+        pendingStake: string;
+        pendingTotalSuiWithdraw: string;
+        pendingPoolTokenWithdraw: string;
+        extraFields: {
+            id: string;
+            size: string;
+        };
+    };
+    toJSON(): {
+        id: string;
+        activationEpoch: string | null;
+        deactivationEpoch: string | null;
+        suiBalance: string;
+        rewardsPool: {
+            value: string;
+        };
+        poolTokenBalance: string;
+        exchangeRates: {
+            id: string;
+            size: string;
+        };
+        pendingStake: string;
+        pendingTotalSuiWithdraw: string;
+        pendingPoolTokenWithdraw: string;
+        extraFields: {
+            id: string;
+            size: string;
+        };
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): StakingPool;
+    static fromJSON(json: Record<string, any>): StakingPool;
+    static fromSuiParsedData(content: SuiParsedData): StakingPool;
+    static fromSuiObjectData(data: SuiObjectData): StakingPool;
+    static fetch(client: SuiClient, id: string): Promise<StakingPool>;
+}