@typemove/aptos 1.5.1 → 1.5.2-rc.2

package/Readme.md

@@ -1,4 +1,8 @@
-# Typemove 
+<p align="center">
+  <img src="../../images/logo.png" width="300" alt="TypeChain">
+</p>
+
+# TypeMove 
 Generate TypeScript bindings for Aptos contracts.
 ## Features
  - Code generation for Aptos smart contract based on ABI

package/dist/cjs/builtin/0x1.d.ts

@@ -1019,10 +1019,26 @@ export declare namespace voting {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
+        function getProposalMetadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
+        function getProposalMetadataValue<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint, string];
+        }, version?: bigint): Promise<[string]>;
         function getProposalState<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
+        function getProposer<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getResolutionTimeSecs<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
         function getVotes<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
@@ -1762,7 +1778,11 @@ export declare namespace features {
         function type(): TypeDescriptor<Features>;
     }
     namespace entry { }
-    namespace view { }
+    namespace view {
+        function isEnabled(client: Aptos, request: {
+            functionArguments: [bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
 }
 export declare namespace from_bcs {
     namespace entry { }
@@ -2280,6 +2300,18 @@ export declare namespace string_utils {
     namespace view { }
 }
 export declare namespace aggregator_v2 {
+    interface Aggregator<T0> {
+        value: T0;
+        max_value: T0;
+    }
+    namespace Aggregator {
+        const TYPE_QNAME = "0x1::aggregator_v2::Aggregator";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Aggregator<T0>>;
+    }
+    interface AggregatorInstance extends TypedEventInstance<Aggregator<any>> {
+        data_decoded: Aggregator<any>;
+        type_arguments: [string];
+    }
     interface AggregatorSnapshot<T0> {
         value: T0;
     }
@@ -2346,6 +2378,122 @@ export declare namespace aptos_account {
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
+export declare namespace bn254_algebra {
+    interface FormatFq12LscLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFq12LscLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFq12LscLsb";
+        function type(): TypeDescriptor<FormatFq12LscLsb>;
+    }
+    interface FormatFqLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFqLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqLsb";
+        function type(): TypeDescriptor<FormatFqLsb>;
+    }
+    interface FormatFqMsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFqMsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqMsb";
+        function type(): TypeDescriptor<FormatFqMsb>;
+    }
+    interface FormatFrLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFrLsb";
+        function type(): TypeDescriptor<FormatFrLsb>;
+    }
+    interface FormatFrMsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrMsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFrMsb";
+        function type(): TypeDescriptor<FormatFrMsb>;
+    }
+    interface FormatG1Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Compr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG1Compr";
+        function type(): TypeDescriptor<FormatG1Compr>;
+    }
+    interface FormatG1Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Uncompr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG1Uncompr";
+        function type(): TypeDescriptor<FormatG1Uncompr>;
+    }
+    interface FormatG2Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Compr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG2Compr";
+        function type(): TypeDescriptor<FormatG2Compr>;
+    }
+    interface FormatG2Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Uncompr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG2Uncompr";
+        function type(): TypeDescriptor<FormatG2Uncompr>;
+    }
+    interface FormatGt {
+        dummy_field: Boolean;
+    }
+    namespace FormatGt {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatGt";
+        function type(): TypeDescriptor<FormatGt>;
+    }
+    interface Fq {
+        dummy_field: Boolean;
+    }
+    namespace Fq {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fq";
+        function type(): TypeDescriptor<Fq>;
+    }
+    interface Fq12 {
+        dummy_field: Boolean;
+    }
+    namespace Fq12 {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fq12";
+        function type(): TypeDescriptor<Fq12>;
+    }
+    interface Fr {
+        dummy_field: Boolean;
+    }
+    namespace Fr {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fr";
+        function type(): TypeDescriptor<Fr>;
+    }
+    interface G1 {
+        dummy_field: Boolean;
+    }
+    namespace G1 {
+        const TYPE_QNAME = "0x1::bn254_algebra::G1";
+        function type(): TypeDescriptor<G1>;
+    }
+    interface G2 {
+        dummy_field: Boolean;
+    }
+    namespace G2 {
+        const TYPE_QNAME = "0x1::bn254_algebra::G2";
+        function type(): TypeDescriptor<G2>;
+    }
+    interface Gt {
+        dummy_field: Boolean;
+    }
+    namespace Gt {
+        const TYPE_QNAME = "0x1::bn254_algebra::Gt";
+        function type(): TypeDescriptor<Gt>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace create_signer {
     namespace entry { }
     namespace view { }
@@ -2508,6 +2656,13 @@ export declare namespace fungible_asset {
         data_decoded: BurnRef;
         type_arguments: [];
     }
+    interface ConcurrentSupply {
+        current: aggregator_v2.Aggregator<bigint>;
+    }
+    namespace ConcurrentSupply {
+        const TYPE_QNAME = "0x1::fungible_asset::ConcurrentSupply";
+        function type(): TypeDescriptor<ConcurrentSupply>;
+    }
     interface DepositEvent {
         amount: bigint;
     }
@@ -2702,6 +2857,19 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::BeneficiaryForOperator";
         function type(): TypeDescriptor<BeneficiaryForOperator>;
     }
+    interface CommissionPercentageChange {
+        pool_address: MoveAddressType;
+        owner: MoveAddressType;
+        commission_percentage_next_lockup_cycle: bigint;
+    }
+    namespace CommissionPercentageChange {
+        const TYPE_QNAME = "0x1::delegation_pool::CommissionPercentageChange";
+        function type(): TypeDescriptor<CommissionPercentageChange>;
+    }
+    interface CommissionPercentageChangeInstance extends TypedEventInstance<CommissionPercentageChange> {
+        data_decoded: CommissionPercentageChange;
+        type_arguments: [];
+    }
     interface CreateProposalEvent {
         proposal_id: bigint;
         voter: MoveAddressType;
@@ -2809,6 +2977,14 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::GovernanceRecords";
         function type(): TypeDescriptor<GovernanceRecords>;
     }
+    interface NextCommissionPercentage {
+        commission_percentage_next_lockup_cycle: bigint;
+        effective_after_secs: bigint;
+    }
+    namespace NextCommissionPercentage {
+        const TYPE_QNAME = "0x1::delegation_pool::NextCommissionPercentage";
+        function type(): TypeDescriptor<NextCommissionPercentage>;
+    }
     interface ObservedLockupCycle {
         index: bigint;
     }
@@ -2957,6 +3133,10 @@ export declare namespace delegation_pool {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateCommissionPercentage(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function vote(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint, bigint, Boolean];
@@ -3003,12 +3183,19 @@ export declare namespace delegation_pool {
         function getStake(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function isNextCommissionPercentageEffective(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[Boolean]>;
+        function minRemainingSecsForCommissionChange(client: Aptos, version?: bigint): Promise<[bigint]>;
         function observedLockupCycle(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
         function operatorCommissionPercentage(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
+        function operatorCommissionPercentageNextLockupCycle(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function ownerCapExists(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;