@sentio/sdk 2.26.0 → 2.26.1-rc.2

package/src/aptos/builtin/0x3.ts

@@ -198,6 +198,29 @@ export class token extends AptosBaseProcessor {
     return this;
   }
 
+  onEventBurnTokenEvent(
+    func: (event: token.BurnTokenEventInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token {
+    this.onMoveEvent(func, { type: "token::BurnTokenEvent" }, fetchConfig);
+    return this;
+  }
+
+  onEventCollectionMutabilityConfig(
+    func: (
+      event: token.CollectionMutabilityConfigInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token {
+    this.onMoveEvent(
+      func,
+      { type: "token::CollectionMutabilityConfig" },
+      fetchConfig,
+    );
+    return this;
+  }
+
   onEventCreateCollectionEvent(
     func: (
       event: token.CreateCollectionEventInstance,
@@ -228,6 +251,14 @@ export class token extends AptosBaseProcessor {
     return this;
   }
 
+  onEventDepositEvent(
+    func: (event: token.DepositEventInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token {
+    this.onMoveEvent(func, { type: "token::DepositEvent" }, fetchConfig);
+    return this;
+  }
+
   onEventMintTokenEvent(
     func: (event: token.MintTokenEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
@@ -236,44 +267,75 @@ export class token extends AptosBaseProcessor {
     return this;
   }
 
-  onEventDepositEvent(
-    func: (event: token.DepositEventInstance, ctx: AptosContext) => void,
+  onEventMutateTokenPropertyMapEvent(
+    func: (
+      event: token.MutateTokenPropertyMapEventInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token {
-    this.onMoveEvent(func, { type: "token::DepositEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { type: "token::MutateTokenPropertyMapEvent" },
+      fetchConfig,
+    );
     return this;
   }
 
-  onEventWithdrawEvent(
-    func: (event: token.WithdrawEventInstance, ctx: AptosContext) => void,
+  onEventRoyalty(
+    func: (event: token.RoyaltyInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token {
-    this.onMoveEvent(func, { type: "token::WithdrawEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "token::Royalty" }, fetchConfig);
     return this;
   }
 
-  onEventBurnTokenEvent(
-    func: (event: token.BurnTokenEventInstance, ctx: AptosContext) => void,
+  onEventTokenDataId(
+    func: (event: token.TokenDataIdInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token {
-    this.onMoveEvent(func, { type: "token::BurnTokenEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "token::TokenDataId" }, fetchConfig);
     return this;
   }
 
-  onEventMutateTokenPropertyMapEvent(
+  onEventTokenId(
+    func: (event: token.TokenIdInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token {
+    this.onMoveEvent(func, { type: "token::TokenId" }, fetchConfig);
+    return this;
+  }
+
+  onEventTokenMutabilityConfig(
     func: (
-      event: token.MutateTokenPropertyMapEventInstance,
+      event: token.TokenMutabilityConfigInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token {
     this.onMoveEvent(
       func,
-      { type: "token::MutateTokenPropertyMapEvent" },
+      { type: "token::TokenMutabilityConfig" },
       fetchConfig,
     );
     return this;
   }
+
+  onEventWithdrawCapability(
+    func: (event: token.WithdrawCapabilityInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token {
+    this.onMoveEvent(func, { type: "token::WithdrawCapability" }, fetchConfig);
+    return this;
+  }
+
+  onEventWithdrawEvent(
+    func: (event: token.WithdrawEventInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token {
+    this.onMoveEvent(func, { type: "token::WithdrawEvent" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace token {
@@ -335,6 +397,12 @@ export namespace token {
     }
   }
 
+  export interface CollectionMutabilityConfigInstance
+    extends TypedEventInstance<CollectionMutabilityConfig> {
+    data_decoded: CollectionMutabilityConfig;
+    type_arguments: [];
+  }
+
   export interface Collections {
     collection_data: _0x1.table.Table<string, token.CollectionData>;
     token_data: _0x1.table.Table<token.TokenDataId, token.TokenData>;
@@ -496,6 +564,11 @@ export namespace token {
     }
   }
 
+  export interface RoyaltyInstance extends TypedEventInstance<Royalty> {
+    data_decoded: Royalty;
+    type_arguments: [];
+  }
+
   export interface Token {
     id: token.TokenId;
     amount: bigint;
@@ -550,6 +623,11 @@ export namespace token {
     }
   }
 
+  export interface TokenDataIdInstance extends TypedEventInstance<TokenDataId> {
+    data_decoded: TokenDataId;
+    type_arguments: [];
+  }
+
   export interface TokenId {
     token_data_id: token.TokenDataId;
     property_version: bigint;
@@ -565,6 +643,11 @@ export namespace token {
     }
   }
 
+  export interface TokenIdInstance extends TypedEventInstance<TokenId> {
+    data_decoded: TokenId;
+    type_arguments: [];
+  }
+
   export interface TokenMutabilityConfig {
     maximum: Boolean;
     uri: Boolean;
@@ -585,6 +668,12 @@ export namespace token {
     }
   }
 
+  export interface TokenMutabilityConfigInstance
+    extends TypedEventInstance<TokenMutabilityConfig> {
+    data_decoded: TokenMutabilityConfig;
+    type_arguments: [];
+  }
+
   export interface TokenStore {
     tokens: _0x1.table.Table<token.TokenId, token.Token>;
     direct_transfer: Boolean;
@@ -623,6 +712,12 @@ export namespace token {
     }
   }
 
+  export interface WithdrawCapabilityInstance
+    extends TypedEventInstance<WithdrawCapability> {
+    data_decoded: WithdrawCapability;
+    type_arguments: [];
+  }
+
   export interface WithdrawEvent {
     id: token.TokenId;
     amount: bigint;
@@ -761,6 +856,43 @@ export namespace token {
   }
 }
 
+export class property_map extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("property_map", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x3",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): property_map {
+    return new property_map({ ...property_map.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventPropertyMap(
+    func: (event: property_map.PropertyMapInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): property_map {
+    this.onMoveEvent(func, { type: "property_map::PropertyMap" }, fetchConfig);
+    return this;
+  }
+
+  onEventPropertyValue(
+    func: (
+      event: property_map.PropertyValueInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): property_map {
+    this.onMoveEvent(
+      func,
+      { type: "property_map::PropertyValue" },
+      fetchConfig,
+    );
+    return this;
+  }
+}
+
 export namespace property_map {
   export interface PropertyMap {
     map: _0x1.simple_map.SimpleMap<string, property_map.PropertyValue>;
@@ -776,6 +908,11 @@ export namespace property_map {
     }
   }
 
+  export interface PropertyMapInstance extends TypedEventInstance<PropertyMap> {
+    data_decoded: PropertyMap;
+    type_arguments: [];
+  }
+
   export interface PropertyValue {
     value: string;
     type: string;
@@ -790,6 +927,12 @@ export namespace property_map {
       return TYPE.apply();
     }
   }
+
+  export interface PropertyValueInstance
+    extends TypedEventInstance<PropertyValue> {
+    data_decoded: PropertyValue;
+    type_arguments: [];
+  }
 }
 
 export class token_coin_swap extends AptosBaseProcessor {
@@ -827,6 +970,21 @@ export class token_coin_swap extends AptosBaseProcessor {
     return this;
   }
 
+  onEventTokenCoinSwap(
+    func: (
+      event: token_coin_swap.TokenCoinSwapInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token_coin_swap {
+    this.onMoveEvent(
+      func,
+      { type: "token_coin_swap::TokenCoinSwap" },
+      fetchConfig,
+    );
+    return this;
+  }
+
   onEventTokenListingEvent(
     func: (
       event: token_coin_swap.TokenListingEventInstance,
@@ -878,6 +1036,12 @@ export namespace token_coin_swap {
     }
   }
 
+  export interface TokenCoinSwapInstance
+    extends TypedEventInstance<TokenCoinSwap<any>> {
+    data_decoded: TokenCoinSwap<any>;
+    type_arguments: [string];
+  }
+
   export interface TokenEscrow {
     token: token.Token;
     locked_until_secs: bigint;
@@ -1066,46 +1230,61 @@ export class token_transfers extends AptosBaseProcessor {
     return this;
   }
 
-  onEventTokenOfferEvent(
+  onEventTokenCancelOfferEvent(
     func: (
-      event: token_transfers.TokenOfferEventInstance,
+      event: token_transfers.TokenCancelOfferEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_transfers {
     this.onMoveEvent(
       func,
-      { type: "token_transfers::TokenOfferEvent" },
+      { type: "token_transfers::TokenCancelOfferEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventTokenCancelOfferEvent(
+  onEventTokenClaimEvent(
     func: (
-      event: token_transfers.TokenCancelOfferEventInstance,
+      event: token_transfers.TokenClaimEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_transfers {
     this.onMoveEvent(
       func,
-      { type: "token_transfers::TokenCancelOfferEvent" },
+      { type: "token_transfers::TokenClaimEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventTokenClaimEvent(
+  onEventTokenOfferEvent(
     func: (
-      event: token_transfers.TokenClaimEventInstance,
+      event: token_transfers.TokenOfferEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_transfers {
     this.onMoveEvent(
       func,
-      { type: "token_transfers::TokenClaimEvent" },
+      { type: "token_transfers::TokenOfferEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventTokenOfferId(
+    func: (
+      event: token_transfers.TokenOfferIdInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): token_transfers {
+    this.onMoveEvent(
+      func,
+      { type: "token_transfers::TokenOfferId" },
       fetchConfig,
     );
     return this;
@@ -1217,6 +1396,12 @@ export namespace token_transfers {
     }
   }
 
+  export interface TokenOfferIdInstance
+    extends TypedEventInstance<TokenOfferId> {
+    data_decoded: TokenOfferId;
+    type_arguments: [];
+  }
+
   export interface CancelOfferScriptPayload
     extends TypedFunctionPayload<
       [Address, Address, Address, string, string, bigint]
@@ -1266,16 +1451,16 @@ export class token_event_store extends AptosBaseProcessor {
     });
   }
 
-  onEventCollectionUriMutateEvent(
+  onEventCollectionDescriptionMutateEvent(
     func: (
-      event: token_event_store.CollectionUriMutateEventInstance,
+      event: token_event_store.CollectionDescriptionMutateEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_event_store {
     this.onMoveEvent(
       func,
-      { type: "token_event_store::CollectionUriMutateEvent" },
+      { type: "token_event_store::CollectionDescriptionMutateEvent" },
       fetchConfig,
     );
     return this;
@@ -1296,76 +1481,76 @@ export class token_event_store extends AptosBaseProcessor {
     return this;
   }
 
-  onEventCollectionDescriptionMutateEvent(
+  onEventCollectionUriMutateEvent(
     func: (
-      event: token_event_store.CollectionDescriptionMutateEventInstance,
+      event: token_event_store.CollectionUriMutateEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_event_store {
     this.onMoveEvent(
       func,
-      { type: "token_event_store::CollectionDescriptionMutateEvent" },
+      { type: "token_event_store::CollectionUriMutateEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventOptInTransferEvent(
+  onEventDefaultPropertyMutateEvent(
     func: (
-      event: token_event_store.OptInTransferEventInstance,
+      event: token_event_store.DefaultPropertyMutateEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_event_store {
     this.onMoveEvent(
       func,
-      { type: "token_event_store::OptInTransferEvent" },
+      { type: "token_event_store::DefaultPropertyMutateEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUriMutationEvent(
+  onEventDescriptionMutateEvent(
     func: (
-      event: token_event_store.UriMutationEventInstance,
+      event: token_event_store.DescriptionMutateEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_event_store {
     this.onMoveEvent(
       func,
-      { type: "token_event_store::UriMutationEvent" },
+      { type: "token_event_store::DescriptionMutateEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDefaultPropertyMutateEvent(
+  onEventMaxiumMutateEvent(
     func: (
-      event: token_event_store.DefaultPropertyMutateEventInstance,
+      event: token_event_store.MaxiumMutateEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_event_store {
     this.onMoveEvent(
       func,
-      { type: "token_event_store::DefaultPropertyMutateEvent" },
+      { type: "token_event_store::MaxiumMutateEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDescriptionMutateEvent(
+  onEventOptInTransferEvent(
     func: (
-      event: token_event_store.DescriptionMutateEventInstance,
+      event: token_event_store.OptInTransferEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_event_store {
     this.onMoveEvent(
       func,
-      { type: "token_event_store::DescriptionMutateEvent" },
+      { type: "token_event_store::OptInTransferEvent" },
       fetchConfig,
     );
     return this;
@@ -1386,16 +1571,16 @@ export class token_event_store extends AptosBaseProcessor {
     return this;
   }
 
-  onEventMaxiumMutateEvent(
+  onEventUriMutationEvent(
     func: (
-      event: token_event_store.MaxiumMutateEventInstance,
+      event: token_event_store.UriMutationEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): token_event_store {
     this.onMoveEvent(
       func,
-      { type: "token_event_store::MaxiumMutateEvent" },
+      { type: "token_event_store::UriMutationEvent" },
       fetchConfig,
     );
     return this;