@sentio/sdk 2.0.0-rc.9 → 2.0.0

package/lib/aptos/builtin/0x3.d.ts

@@ -0,0 +1,491 @@
+import { MoveCoder, AptosBindOptions, AptosBaseProcessor, TypedEventInstance, TypedEntryFunctionPayload, AptosContext, CallFilter } from "@sentio/sdk/aptos";
+import { AptosFetchConfig } from "@sentio/protos";
+import { Address, MoveModule } from "@sentio/sdk/aptos";
+import * as _0x1 from "./0x1.js";
+export declare class token extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): token;
+    onEntryBurn(func: (call: token.BurnPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryBurnByCreator(func: (call: token.BurnByCreatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryCreateCollectionScript(func: (call: token.CreateCollectionScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryCreateTokenScript(func: (call: token.CreateTokenScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryDirectTransferScript(func: (call: token.DirectTransferScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryInitializeTokenScript(func: (call: token.InitializeTokenScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryMintScript(func: (call: token.MintScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryMutateTokenProperties(func: (call: token.MutateTokenPropertiesPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEntryOptInDirectTransfer(func: (call: token.OptInDirectTransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token;
+    onEventCreateCollectionEvent(func: (event: token.CreateCollectionEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token;
+    onEventCreateTokenDataEvent(func: (event: token.CreateTokenDataEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token;
+    onEventMintTokenEvent(func: (event: token.MintTokenEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token;
+    onEventDepositEvent(func: (event: token.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token;
+    onEventWithdrawEvent(func: (event: token.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token;
+    onEventBurnTokenEvent(func: (event: token.BurnTokenEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token;
+    onEventMutateTokenPropertyMapEvent(func: (event: token.MutateTokenPropertyMapEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token;
+    loadTypesInternal(registry: MoveCoder): void;
+}
+export declare namespace token {
+    class BurnTokenEvent {
+        static TYPE_QNAME: string;
+        id: token.TokenId;
+        amount: bigint;
+    }
+    interface BurnTokenEventInstance extends TypedEventInstance<BurnTokenEvent> {
+        data_decoded: BurnTokenEvent;
+        type_arguments: [];
+    }
+    class CollectionData {
+        static TYPE_QNAME: string;
+        description: string;
+        name: string;
+        uri: string;
+        supply: bigint;
+        maximum: bigint;
+        mutability_config: token.CollectionMutabilityConfig;
+    }
+    class CollectionMutabilityConfig {
+        static TYPE_QNAME: string;
+        description: Boolean;
+        uri: Boolean;
+        maximum: Boolean;
+    }
+    class Collections {
+        static TYPE_QNAME: string;
+        collection_data: _0x1.table.Table<string, token.CollectionData>;
+        token_data: _0x1.table.Table<token.TokenDataId, token.TokenData>;
+        create_collection_events: _0x1.event.EventHandle<token.CreateCollectionEvent>;
+        create_token_data_events: _0x1.event.EventHandle<token.CreateTokenDataEvent>;
+        mint_token_events: _0x1.event.EventHandle<token.MintTokenEvent>;
+    }
+    class CreateCollectionEvent {
+        static TYPE_QNAME: string;
+        creator: Address;
+        collection_name: string;
+        uri: string;
+        description: string;
+        maximum: bigint;
+    }
+    interface CreateCollectionEventInstance extends TypedEventInstance<CreateCollectionEvent> {
+        data_decoded: CreateCollectionEvent;
+        type_arguments: [];
+    }
+    class CreateTokenDataEvent {
+        static TYPE_QNAME: string;
+        id: token.TokenDataId;
+        description: string;
+        maximum: bigint;
+        uri: string;
+        royalty_payee_address: Address;
+        royalty_points_denominator: bigint;
+        royalty_points_numerator: bigint;
+        name: string;
+        mutability_config: token.TokenMutabilityConfig;
+        property_keys: string[];
+        property_values: string[];
+        property_types: string[];
+    }
+    interface CreateTokenDataEventInstance extends TypedEventInstance<CreateTokenDataEvent> {
+        data_decoded: CreateTokenDataEvent;
+        type_arguments: [];
+    }
+    class DepositEvent {
+        static TYPE_QNAME: string;
+        id: token.TokenId;
+        amount: bigint;
+    }
+    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
+        data_decoded: DepositEvent;
+        type_arguments: [];
+    }
+    class MintTokenEvent {
+        static TYPE_QNAME: string;
+        id: token.TokenDataId;
+        amount: bigint;
+    }
+    interface MintTokenEventInstance extends TypedEventInstance<MintTokenEvent> {
+        data_decoded: MintTokenEvent;
+        type_arguments: [];
+    }
+    class MutateTokenPropertyMapEvent {
+        static TYPE_QNAME: string;
+        old_id: token.TokenId;
+        new_id: token.TokenId;
+        keys: string[];
+        values: string[];
+        types: string[];
+    }
+    interface MutateTokenPropertyMapEventInstance extends TypedEventInstance<MutateTokenPropertyMapEvent> {
+        data_decoded: MutateTokenPropertyMapEvent;
+        type_arguments: [];
+    }
+    class Royalty {
+        static TYPE_QNAME: string;
+        royalty_points_numerator: bigint;
+        royalty_points_denominator: bigint;
+        payee_address: Address;
+    }
+    class Token {
+        static TYPE_QNAME: string;
+        id: token.TokenId;
+        amount: bigint;
+        token_properties: property_map.PropertyMap;
+    }
+    class TokenData {
+        static TYPE_QNAME: string;
+        maximum: bigint;
+        largest_property_version: bigint;
+        supply: bigint;
+        uri: string;
+        royalty: token.Royalty;
+        name: string;
+        description: string;
+        default_properties: property_map.PropertyMap;
+        mutability_config: token.TokenMutabilityConfig;
+    }
+    class TokenDataId {
+        static TYPE_QNAME: string;
+        creator: Address;
+        collection: string;
+        name: string;
+    }
+    class TokenId {
+        static TYPE_QNAME: string;
+        token_data_id: token.TokenDataId;
+        property_version: bigint;
+    }
+    class TokenMutabilityConfig {
+        static TYPE_QNAME: string;
+        maximum: Boolean;
+        uri: Boolean;
+        royalty: Boolean;
+        description: Boolean;
+        properties: Boolean;
+    }
+    class TokenStore {
+        static TYPE_QNAME: string;
+        tokens: _0x1.table.Table<token.TokenId, token.Token>;
+        direct_transfer: Boolean;
+        deposit_events: _0x1.event.EventHandle<token.DepositEvent>;
+        withdraw_events: _0x1.event.EventHandle<token.WithdrawEvent>;
+        burn_events: _0x1.event.EventHandle<token.BurnTokenEvent>;
+        mutate_token_property_events: _0x1.event.EventHandle<token.MutateTokenPropertyMapEvent>;
+    }
+    class WithdrawCapability {
+        static TYPE_QNAME: string;
+        token_owner: Address;
+        token_id: token.TokenId;
+        amount: bigint;
+        expiration_sec: bigint;
+    }
+    class WithdrawEvent {
+        static TYPE_QNAME: string;
+        id: token.TokenId;
+        amount: bigint;
+    }
+    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
+        data_decoded: WithdrawEvent;
+        type_arguments: [];
+    }
+    interface BurnPayload extends TypedEntryFunctionPayload<[
+        Address,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [Address, string, string, bigint, bigint];
+        type_arguments: [];
+    }
+    interface BurnByCreatorPayload extends TypedEntryFunctionPayload<[
+        Address,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [Address, string, string, bigint, bigint];
+        type_arguments: [];
+    }
+    interface CreateCollectionScriptPayload extends TypedEntryFunctionPayload<[
+        string,
+        string,
+        string,
+        bigint,
+        Boolean[]
+    ]> {
+        arguments_decoded: [string, string, string, bigint, Boolean[]];
+        type_arguments: [];
+    }
+    interface CreateTokenScriptPayload extends TypedEntryFunctionPayload<[
+        string,
+        string,
+        string,
+        bigint,
+        bigint,
+        string,
+        Address,
+        bigint,
+        bigint,
+        Boolean[],
+        string[],
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            string,
+            string,
+            string,
+            bigint,
+            bigint,
+            string,
+            Address,
+            bigint,
+            bigint,
+            Boolean[],
+            string[],
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface DirectTransferScriptPayload extends TypedEntryFunctionPayload<[
+        Address,
+        Address,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [Address, Address, string, string, bigint, bigint];
+        type_arguments: [];
+    }
+    interface InitializeTokenScriptPayload extends TypedEntryFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface MintScriptPayload extends TypedEntryFunctionPayload<[Address, string, string, bigint]> {
+        arguments_decoded: [Address, string, string, bigint];
+        type_arguments: [];
+    }
+    interface MutateTokenPropertiesPayload extends TypedEntryFunctionPayload<[
+        Address,
+        Address,
+        string,
+        string,
+        bigint,
+        bigint,
+        string[],
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            Address,
+            Address,
+            string,
+            string,
+            bigint,
+            bigint,
+            string[],
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface OptInDirectTransferPayload extends TypedEntryFunctionPayload<[Boolean]> {
+        arguments_decoded: [Boolean];
+        type_arguments: [];
+    }
+    function loadTypes(_r: MoveCoder): void;
+    const ABI: MoveModule;
+}
+export declare namespace property_map {
+    class PropertyMap {
+        static TYPE_QNAME: string;
+        map: _0x1.simple_map.SimpleMap<string, property_map.PropertyValue>;
+    }
+    class PropertyValue {
+        static TYPE_QNAME: string;
+        value: string;
+        type: string;
+    }
+    function loadTypes(_r: MoveCoder): void;
+    const ABI: MoveModule;
+}
+export declare class token_coin_swap extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): token_coin_swap;
+    onEntryListTokenForSwap(func: (call: token_coin_swap.ListTokenForSwapPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token_coin_swap;
+    onEventTokenListingEvent(func: (event: token_coin_swap.TokenListingEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token_coin_swap;
+    onEventTokenSwapEvent(func: (event: token_coin_swap.TokenSwapEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token_coin_swap;
+    loadTypesInternal(registry: MoveCoder): void;
+}
+export declare namespace token_coin_swap {
+    class TokenCoinSwap<T0> {
+        static TYPE_QNAME: string;
+        token_amount: bigint;
+        min_price_per_token: bigint;
+    }
+    class TokenEscrow {
+        static TYPE_QNAME: string;
+        token: token.Token;
+        locked_until_secs: bigint;
+    }
+    class TokenListingEvent {
+        static TYPE_QNAME: string;
+        token_id: token.TokenId;
+        amount: bigint;
+        min_price: bigint;
+        locked_until_secs: bigint;
+        coin_type_info: _0x1.type_info.TypeInfo;
+    }
+    interface TokenListingEventInstance extends TypedEventInstance<TokenListingEvent> {
+        data_decoded: TokenListingEvent;
+        type_arguments: [];
+    }
+    class TokenListings<T0> {
+        static TYPE_QNAME: string;
+        listings: _0x1.table.Table<token.TokenId, token_coin_swap.TokenCoinSwap<T0>>;
+        listing_events: _0x1.event.EventHandle<token_coin_swap.TokenListingEvent>;
+        swap_events: _0x1.event.EventHandle<token_coin_swap.TokenSwapEvent>;
+    }
+    class TokenStoreEscrow {
+        static TYPE_QNAME: string;
+        token_escrows: _0x1.table.Table<token.TokenId, token_coin_swap.TokenEscrow>;
+    }
+    class TokenSwapEvent {
+        static TYPE_QNAME: string;
+        token_id: token.TokenId;
+        token_buyer: Address;
+        token_amount: bigint;
+        coin_amount: bigint;
+        coin_type_info: _0x1.type_info.TypeInfo;
+    }
+    interface TokenSwapEventInstance extends TypedEventInstance<TokenSwapEvent> {
+        data_decoded: TokenSwapEvent;
+        type_arguments: [];
+    }
+    interface ListTokenForSwapPayload<T0 = any> extends TypedEntryFunctionPayload<[
+        Address,
+        string,
+        string,
+        bigint,
+        bigint,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [
+            Address,
+            string,
+            string,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ];
+        type_arguments: [string];
+    }
+    function loadTypes(_r: MoveCoder): void;
+    const ABI: MoveModule;
+}
+export declare class token_transfers extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): token_transfers;
+    onEntryCancelOfferScript(func: (call: token_transfers.CancelOfferScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token_transfers;
+    onEntryClaimScript(func: (call: token_transfers.ClaimScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token_transfers;
+    onEntryOfferScript(func: (call: token_transfers.OfferScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): token_transfers;
+    onEventTokenOfferEvent(func: (event: token_transfers.TokenOfferEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token_transfers;
+    onEventTokenCancelOfferEvent(func: (event: token_transfers.TokenCancelOfferEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token_transfers;
+    onEventTokenClaimEvent(func: (event: token_transfers.TokenClaimEventInstance, ctx: AptosContext) => void, fetchConfig?: AptosFetchConfig): token_transfers;
+    loadTypesInternal(registry: MoveCoder): void;
+}
+export declare namespace token_transfers {
+    class PendingClaims {
+        static TYPE_QNAME: string;
+        pending_claims: _0x1.table.Table<token_transfers.TokenOfferId, token.Token>;
+        offer_events: _0x1.event.EventHandle<token_transfers.TokenOfferEvent>;
+        cancel_offer_events: _0x1.event.EventHandle<token_transfers.TokenCancelOfferEvent>;
+        claim_events: _0x1.event.EventHandle<token_transfers.TokenClaimEvent>;
+    }
+    class TokenCancelOfferEvent {
+        static TYPE_QNAME: string;
+        to_address: Address;
+        token_id: token.TokenId;
+        amount: bigint;
+    }
+    interface TokenCancelOfferEventInstance extends TypedEventInstance<TokenCancelOfferEvent> {
+        data_decoded: TokenCancelOfferEvent;
+        type_arguments: [];
+    }
+    class TokenClaimEvent {
+        static TYPE_QNAME: string;
+        to_address: Address;
+        token_id: token.TokenId;
+        amount: bigint;
+    }
+    interface TokenClaimEventInstance extends TypedEventInstance<TokenClaimEvent> {
+        data_decoded: TokenClaimEvent;
+        type_arguments: [];
+    }
+    class TokenOfferEvent {
+        static TYPE_QNAME: string;
+        to_address: Address;
+        token_id: token.TokenId;
+        amount: bigint;
+    }
+    interface TokenOfferEventInstance extends TypedEventInstance<TokenOfferEvent> {
+        data_decoded: TokenOfferEvent;
+        type_arguments: [];
+    }
+    class TokenOfferId {
+        static TYPE_QNAME: string;
+        to_addr: Address;
+        token_id: token.TokenId;
+    }
+    interface CancelOfferScriptPayload extends TypedEntryFunctionPayload<[
+        Address,
+        Address,
+        Address,
+        string,
+        string,
+        bigint
+    ]> {
+        arguments_decoded: [Address, Address, Address, string, string, bigint];
+        type_arguments: [];
+    }
+    interface ClaimScriptPayload extends TypedEntryFunctionPayload<[
+        Address,
+        Address,
+        Address,
+        string,
+        string,
+        bigint
+    ]> {
+        arguments_decoded: [Address, Address, Address, string, string, bigint];
+        type_arguments: [];
+    }
+    interface OfferScriptPayload extends TypedEntryFunctionPayload<[
+        Address,
+        Address,
+        Address,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [
+            Address,
+            Address,
+            Address,
+            string,
+            string,
+            bigint,
+            bigint
+        ];
+        type_arguments: [];
+    }
+    function loadTypes(_r: MoveCoder): void;
+    const ABI: MoveModule;
+}
+export declare function loadAllTypes(_r: MoveCoder): void;