@typemove/aptos 1.0.0-rc.14 → 1.0.0-rc.16
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/builtin/0x1.d.ts +654 -104
- package/dist/builtin/0x1.d.ts.map +1 -1
- package/dist/builtin/0x1.js +1481 -117
- package/dist/builtin/0x1.js.map +1 -1
- package/dist/builtin/0x3.d.ts +90 -2
- package/dist/builtin/0x3.d.ts.map +1 -1
- package/dist/builtin/0x3.js +153 -1
- package/dist/builtin/0x3.js.map +1 -1
- package/dist/client.test.d.ts +2 -0
- package/dist/client.test.d.ts.map +1 -0
- package/dist/client.test.js.map +1 -0
- package/dist/codegen/codegen.js +42 -9
- package/dist/codegen/codegen.js.map +1 -1
- package/package.json +2 -2
- package/src/builtin/0x1.ts +3029 -219
- package/src/builtin/0x3.ts +350 -3
- package/src/codegen/codegen.ts +48 -10
- package/dist/view-function.test.d.ts +0 -2
- package/dist/view-function.test.d.ts.map +0 -1
- package/dist/view-function.test.js.map +0 -1
package/dist/builtin/0x1.d.ts
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import { TypeDescriptor } from "@typemove/move";
|
|
2
2
|
import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
|
|
3
3
|
import { Address } from "@typemove/aptos";
|
|
4
|
-
import { AptosClient } from "aptos";
|
|
4
|
+
import { AptosClient, AptosAccount, Types, OptionalTransactionArgs } from "aptos";
|
|
5
5
|
export declare namespace acl {
|
|
6
6
|
interface ACL {
|
|
7
7
|
list: Address[];
|
|
@@ -10,6 +10,7 @@ export declare namespace acl {
|
|
|
10
10
|
const TYPE_QNAME = "0x1::acl::ACL";
|
|
11
11
|
function type(): TypeDescriptor<ACL>;
|
|
12
12
|
}
|
|
13
|
+
namespace entry { }
|
|
13
14
|
namespace view { }
|
|
14
15
|
}
|
|
15
16
|
export declare namespace any_ {
|
|
@@ -21,9 +22,11 @@ export declare namespace any_ {
|
|
|
21
22
|
const TYPE_QNAME = "0x1::any::Any";
|
|
22
23
|
function type(): TypeDescriptor<Any>;
|
|
23
24
|
}
|
|
25
|
+
namespace entry { }
|
|
24
26
|
namespace view { }
|
|
25
27
|
}
|
|
26
28
|
export declare namespace bcs {
|
|
29
|
+
namespace entry { }
|
|
27
30
|
namespace view { }
|
|
28
31
|
}
|
|
29
32
|
export declare namespace code {
|
|
@@ -81,6 +84,12 @@ export declare namespace code {
|
|
|
81
84
|
const TYPE_QNAME = "0x1::code::UpgradePolicy";
|
|
82
85
|
function type(): TypeDescriptor<UpgradePolicy>;
|
|
83
86
|
}
|
|
87
|
+
namespace entry {
|
|
88
|
+
function publishPackageTxn(client: AptosClient, account: AptosAccount, request: {
|
|
89
|
+
type_arguments: [];
|
|
90
|
+
arguments: [string, string[]];
|
|
91
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
92
|
+
}
|
|
84
93
|
namespace view { }
|
|
85
94
|
}
|
|
86
95
|
export declare namespace coin {
|
|
@@ -168,35 +177,53 @@ export declare namespace coin {
|
|
|
168
177
|
data_decoded: WithdrawEvent;
|
|
169
178
|
type_arguments: [];
|
|
170
179
|
}
|
|
180
|
+
namespace entry {
|
|
181
|
+
function freezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
182
|
+
type_arguments: [string];
|
|
183
|
+
arguments: [Address, Address];
|
|
184
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
185
|
+
function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
186
|
+
type_arguments: [string];
|
|
187
|
+
arguments: [Address, bigint];
|
|
188
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
189
|
+
function unfreezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
190
|
+
type_arguments: [string];
|
|
191
|
+
arguments: [Address, Address];
|
|
192
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
193
|
+
function upgradeSupply<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
194
|
+
type_arguments: [string];
|
|
195
|
+
arguments: [];
|
|
196
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
197
|
+
}
|
|
171
198
|
namespace view {
|
|
172
199
|
function balance<T0 = any>(client: AptosClient, request: {
|
|
173
200
|
type_arguments: [string];
|
|
174
201
|
arguments: [Address];
|
|
175
|
-
}, version?: bigint): Promise<
|
|
202
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
176
203
|
function decimals<T0 = any>(client: AptosClient, request: {
|
|
177
204
|
type_arguments: [string];
|
|
178
205
|
arguments: [];
|
|
179
|
-
}, version?: bigint): Promise<
|
|
206
|
+
}, version?: bigint): Promise<[number]>;
|
|
180
207
|
function isAccountRegistered<T0 = any>(client: AptosClient, request: {
|
|
181
208
|
type_arguments: [string];
|
|
182
209
|
arguments: [Address];
|
|
183
|
-
}, version?: bigint): Promise<
|
|
210
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
184
211
|
function isCoinInitialized<T0 = any>(client: AptosClient, request: {
|
|
185
212
|
type_arguments: [string];
|
|
186
213
|
arguments: [];
|
|
187
|
-
}, version?: bigint): Promise<
|
|
214
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
188
215
|
function name<T0 = any>(client: AptosClient, request: {
|
|
189
216
|
type_arguments: [string];
|
|
190
217
|
arguments: [];
|
|
191
|
-
}, version?: bigint): Promise<
|
|
218
|
+
}, version?: bigint): Promise<[string]>;
|
|
192
219
|
function supply<T0 = any>(client: AptosClient, request: {
|
|
193
220
|
type_arguments: [string];
|
|
194
221
|
arguments: [];
|
|
195
|
-
}, version?: bigint): Promise<
|
|
222
|
+
}, version?: bigint): Promise<[option.Option<bigint>]>;
|
|
196
223
|
function symbol<T0 = any>(client: AptosClient, request: {
|
|
197
224
|
type_arguments: [string];
|
|
198
225
|
arguments: [];
|
|
199
|
-
}, version?: bigint): Promise<
|
|
226
|
+
}, version?: bigint): Promise<[string]>;
|
|
200
227
|
}
|
|
201
228
|
}
|
|
202
229
|
export declare namespace guid {
|
|
@@ -215,12 +242,15 @@ export declare namespace guid {
|
|
|
215
242
|
const TYPE_QNAME = "0x1::guid::ID";
|
|
216
243
|
function type(): TypeDescriptor<ID>;
|
|
217
244
|
}
|
|
245
|
+
namespace entry { }
|
|
218
246
|
namespace view { }
|
|
219
247
|
}
|
|
220
248
|
export declare namespace hash {
|
|
249
|
+
namespace entry { }
|
|
221
250
|
namespace view { }
|
|
222
251
|
}
|
|
223
252
|
export declare namespace util {
|
|
253
|
+
namespace entry { }
|
|
224
254
|
namespace view { }
|
|
225
255
|
}
|
|
226
256
|
export declare namespace block {
|
|
@@ -264,21 +294,24 @@ export declare namespace block {
|
|
|
264
294
|
data_decoded: UpdateEpochIntervalEvent;
|
|
265
295
|
type_arguments: [];
|
|
266
296
|
}
|
|
297
|
+
namespace entry { }
|
|
267
298
|
namespace view {
|
|
268
299
|
function getCurrentBlockHeight(client: AptosClient, request: {
|
|
269
300
|
type_arguments: [];
|
|
270
301
|
arguments: [];
|
|
271
|
-
}, version?: bigint): Promise<
|
|
302
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
272
303
|
function getEpochIntervalSecs(client: AptosClient, request: {
|
|
273
304
|
type_arguments: [];
|
|
274
305
|
arguments: [];
|
|
275
|
-
}, version?: bigint): Promise<
|
|
306
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
276
307
|
}
|
|
277
308
|
}
|
|
278
309
|
export declare namespace debug {
|
|
310
|
+
namespace entry { }
|
|
279
311
|
namespace view { }
|
|
280
312
|
}
|
|
281
313
|
export declare namespace error {
|
|
314
|
+
namespace entry { }
|
|
282
315
|
namespace view { }
|
|
283
316
|
}
|
|
284
317
|
export declare namespace event {
|
|
@@ -290,6 +323,7 @@ export declare namespace event {
|
|
|
290
323
|
const TYPE_QNAME = "0x1::event::EventHandle";
|
|
291
324
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<EventHandle<T0>>;
|
|
292
325
|
}
|
|
326
|
+
namespace entry { }
|
|
293
327
|
namespace view { }
|
|
294
328
|
}
|
|
295
329
|
export declare namespace stake {
|
|
@@ -539,51 +573,105 @@ export declare namespace stake {
|
|
|
539
573
|
data_decoded: WithdrawStakeEvent;
|
|
540
574
|
type_arguments: [];
|
|
541
575
|
}
|
|
576
|
+
namespace entry {
|
|
577
|
+
function addStake(client: AptosClient, account: AptosAccount, request: {
|
|
578
|
+
type_arguments: [];
|
|
579
|
+
arguments: [bigint];
|
|
580
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
581
|
+
function increaseLockup(client: AptosClient, account: AptosAccount, request: {
|
|
582
|
+
type_arguments: [];
|
|
583
|
+
arguments: [];
|
|
584
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
585
|
+
function initializeStakeOwner(client: AptosClient, account: AptosAccount, request: {
|
|
586
|
+
type_arguments: [];
|
|
587
|
+
arguments: [bigint, Address, Address];
|
|
588
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
589
|
+
function initializeValidator(client: AptosClient, account: AptosAccount, request: {
|
|
590
|
+
type_arguments: [];
|
|
591
|
+
arguments: [string, string, string, string];
|
|
592
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
593
|
+
function joinValidatorSet(client: AptosClient, account: AptosAccount, request: {
|
|
594
|
+
type_arguments: [];
|
|
595
|
+
arguments: [Address];
|
|
596
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
597
|
+
function leaveValidatorSet(client: AptosClient, account: AptosAccount, request: {
|
|
598
|
+
type_arguments: [];
|
|
599
|
+
arguments: [Address];
|
|
600
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
601
|
+
function reactivateStake(client: AptosClient, account: AptosAccount, request: {
|
|
602
|
+
type_arguments: [];
|
|
603
|
+
arguments: [bigint];
|
|
604
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
605
|
+
function rotateConsensusKey(client: AptosClient, account: AptosAccount, request: {
|
|
606
|
+
type_arguments: [];
|
|
607
|
+
arguments: [Address, string, string];
|
|
608
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
609
|
+
function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
|
|
610
|
+
type_arguments: [];
|
|
611
|
+
arguments: [Address];
|
|
612
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
613
|
+
function setOperator(client: AptosClient, account: AptosAccount, request: {
|
|
614
|
+
type_arguments: [];
|
|
615
|
+
arguments: [Address];
|
|
616
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
617
|
+
function unlock(client: AptosClient, account: AptosAccount, request: {
|
|
618
|
+
type_arguments: [];
|
|
619
|
+
arguments: [bigint];
|
|
620
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
621
|
+
function updateNetworkAndFullnodeAddresses(client: AptosClient, account: AptosAccount, request: {
|
|
622
|
+
type_arguments: [];
|
|
623
|
+
arguments: [Address, string, string];
|
|
624
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
625
|
+
function withdraw(client: AptosClient, account: AptosAccount, request: {
|
|
626
|
+
type_arguments: [];
|
|
627
|
+
arguments: [bigint];
|
|
628
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
629
|
+
}
|
|
542
630
|
namespace view {
|
|
543
631
|
function getCurrentEpochProposalCounts(client: AptosClient, request: {
|
|
544
632
|
type_arguments: [];
|
|
545
633
|
arguments: [bigint];
|
|
546
|
-
}, version?: bigint): Promise<
|
|
634
|
+
}, version?: bigint): Promise<[bigint, bigint]>;
|
|
547
635
|
function getCurrentEpochVotingPower(client: AptosClient, request: {
|
|
548
636
|
type_arguments: [];
|
|
549
637
|
arguments: [Address];
|
|
550
|
-
}, version?: bigint): Promise<
|
|
638
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
551
639
|
function getDelegatedVoter(client: AptosClient, request: {
|
|
552
640
|
type_arguments: [];
|
|
553
641
|
arguments: [Address];
|
|
554
|
-
}, version?: bigint): Promise<
|
|
642
|
+
}, version?: bigint): Promise<[Address]>;
|
|
555
643
|
function getLockupSecs(client: AptosClient, request: {
|
|
556
644
|
type_arguments: [];
|
|
557
645
|
arguments: [Address];
|
|
558
|
-
}, version?: bigint): Promise<
|
|
646
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
559
647
|
function getOperator(client: AptosClient, request: {
|
|
560
648
|
type_arguments: [];
|
|
561
649
|
arguments: [Address];
|
|
562
|
-
}, version?: bigint): Promise<
|
|
650
|
+
}, version?: bigint): Promise<[Address]>;
|
|
563
651
|
function getRemainingLockupSecs(client: AptosClient, request: {
|
|
564
652
|
type_arguments: [];
|
|
565
653
|
arguments: [Address];
|
|
566
|
-
}, version?: bigint): Promise<
|
|
654
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
567
655
|
function getStake(client: AptosClient, request: {
|
|
568
656
|
type_arguments: [];
|
|
569
657
|
arguments: [Address];
|
|
570
|
-
}, version?: bigint): Promise<
|
|
658
|
+
}, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
|
|
571
659
|
function getValidatorConfig(client: AptosClient, request: {
|
|
572
660
|
type_arguments: [];
|
|
573
661
|
arguments: [Address];
|
|
574
|
-
}, version?: bigint): Promise<
|
|
662
|
+
}, version?: bigint): Promise<[string, string, string]>;
|
|
575
663
|
function getValidatorIndex(client: AptosClient, request: {
|
|
576
664
|
type_arguments: [];
|
|
577
665
|
arguments: [Address];
|
|
578
|
-
}, version?: bigint): Promise<
|
|
666
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
579
667
|
function getValidatorState(client: AptosClient, request: {
|
|
580
668
|
type_arguments: [];
|
|
581
669
|
arguments: [Address];
|
|
582
|
-
}, version?: bigint): Promise<
|
|
670
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
583
671
|
function stakePoolExists(client: AptosClient, request: {
|
|
584
672
|
type_arguments: [];
|
|
585
673
|
arguments: [Address];
|
|
586
|
-
}, version?: bigint): Promise<
|
|
674
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
587
675
|
}
|
|
588
676
|
}
|
|
589
677
|
export declare namespace table {
|
|
@@ -601,9 +689,11 @@ export declare namespace table {
|
|
|
601
689
|
const TYPE_QNAME = "0x1::table::Table";
|
|
602
690
|
function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Table<T0, T1>>;
|
|
603
691
|
}
|
|
692
|
+
namespace entry { }
|
|
604
693
|
namespace view { }
|
|
605
694
|
}
|
|
606
695
|
export declare namespace math64 {
|
|
696
|
+
namespace entry { }
|
|
607
697
|
namespace view { }
|
|
608
698
|
}
|
|
609
699
|
export declare namespace object_ {
|
|
@@ -688,6 +778,20 @@ export declare namespace object_ {
|
|
|
688
778
|
const TYPE_QNAME = "0x1::object::TransferRef";
|
|
689
779
|
function type(): TypeDescriptor<TransferRef>;
|
|
690
780
|
}
|
|
781
|
+
namespace entry {
|
|
782
|
+
function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
783
|
+
type_arguments: [string];
|
|
784
|
+
arguments: [object_.Object<T0>, Address];
|
|
785
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
786
|
+
function transferCall(client: AptosClient, account: AptosAccount, request: {
|
|
787
|
+
type_arguments: [];
|
|
788
|
+
arguments: [Address, Address];
|
|
789
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
790
|
+
function transferToObject<T0 = any, T1 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
791
|
+
type_arguments: [string, string];
|
|
792
|
+
arguments: [object_.Object<T0>, object_.Object<T1>];
|
|
793
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
794
|
+
}
|
|
691
795
|
namespace view { }
|
|
692
796
|
}
|
|
693
797
|
export declare namespace option {
|
|
@@ -698,9 +802,11 @@ export declare namespace option {
|
|
|
698
802
|
const TYPE_QNAME = "0x1::option::Option";
|
|
699
803
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Option<T0>>;
|
|
700
804
|
}
|
|
805
|
+
namespace entry { }
|
|
701
806
|
namespace view { }
|
|
702
807
|
}
|
|
703
808
|
export declare namespace signer {
|
|
809
|
+
namespace entry { }
|
|
704
810
|
namespace view { }
|
|
705
811
|
}
|
|
706
812
|
export declare namespace string_ {
|
|
@@ -711,9 +817,11 @@ export declare namespace string_ {
|
|
|
711
817
|
const TYPE_QNAME = "0x1::string::String";
|
|
712
818
|
function type(): TypeDescriptor<String>;
|
|
713
819
|
}
|
|
820
|
+
namespace entry { }
|
|
714
821
|
namespace view { }
|
|
715
822
|
}
|
|
716
823
|
export declare namespace vector {
|
|
824
|
+
namespace entry { }
|
|
717
825
|
namespace view { }
|
|
718
826
|
}
|
|
719
827
|
export declare namespace voting {
|
|
@@ -808,51 +916,52 @@ export declare namespace voting {
|
|
|
808
916
|
const TYPE_QNAME = "0x1::voting::VotingForum";
|
|
809
917
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<VotingForum<T0>>;
|
|
810
918
|
}
|
|
919
|
+
namespace entry { }
|
|
811
920
|
namespace view {
|
|
812
921
|
function getEarlyResolutionVoteThreshold<T0 = any>(client: AptosClient, request: {
|
|
813
922
|
type_arguments: [string];
|
|
814
923
|
arguments: [Address, bigint];
|
|
815
|
-
}, version?: bigint): Promise<
|
|
924
|
+
}, version?: bigint): Promise<[option.Option<bigint>]>;
|
|
816
925
|
function getExecutionHash<T0 = any>(client: AptosClient, request: {
|
|
817
926
|
type_arguments: [string];
|
|
818
927
|
arguments: [Address, bigint];
|
|
819
|
-
}, version?: bigint): Promise<
|
|
928
|
+
}, version?: bigint): Promise<[string]>;
|
|
820
929
|
function getMinVoteThreshold<T0 = any>(client: AptosClient, request: {
|
|
821
930
|
type_arguments: [string];
|
|
822
931
|
arguments: [Address, bigint];
|
|
823
|
-
}, version?: bigint): Promise<
|
|
932
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
824
933
|
function getProposalCreationSecs<T0 = any>(client: AptosClient, request: {
|
|
825
934
|
type_arguments: [string];
|
|
826
935
|
arguments: [Address, bigint];
|
|
827
|
-
}, version?: bigint): Promise<
|
|
936
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
828
937
|
function getProposalExpirationSecs<T0 = any>(client: AptosClient, request: {
|
|
829
938
|
type_arguments: [string];
|
|
830
939
|
arguments: [Address, bigint];
|
|
831
|
-
}, version?: bigint): Promise<
|
|
940
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
832
941
|
function getProposalState<T0 = any>(client: AptosClient, request: {
|
|
833
942
|
type_arguments: [string];
|
|
834
943
|
arguments: [Address, bigint];
|
|
835
|
-
}, version?: bigint): Promise<
|
|
944
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
836
945
|
function getVotes<T0 = any>(client: AptosClient, request: {
|
|
837
946
|
type_arguments: [string];
|
|
838
947
|
arguments: [Address, bigint];
|
|
839
|
-
}, version?: bigint): Promise<
|
|
948
|
+
}, version?: bigint): Promise<[bigint, bigint]>;
|
|
840
949
|
function isMultiStepProposalInExecution<T0 = any>(client: AptosClient, request: {
|
|
841
950
|
type_arguments: [string];
|
|
842
951
|
arguments: [Address, bigint];
|
|
843
|
-
}, version?: bigint): Promise<
|
|
952
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
844
953
|
function isResolved<T0 = any>(client: AptosClient, request: {
|
|
845
954
|
type_arguments: [string];
|
|
846
955
|
arguments: [Address, bigint];
|
|
847
|
-
}, version?: bigint): Promise<
|
|
956
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
848
957
|
function isVotingClosed<T0 = any>(client: AptosClient, request: {
|
|
849
958
|
type_arguments: [string];
|
|
850
959
|
arguments: [Address, bigint];
|
|
851
|
-
}, version?: bigint): Promise<
|
|
960
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
852
961
|
function nextProposalId<T0 = any>(client: AptosClient, request: {
|
|
853
962
|
type_arguments: [string];
|
|
854
963
|
arguments: [Address];
|
|
855
|
-
}, version?: bigint): Promise<
|
|
964
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
856
965
|
}
|
|
857
966
|
}
|
|
858
967
|
export declare namespace account {
|
|
@@ -965,31 +1074,65 @@ export declare namespace account {
|
|
|
965
1074
|
const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
|
|
966
1075
|
function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2>;
|
|
967
1076
|
}
|
|
1077
|
+
namespace entry {
|
|
1078
|
+
function offerRotationCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1079
|
+
type_arguments: [];
|
|
1080
|
+
arguments: [string, number, string, Address];
|
|
1081
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1082
|
+
function offerSignerCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1083
|
+
type_arguments: [];
|
|
1084
|
+
arguments: [string, number, string, Address];
|
|
1085
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1086
|
+
function revokeAnyRotationCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1087
|
+
type_arguments: [];
|
|
1088
|
+
arguments: [];
|
|
1089
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1090
|
+
function revokeAnySignerCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1091
|
+
type_arguments: [];
|
|
1092
|
+
arguments: [];
|
|
1093
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1094
|
+
function revokeRotationCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1095
|
+
type_arguments: [];
|
|
1096
|
+
arguments: [Address];
|
|
1097
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1098
|
+
function revokeSignerCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1099
|
+
type_arguments: [];
|
|
1100
|
+
arguments: [Address];
|
|
1101
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1102
|
+
function rotateAuthenticationKey(client: AptosClient, account: AptosAccount, request: {
|
|
1103
|
+
type_arguments: [];
|
|
1104
|
+
arguments: [number, string, number, string, string, string];
|
|
1105
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1106
|
+
function rotateAuthenticationKeyWithRotationCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1107
|
+
type_arguments: [];
|
|
1108
|
+
arguments: [Address, number, string, string];
|
|
1109
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1110
|
+
}
|
|
968
1111
|
namespace view {
|
|
969
1112
|
function existsAt(client: AptosClient, request: {
|
|
970
1113
|
type_arguments: [];
|
|
971
1114
|
arguments: [Address];
|
|
972
|
-
}, version?: bigint): Promise<
|
|
1115
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
973
1116
|
function getAuthenticationKey(client: AptosClient, request: {
|
|
974
1117
|
type_arguments: [];
|
|
975
1118
|
arguments: [Address];
|
|
976
|
-
}, version?: bigint): Promise<
|
|
1119
|
+
}, version?: bigint): Promise<[string]>;
|
|
977
1120
|
function getGuidNextCreationNum(client: AptosClient, request: {
|
|
978
1121
|
type_arguments: [];
|
|
979
1122
|
arguments: [Address];
|
|
980
|
-
}, version?: bigint): Promise<
|
|
1123
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
981
1124
|
function getSequenceNumber(client: AptosClient, request: {
|
|
982
1125
|
type_arguments: [];
|
|
983
1126
|
arguments: [Address];
|
|
984
|
-
}, version?: bigint): Promise<
|
|
1127
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
985
1128
|
function getSignerCapabilityOfferFor(client: AptosClient, request: {
|
|
986
1129
|
type_arguments: [];
|
|
987
1130
|
arguments: [Address];
|
|
988
|
-
}, version?: bigint): Promise<
|
|
1131
|
+
}, version?: bigint): Promise<[Address]>;
|
|
989
1132
|
function isSignerCapabilityOffered(client: AptosClient, request: {
|
|
990
1133
|
type_arguments: [];
|
|
991
1134
|
arguments: [Address];
|
|
992
|
-
}, version?: bigint): Promise<
|
|
1135
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
993
1136
|
}
|
|
994
1137
|
}
|
|
995
1138
|
export declare namespace ed25519 {
|
|
@@ -1022,6 +1165,7 @@ export declare namespace ed25519 {
|
|
|
1022
1165
|
const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
|
|
1023
1166
|
function type(): TypeDescriptor<ValidatedPublicKey>;
|
|
1024
1167
|
}
|
|
1168
|
+
namespace entry { }
|
|
1025
1169
|
namespace view { }
|
|
1026
1170
|
}
|
|
1027
1171
|
export declare namespace genesis {
|
|
@@ -1067,9 +1211,11 @@ export declare namespace genesis {
|
|
|
1067
1211
|
const TYPE_QNAME = "0x1::genesis::ValidatorConfigurationWithCommission";
|
|
1068
1212
|
function type(): TypeDescriptor<ValidatorConfigurationWithCommission>;
|
|
1069
1213
|
}
|
|
1214
|
+
namespace entry { }
|
|
1070
1215
|
namespace view { }
|
|
1071
1216
|
}
|
|
1072
1217
|
export declare namespace math128 {
|
|
1218
|
+
namespace entry { }
|
|
1073
1219
|
namespace view { }
|
|
1074
1220
|
}
|
|
1075
1221
|
export declare namespace version {
|
|
@@ -1087,6 +1233,12 @@ export declare namespace version {
|
|
|
1087
1233
|
const TYPE_QNAME = "0x1::version::Version";
|
|
1088
1234
|
function type(): TypeDescriptor<Version>;
|
|
1089
1235
|
}
|
|
1236
|
+
namespace entry {
|
|
1237
|
+
function setVersion(client: AptosClient, account: AptosAccount, request: {
|
|
1238
|
+
type_arguments: [];
|
|
1239
|
+
arguments: [bigint];
|
|
1240
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1241
|
+
}
|
|
1090
1242
|
namespace view { }
|
|
1091
1243
|
}
|
|
1092
1244
|
export declare namespace vesting {
|
|
@@ -1294,63 +1446,129 @@ export declare namespace vesting {
|
|
|
1294
1446
|
const TYPE_QNAME = "0x1::vesting::VestingSchedule";
|
|
1295
1447
|
function type(): TypeDescriptor<VestingSchedule>;
|
|
1296
1448
|
}
|
|
1449
|
+
namespace entry {
|
|
1450
|
+
function adminWithdraw(client: AptosClient, account: AptosAccount, request: {
|
|
1451
|
+
type_arguments: [];
|
|
1452
|
+
arguments: [Address];
|
|
1453
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1454
|
+
function distribute(client: AptosClient, account: AptosAccount, request: {
|
|
1455
|
+
type_arguments: [];
|
|
1456
|
+
arguments: [Address];
|
|
1457
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1458
|
+
function distributeMany(client: AptosClient, account: AptosAccount, request: {
|
|
1459
|
+
type_arguments: [];
|
|
1460
|
+
arguments: [Address[]];
|
|
1461
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1462
|
+
function resetBeneficiary(client: AptosClient, account: AptosAccount, request: {
|
|
1463
|
+
type_arguments: [];
|
|
1464
|
+
arguments: [Address, Address];
|
|
1465
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1466
|
+
function resetLockup(client: AptosClient, account: AptosAccount, request: {
|
|
1467
|
+
type_arguments: [];
|
|
1468
|
+
arguments: [Address];
|
|
1469
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1470
|
+
function setBeneficiary(client: AptosClient, account: AptosAccount, request: {
|
|
1471
|
+
type_arguments: [];
|
|
1472
|
+
arguments: [Address, Address, Address];
|
|
1473
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1474
|
+
function setBeneficiaryResetter(client: AptosClient, account: AptosAccount, request: {
|
|
1475
|
+
type_arguments: [];
|
|
1476
|
+
arguments: [Address, Address];
|
|
1477
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1478
|
+
function setManagementRole(client: AptosClient, account: AptosAccount, request: {
|
|
1479
|
+
type_arguments: [];
|
|
1480
|
+
arguments: [Address, string, Address];
|
|
1481
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1482
|
+
function terminateVestingContract(client: AptosClient, account: AptosAccount, request: {
|
|
1483
|
+
type_arguments: [];
|
|
1484
|
+
arguments: [Address];
|
|
1485
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1486
|
+
function unlockRewards(client: AptosClient, account: AptosAccount, request: {
|
|
1487
|
+
type_arguments: [];
|
|
1488
|
+
arguments: [Address];
|
|
1489
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1490
|
+
function unlockRewardsMany(client: AptosClient, account: AptosAccount, request: {
|
|
1491
|
+
type_arguments: [];
|
|
1492
|
+
arguments: [Address[]];
|
|
1493
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1494
|
+
function updateOperator(client: AptosClient, account: AptosAccount, request: {
|
|
1495
|
+
type_arguments: [];
|
|
1496
|
+
arguments: [Address, Address, bigint];
|
|
1497
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1498
|
+
function updateOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
|
|
1499
|
+
type_arguments: [];
|
|
1500
|
+
arguments: [Address, Address];
|
|
1501
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1502
|
+
function updateVoter(client: AptosClient, account: AptosAccount, request: {
|
|
1503
|
+
type_arguments: [];
|
|
1504
|
+
arguments: [Address, Address];
|
|
1505
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1506
|
+
function vest(client: AptosClient, account: AptosAccount, request: {
|
|
1507
|
+
type_arguments: [];
|
|
1508
|
+
arguments: [Address];
|
|
1509
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1510
|
+
function vestMany(client: AptosClient, account: AptosAccount, request: {
|
|
1511
|
+
type_arguments: [];
|
|
1512
|
+
arguments: [Address[]];
|
|
1513
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1514
|
+
}
|
|
1297
1515
|
namespace view {
|
|
1298
1516
|
function accumulatedRewards(client: AptosClient, request: {
|
|
1299
1517
|
type_arguments: [];
|
|
1300
1518
|
arguments: [Address, Address];
|
|
1301
|
-
}, version?: bigint): Promise<
|
|
1519
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1302
1520
|
function beneficiary(client: AptosClient, request: {
|
|
1303
1521
|
type_arguments: [];
|
|
1304
1522
|
arguments: [Address, Address];
|
|
1305
|
-
}, version?: bigint): Promise<
|
|
1523
|
+
}, version?: bigint): Promise<[Address]>;
|
|
1306
1524
|
function operator(client: AptosClient, request: {
|
|
1307
1525
|
type_arguments: [];
|
|
1308
1526
|
arguments: [Address];
|
|
1309
|
-
}, version?: bigint): Promise<
|
|
1527
|
+
}, version?: bigint): Promise<[Address]>;
|
|
1310
1528
|
function operatorCommissionPercentage(client: AptosClient, request: {
|
|
1311
1529
|
type_arguments: [];
|
|
1312
1530
|
arguments: [Address];
|
|
1313
|
-
}, version?: bigint): Promise<
|
|
1531
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1314
1532
|
function periodDurationSecs(client: AptosClient, request: {
|
|
1315
1533
|
type_arguments: [];
|
|
1316
1534
|
arguments: [Address];
|
|
1317
|
-
}, version?: bigint): Promise<
|
|
1535
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1318
1536
|
function remainingGrant(client: AptosClient, request: {
|
|
1319
1537
|
type_arguments: [];
|
|
1320
1538
|
arguments: [Address];
|
|
1321
|
-
}, version?: bigint): Promise<
|
|
1539
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1322
1540
|
function shareholder(client: AptosClient, request: {
|
|
1323
1541
|
type_arguments: [];
|
|
1324
1542
|
arguments: [Address, Address];
|
|
1325
|
-
}, version?: bigint): Promise<
|
|
1543
|
+
}, version?: bigint): Promise<[Address]>;
|
|
1326
1544
|
function shareholders(client: AptosClient, request: {
|
|
1327
1545
|
type_arguments: [];
|
|
1328
1546
|
arguments: [Address];
|
|
1329
|
-
}, version?: bigint): Promise<
|
|
1547
|
+
}, version?: bigint): Promise<[Address[]]>;
|
|
1330
1548
|
function stakePoolAddress(client: AptosClient, request: {
|
|
1331
1549
|
type_arguments: [];
|
|
1332
1550
|
arguments: [Address];
|
|
1333
|
-
}, version?: bigint): Promise<
|
|
1551
|
+
}, version?: bigint): Promise<[Address]>;
|
|
1334
1552
|
function totalAccumulatedRewards(client: AptosClient, request: {
|
|
1335
1553
|
type_arguments: [];
|
|
1336
1554
|
arguments: [Address];
|
|
1337
|
-
}, version?: bigint): Promise<
|
|
1555
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1338
1556
|
function vestingContracts(client: AptosClient, request: {
|
|
1339
1557
|
type_arguments: [];
|
|
1340
1558
|
arguments: [Address];
|
|
1341
|
-
}, version?: bigint): Promise<
|
|
1559
|
+
}, version?: bigint): Promise<[Address[]]>;
|
|
1342
1560
|
function vestingSchedule(client: AptosClient, request: {
|
|
1343
1561
|
type_arguments: [];
|
|
1344
1562
|
arguments: [Address];
|
|
1345
|
-
}, version?: bigint): Promise<
|
|
1563
|
+
}, version?: bigint): Promise<[vesting.VestingSchedule]>;
|
|
1346
1564
|
function vestingStartSecs(client: AptosClient, request: {
|
|
1347
1565
|
type_arguments: [];
|
|
1348
1566
|
arguments: [Address];
|
|
1349
|
-
}, version?: bigint): Promise<
|
|
1567
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1350
1568
|
function voter(client: AptosClient, request: {
|
|
1351
1569
|
type_arguments: [];
|
|
1352
1570
|
arguments: [Address];
|
|
1353
|
-
}, version?: bigint): Promise<
|
|
1571
|
+
}, version?: bigint): Promise<[Address]>;
|
|
1354
1572
|
}
|
|
1355
1573
|
}
|
|
1356
1574
|
export declare namespace bls12381 {
|
|
@@ -1396,6 +1614,7 @@ export declare namespace bls12381 {
|
|
|
1396
1614
|
const TYPE_QNAME = "0x1::bls12381::Signature";
|
|
1397
1615
|
function type(): TypeDescriptor<Signature>;
|
|
1398
1616
|
}
|
|
1617
|
+
namespace entry { }
|
|
1399
1618
|
namespace view { }
|
|
1400
1619
|
}
|
|
1401
1620
|
export declare namespace chain_id {
|
|
@@ -1406,11 +1625,12 @@ export declare namespace chain_id {
|
|
|
1406
1625
|
const TYPE_QNAME = "0x1::chain_id::ChainId";
|
|
1407
1626
|
function type(): TypeDescriptor<ChainId>;
|
|
1408
1627
|
}
|
|
1628
|
+
namespace entry { }
|
|
1409
1629
|
namespace view {
|
|
1410
1630
|
function get(client: AptosClient, request: {
|
|
1411
1631
|
type_arguments: [];
|
|
1412
1632
|
arguments: [];
|
|
1413
|
-
}, version?: bigint): Promise<
|
|
1633
|
+
}, version?: bigint): Promise<[number]>;
|
|
1414
1634
|
}
|
|
1415
1635
|
}
|
|
1416
1636
|
export declare namespace features {
|
|
@@ -1421,9 +1641,11 @@ export declare namespace features {
|
|
|
1421
1641
|
const TYPE_QNAME = "0x1::features::Features";
|
|
1422
1642
|
function type(): TypeDescriptor<Features>;
|
|
1423
1643
|
}
|
|
1644
|
+
namespace entry { }
|
|
1424
1645
|
namespace view { }
|
|
1425
1646
|
}
|
|
1426
1647
|
export declare namespace from_bcs {
|
|
1648
|
+
namespace entry { }
|
|
1427
1649
|
namespace view { }
|
|
1428
1650
|
}
|
|
1429
1651
|
export declare namespace pool_u64 {
|
|
@@ -1439,6 +1661,7 @@ export declare namespace pool_u64 {
|
|
|
1439
1661
|
const TYPE_QNAME = "0x1::pool_u64::Pool";
|
|
1440
1662
|
function type(): TypeDescriptor<Pool>;
|
|
1441
1663
|
}
|
|
1664
|
+
namespace entry { }
|
|
1442
1665
|
namespace view { }
|
|
1443
1666
|
}
|
|
1444
1667
|
export declare namespace secp256k1 {
|
|
@@ -1456,6 +1679,7 @@ export declare namespace secp256k1 {
|
|
|
1456
1679
|
const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
|
|
1457
1680
|
function type(): TypeDescriptor<ECDSASignature>;
|
|
1458
1681
|
}
|
|
1682
|
+
namespace entry { }
|
|
1459
1683
|
namespace view { }
|
|
1460
1684
|
}
|
|
1461
1685
|
export declare namespace timestamp {
|
|
@@ -1466,15 +1690,16 @@ export declare namespace timestamp {
|
|
|
1466
1690
|
const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
|
|
1467
1691
|
function type(): TypeDescriptor<CurrentTimeMicroseconds>;
|
|
1468
1692
|
}
|
|
1693
|
+
namespace entry { }
|
|
1469
1694
|
namespace view {
|
|
1470
1695
|
function nowMicroseconds(client: AptosClient, request: {
|
|
1471
1696
|
type_arguments: [];
|
|
1472
1697
|
arguments: [];
|
|
1473
|
-
}, version?: bigint): Promise<
|
|
1698
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1474
1699
|
function nowSeconds(client: AptosClient, request: {
|
|
1475
1700
|
type_arguments: [];
|
|
1476
1701
|
arguments: [];
|
|
1477
|
-
}, version?: bigint): Promise<
|
|
1702
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
1478
1703
|
}
|
|
1479
1704
|
}
|
|
1480
1705
|
export declare namespace type_info {
|
|
@@ -1487,6 +1712,7 @@ export declare namespace type_info {
|
|
|
1487
1712
|
const TYPE_QNAME = "0x1::type_info::TypeInfo";
|
|
1488
1713
|
function type(): TypeDescriptor<TypeInfo>;
|
|
1489
1714
|
}
|
|
1715
|
+
namespace entry { }
|
|
1490
1716
|
namespace view { }
|
|
1491
1717
|
}
|
|
1492
1718
|
export declare namespace aggregator {
|
|
@@ -1499,6 +1725,7 @@ export declare namespace aggregator {
|
|
|
1499
1725
|
const TYPE_QNAME = "0x1::aggregator::Aggregator";
|
|
1500
1726
|
function type(): TypeDescriptor<Aggregator>;
|
|
1501
1727
|
}
|
|
1728
|
+
namespace entry { }
|
|
1502
1729
|
namespace view { }
|
|
1503
1730
|
}
|
|
1504
1731
|
export declare namespace aptos_coin {
|
|
@@ -1530,9 +1757,24 @@ export declare namespace aptos_coin {
|
|
|
1530
1757
|
const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
|
|
1531
1758
|
function type(): TypeDescriptor<MintCapStore>;
|
|
1532
1759
|
}
|
|
1760
|
+
namespace entry {
|
|
1761
|
+
function claimMintCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1762
|
+
type_arguments: [];
|
|
1763
|
+
arguments: [];
|
|
1764
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1765
|
+
function delegateMintCapability(client: AptosClient, account: AptosAccount, request: {
|
|
1766
|
+
type_arguments: [];
|
|
1767
|
+
arguments: [Address, Address];
|
|
1768
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1769
|
+
function mint(client: AptosClient, account: AptosAccount, request: {
|
|
1770
|
+
type_arguments: [];
|
|
1771
|
+
arguments: [Address, bigint];
|
|
1772
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
1773
|
+
}
|
|
1533
1774
|
namespace view { }
|
|
1534
1775
|
}
|
|
1535
1776
|
export declare namespace aptos_hash {
|
|
1777
|
+
namespace entry { }
|
|
1536
1778
|
namespace view { }
|
|
1537
1779
|
}
|
|
1538
1780
|
export declare namespace big_vector {
|
|
@@ -1545,6 +1787,7 @@ export declare namespace big_vector {
|
|
|
1545
1787
|
const TYPE_QNAME = "0x1::big_vector::BigVector";
|
|
1546
1788
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BigVector<T0>>;
|
|
1547
1789
|
}
|
|
1790
|
+
namespace entry { }
|
|
1548
1791
|
namespace view { }
|
|
1549
1792
|
}
|
|
1550
1793
|
export declare namespace bit_vector {
|
|
@@ -1556,6 +1799,7 @@ export declare namespace bit_vector {
|
|
|
1556
1799
|
const TYPE_QNAME = "0x1::bit_vector::BitVector";
|
|
1557
1800
|
function type(): TypeDescriptor<BitVector>;
|
|
1558
1801
|
}
|
|
1802
|
+
namespace entry { }
|
|
1559
1803
|
namespace view { }
|
|
1560
1804
|
}
|
|
1561
1805
|
export declare namespace capability {
|
|
@@ -1587,6 +1831,7 @@ export declare namespace capability {
|
|
|
1587
1831
|
const TYPE_QNAME = "0x1::capability::LinearCap";
|
|
1588
1832
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<LinearCap<T0>>;
|
|
1589
1833
|
}
|
|
1834
|
+
namespace entry { }
|
|
1590
1835
|
namespace view { }
|
|
1591
1836
|
}
|
|
1592
1837
|
export declare namespace comparator {
|
|
@@ -1597,9 +1842,11 @@ export declare namespace comparator {
|
|
|
1597
1842
|
const TYPE_QNAME = "0x1::comparator::Result";
|
|
1598
1843
|
function type(): TypeDescriptor<Result>;
|
|
1599
1844
|
}
|
|
1845
|
+
namespace entry { }
|
|
1600
1846
|
namespace view { }
|
|
1601
1847
|
}
|
|
1602
1848
|
export declare namespace math_fixed {
|
|
1849
|
+
namespace entry { }
|
|
1603
1850
|
namespace view { }
|
|
1604
1851
|
}
|
|
1605
1852
|
export declare namespace simple_map {
|
|
@@ -1618,6 +1865,7 @@ export declare namespace simple_map {
|
|
|
1618
1865
|
const TYPE_QNAME = "0x1::simple_map::SimpleMap";
|
|
1619
1866
|
function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SimpleMap<T0, T1>>;
|
|
1620
1867
|
}
|
|
1868
|
+
namespace entry { }
|
|
1621
1869
|
namespace view { }
|
|
1622
1870
|
}
|
|
1623
1871
|
export declare namespace smart_table {
|
|
@@ -1642,6 +1890,7 @@ export declare namespace smart_table {
|
|
|
1642
1890
|
const TYPE_QNAME = "0x1::smart_table::SmartTable";
|
|
1643
1891
|
function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SmartTable<T0, T1>>;
|
|
1644
1892
|
}
|
|
1893
|
+
namespace entry { }
|
|
1645
1894
|
namespace view { }
|
|
1646
1895
|
}
|
|
1647
1896
|
export declare namespace storage_gas {
|
|
@@ -1692,6 +1941,7 @@ export declare namespace storage_gas {
|
|
|
1692
1941
|
const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
|
|
1693
1942
|
function type(): TypeDescriptor<UsageGasConfig>;
|
|
1694
1943
|
}
|
|
1944
|
+
namespace entry { }
|
|
1695
1945
|
namespace view { }
|
|
1696
1946
|
}
|
|
1697
1947
|
export declare namespace chain_status {
|
|
@@ -1702,15 +1952,16 @@ export declare namespace chain_status {
|
|
|
1702
1952
|
const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
|
|
1703
1953
|
function type(): TypeDescriptor<GenesisEndMarker>;
|
|
1704
1954
|
}
|
|
1955
|
+
namespace entry { }
|
|
1705
1956
|
namespace view {
|
|
1706
1957
|
function isGenesis(client: AptosClient, request: {
|
|
1707
1958
|
type_arguments: [];
|
|
1708
1959
|
arguments: [];
|
|
1709
|
-
}, version?: bigint): Promise<
|
|
1960
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
1710
1961
|
function isOperating(client: AptosClient, request: {
|
|
1711
1962
|
type_arguments: [];
|
|
1712
1963
|
arguments: [];
|
|
1713
|
-
}, version?: bigint): Promise<
|
|
1964
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
1714
1965
|
}
|
|
1715
1966
|
}
|
|
1716
1967
|
export declare namespace copyable_any {
|
|
@@ -1722,6 +1973,7 @@ export declare namespace copyable_any {
|
|
|
1722
1973
|
const TYPE_QNAME = "0x1::copyable_any::Any";
|
|
1723
1974
|
function type(): TypeDescriptor<Any>;
|
|
1724
1975
|
}
|
|
1976
|
+
namespace entry { }
|
|
1725
1977
|
namespace view { }
|
|
1726
1978
|
}
|
|
1727
1979
|
export declare namespace gas_schedule {
|
|
@@ -1748,6 +2000,7 @@ export declare namespace gas_schedule {
|
|
|
1748
2000
|
const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
|
|
1749
2001
|
function type(): TypeDescriptor<GasScheduleV2>;
|
|
1750
2002
|
}
|
|
2003
|
+
namespace entry { }
|
|
1751
2004
|
namespace view { }
|
|
1752
2005
|
}
|
|
1753
2006
|
export declare namespace managed_coin {
|
|
@@ -1760,9 +2013,28 @@ export declare namespace managed_coin {
|
|
|
1760
2013
|
const TYPE_QNAME = "0x1::managed_coin::Capabilities";
|
|
1761
2014
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Capabilities<T0>>;
|
|
1762
2015
|
}
|
|
2016
|
+
namespace entry {
|
|
2017
|
+
function burn<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
2018
|
+
type_arguments: [string];
|
|
2019
|
+
arguments: [bigint];
|
|
2020
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2021
|
+
function initialize<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
2022
|
+
type_arguments: [string];
|
|
2023
|
+
arguments: [string, string, number, Boolean];
|
|
2024
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2025
|
+
function mint<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
2026
|
+
type_arguments: [string];
|
|
2027
|
+
arguments: [Address, bigint];
|
|
2028
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2029
|
+
function register<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
2030
|
+
type_arguments: [string];
|
|
2031
|
+
arguments: [];
|
|
2032
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2033
|
+
}
|
|
1763
2034
|
namespace view { }
|
|
1764
2035
|
}
|
|
1765
2036
|
export declare namespace math_fixed64 {
|
|
2037
|
+
namespace entry { }
|
|
1766
2038
|
namespace view { }
|
|
1767
2039
|
}
|
|
1768
2040
|
export declare namespace ristretto255 {
|
|
@@ -1787,6 +2059,7 @@ export declare namespace ristretto255 {
|
|
|
1787
2059
|
const TYPE_QNAME = "0x1::ristretto255::Scalar";
|
|
1788
2060
|
function type(): TypeDescriptor<Scalar>;
|
|
1789
2061
|
}
|
|
2062
|
+
namespace entry { }
|
|
1790
2063
|
namespace view { }
|
|
1791
2064
|
}
|
|
1792
2065
|
export declare namespace smart_vector {
|
|
@@ -1800,6 +2073,7 @@ export declare namespace smart_vector {
|
|
|
1800
2073
|
const TYPE_QNAME = "0x1::smart_vector::SmartVector";
|
|
1801
2074
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SmartVector<T0>>;
|
|
1802
2075
|
}
|
|
2076
|
+
namespace entry { }
|
|
1803
2077
|
namespace view { }
|
|
1804
2078
|
}
|
|
1805
2079
|
export declare namespace string_utils {
|
|
@@ -1826,6 +2100,7 @@ export declare namespace string_utils {
|
|
|
1826
2100
|
const TYPE_QNAME = "0x1::string_utils::NIL";
|
|
1827
2101
|
function type(): TypeDescriptor<NIL>;
|
|
1828
2102
|
}
|
|
2103
|
+
namespace entry { }
|
|
1829
2104
|
namespace view { }
|
|
1830
2105
|
}
|
|
1831
2106
|
export declare namespace aptos_account {
|
|
@@ -1848,14 +2123,41 @@ export declare namespace aptos_account {
|
|
|
1848
2123
|
const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
|
|
1849
2124
|
function type(): TypeDescriptor<DirectTransferConfig>;
|
|
1850
2125
|
}
|
|
2126
|
+
namespace entry {
|
|
2127
|
+
function batchTransfer(client: AptosClient, account: AptosAccount, request: {
|
|
2128
|
+
type_arguments: [];
|
|
2129
|
+
arguments: [Address[], bigint[]];
|
|
2130
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2131
|
+
function batchTransferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
2132
|
+
type_arguments: [string];
|
|
2133
|
+
arguments: [Address[], bigint[]];
|
|
2134
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2135
|
+
function createAccount(client: AptosClient, account: AptosAccount, request: {
|
|
2136
|
+
type_arguments: [];
|
|
2137
|
+
arguments: [Address];
|
|
2138
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2139
|
+
function setAllowDirectCoinTransfers(client: AptosClient, account: AptosAccount, request: {
|
|
2140
|
+
type_arguments: [];
|
|
2141
|
+
arguments: [Boolean];
|
|
2142
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2143
|
+
function transfer(client: AptosClient, account: AptosAccount, request: {
|
|
2144
|
+
type_arguments: [];
|
|
2145
|
+
arguments: [Address, bigint];
|
|
2146
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2147
|
+
function transferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
2148
|
+
type_arguments: [string];
|
|
2149
|
+
arguments: [Address, bigint];
|
|
2150
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2151
|
+
}
|
|
1851
2152
|
namespace view {
|
|
1852
2153
|
function canReceiveDirectCoinTransfers(client: AptosClient, request: {
|
|
1853
2154
|
type_arguments: [];
|
|
1854
2155
|
arguments: [Address];
|
|
1855
|
-
}, version?: bigint): Promise<
|
|
2156
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
1856
2157
|
}
|
|
1857
2158
|
}
|
|
1858
2159
|
export declare namespace create_signer {
|
|
2160
|
+
namespace entry { }
|
|
1859
2161
|
namespace view { }
|
|
1860
2162
|
}
|
|
1861
2163
|
export declare namespace fixed_point32 {
|
|
@@ -1866,6 +2168,7 @@ export declare namespace fixed_point32 {
|
|
|
1866
2168
|
const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
|
|
1867
2169
|
function type(): TypeDescriptor<FixedPoint32>;
|
|
1868
2170
|
}
|
|
2171
|
+
namespace entry { }
|
|
1869
2172
|
namespace view { }
|
|
1870
2173
|
}
|
|
1871
2174
|
export declare namespace fixed_point64 {
|
|
@@ -1876,6 +2179,7 @@ export declare namespace fixed_point64 {
|
|
|
1876
2179
|
const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";
|
|
1877
2180
|
function type(): TypeDescriptor<FixedPoint64>;
|
|
1878
2181
|
}
|
|
2182
|
+
namespace entry { }
|
|
1879
2183
|
namespace view { }
|
|
1880
2184
|
}
|
|
1881
2185
|
export declare namespace multi_ed25519 {
|
|
@@ -1900,9 +2204,44 @@ export declare namespace multi_ed25519 {
|
|
|
1900
2204
|
const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
|
|
1901
2205
|
function type(): TypeDescriptor<ValidatedPublicKey>;
|
|
1902
2206
|
}
|
|
2207
|
+
namespace entry { }
|
|
1903
2208
|
namespace view { }
|
|
1904
2209
|
}
|
|
1905
2210
|
export declare namespace staking_proxy {
|
|
2211
|
+
namespace entry {
|
|
2212
|
+
function setOperator(client: AptosClient, account: AptosAccount, request: {
|
|
2213
|
+
type_arguments: [];
|
|
2214
|
+
arguments: [Address, Address];
|
|
2215
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2216
|
+
function setStakePoolOperator(client: AptosClient, account: AptosAccount, request: {
|
|
2217
|
+
type_arguments: [];
|
|
2218
|
+
arguments: [Address];
|
|
2219
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2220
|
+
function setStakePoolVoter(client: AptosClient, account: AptosAccount, request: {
|
|
2221
|
+
type_arguments: [];
|
|
2222
|
+
arguments: [Address];
|
|
2223
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2224
|
+
function setStakingContractOperator(client: AptosClient, account: AptosAccount, request: {
|
|
2225
|
+
type_arguments: [];
|
|
2226
|
+
arguments: [Address, Address];
|
|
2227
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2228
|
+
function setStakingContractVoter(client: AptosClient, account: AptosAccount, request: {
|
|
2229
|
+
type_arguments: [];
|
|
2230
|
+
arguments: [Address, Address];
|
|
2231
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2232
|
+
function setVestingContractOperator(client: AptosClient, account: AptosAccount, request: {
|
|
2233
|
+
type_arguments: [];
|
|
2234
|
+
arguments: [Address, Address];
|
|
2235
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2236
|
+
function setVestingContractVoter(client: AptosClient, account: AptosAccount, request: {
|
|
2237
|
+
type_arguments: [];
|
|
2238
|
+
arguments: [Address, Address];
|
|
2239
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2240
|
+
function setVoter(client: AptosClient, account: AptosAccount, request: {
|
|
2241
|
+
type_arguments: [];
|
|
2242
|
+
arguments: [Address, Address];
|
|
2243
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2244
|
+
}
|
|
1906
2245
|
namespace view { }
|
|
1907
2246
|
}
|
|
1908
2247
|
export declare namespace state_storage {
|
|
@@ -1929,6 +2268,7 @@ export declare namespace state_storage {
|
|
|
1929
2268
|
const TYPE_QNAME = "0x1::state_storage::Usage";
|
|
1930
2269
|
function type(): TypeDescriptor<Usage>;
|
|
1931
2270
|
}
|
|
2271
|
+
namespace entry { }
|
|
1932
2272
|
namespace view { }
|
|
1933
2273
|
}
|
|
1934
2274
|
export declare namespace crypto_algebra {
|
|
@@ -1939,6 +2279,7 @@ export declare namespace crypto_algebra {
|
|
|
1939
2279
|
const TYPE_QNAME = "0x1::crypto_algebra::Element";
|
|
1940
2280
|
function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Element<T0>>;
|
|
1941
2281
|
}
|
|
2282
|
+
namespace entry { }
|
|
1942
2283
|
namespace view { }
|
|
1943
2284
|
}
|
|
1944
2285
|
export declare namespace fungible_asset {
|
|
@@ -2041,43 +2382,49 @@ export declare namespace fungible_asset {
|
|
|
2041
2382
|
data_decoded: WithdrawEvent;
|
|
2042
2383
|
type_arguments: [];
|
|
2043
2384
|
}
|
|
2385
|
+
namespace entry {
|
|
2386
|
+
function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
2387
|
+
type_arguments: [string];
|
|
2388
|
+
arguments: [object_.Object<T0>, object_.Object<T0>, bigint];
|
|
2389
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2390
|
+
}
|
|
2044
2391
|
namespace view {
|
|
2045
2392
|
function balance<T0 = any>(client: AptosClient, request: {
|
|
2046
2393
|
type_arguments: [string];
|
|
2047
2394
|
arguments: [object_.Object<T0>];
|
|
2048
|
-
}, version?: bigint): Promise<
|
|
2395
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2049
2396
|
function decimals<T0 = any>(client: AptosClient, request: {
|
|
2050
2397
|
type_arguments: [string];
|
|
2051
2398
|
arguments: [object_.Object<T0>];
|
|
2052
|
-
}, version?: bigint): Promise<
|
|
2399
|
+
}, version?: bigint): Promise<[number]>;
|
|
2053
2400
|
function isFrozen<T0 = any>(client: AptosClient, request: {
|
|
2054
2401
|
type_arguments: [string];
|
|
2055
2402
|
arguments: [object_.Object<T0>];
|
|
2056
|
-
}, version?: bigint): Promise<
|
|
2403
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2057
2404
|
function maximum<T0 = any>(client: AptosClient, request: {
|
|
2058
2405
|
type_arguments: [string];
|
|
2059
2406
|
arguments: [object_.Object<T0>];
|
|
2060
|
-
}, version?: bigint): Promise<
|
|
2407
|
+
}, version?: bigint): Promise<[option.Option<bigint>]>;
|
|
2061
2408
|
function name<T0 = any>(client: AptosClient, request: {
|
|
2062
2409
|
type_arguments: [string];
|
|
2063
2410
|
arguments: [object_.Object<T0>];
|
|
2064
|
-
}, version?: bigint): Promise<
|
|
2411
|
+
}, version?: bigint): Promise<[string]>;
|
|
2065
2412
|
function storeExists(client: AptosClient, request: {
|
|
2066
2413
|
type_arguments: [];
|
|
2067
2414
|
arguments: [Address];
|
|
2068
|
-
}, version?: bigint): Promise<
|
|
2415
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2069
2416
|
function storeMetadata<T0 = any>(client: AptosClient, request: {
|
|
2070
2417
|
type_arguments: [string];
|
|
2071
2418
|
arguments: [object_.Object<T0>];
|
|
2072
|
-
}, version?: bigint): Promise<
|
|
2419
|
+
}, version?: bigint): Promise<[object_.Object<fungible_asset.Metadata>]>;
|
|
2073
2420
|
function supply<T0 = any>(client: AptosClient, request: {
|
|
2074
2421
|
type_arguments: [string];
|
|
2075
2422
|
arguments: [object_.Object<T0>];
|
|
2076
|
-
}, version?: bigint): Promise<
|
|
2423
|
+
}, version?: bigint): Promise<[option.Option<bigint>]>;
|
|
2077
2424
|
function symbol<T0 = any>(client: AptosClient, request: {
|
|
2078
2425
|
type_arguments: [string];
|
|
2079
2426
|
arguments: [object_.Object<T0>];
|
|
2080
|
-
}, version?: bigint): Promise<
|
|
2427
|
+
}, version?: bigint): Promise<[string]>;
|
|
2081
2428
|
}
|
|
2082
2429
|
}
|
|
2083
2430
|
export declare namespace staking_config {
|
|
@@ -2105,6 +2452,7 @@ export declare namespace staking_config {
|
|
|
2105
2452
|
const TYPE_QNAME = "0x1::staking_config::StakingRewardsConfig";
|
|
2106
2453
|
function type(): TypeDescriptor<StakingRewardsConfig>;
|
|
2107
2454
|
}
|
|
2455
|
+
namespace entry { }
|
|
2108
2456
|
namespace view { }
|
|
2109
2457
|
}
|
|
2110
2458
|
export declare namespace delegation_pool {
|
|
@@ -2207,51 +2555,85 @@ export declare namespace delegation_pool {
|
|
|
2207
2555
|
data_decoded: WithdrawStakeEvent;
|
|
2208
2556
|
type_arguments: [];
|
|
2209
2557
|
}
|
|
2558
|
+
namespace entry {
|
|
2559
|
+
function addStake(client: AptosClient, account: AptosAccount, request: {
|
|
2560
|
+
type_arguments: [];
|
|
2561
|
+
arguments: [Address, bigint];
|
|
2562
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2563
|
+
function initializeDelegationPool(client: AptosClient, account: AptosAccount, request: {
|
|
2564
|
+
type_arguments: [];
|
|
2565
|
+
arguments: [bigint, string];
|
|
2566
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2567
|
+
function reactivateStake(client: AptosClient, account: AptosAccount, request: {
|
|
2568
|
+
type_arguments: [];
|
|
2569
|
+
arguments: [Address, bigint];
|
|
2570
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2571
|
+
function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
|
|
2572
|
+
type_arguments: [];
|
|
2573
|
+
arguments: [Address];
|
|
2574
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2575
|
+
function setOperator(client: AptosClient, account: AptosAccount, request: {
|
|
2576
|
+
type_arguments: [];
|
|
2577
|
+
arguments: [Address];
|
|
2578
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2579
|
+
function synchronizeDelegationPool(client: AptosClient, account: AptosAccount, request: {
|
|
2580
|
+
type_arguments: [];
|
|
2581
|
+
arguments: [Address];
|
|
2582
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2583
|
+
function unlock(client: AptosClient, account: AptosAccount, request: {
|
|
2584
|
+
type_arguments: [];
|
|
2585
|
+
arguments: [Address, bigint];
|
|
2586
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2587
|
+
function withdraw(client: AptosClient, account: AptosAccount, request: {
|
|
2588
|
+
type_arguments: [];
|
|
2589
|
+
arguments: [Address, bigint];
|
|
2590
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2591
|
+
}
|
|
2210
2592
|
namespace view {
|
|
2211
2593
|
function canWithdrawPendingInactive(client: AptosClient, request: {
|
|
2212
2594
|
type_arguments: [];
|
|
2213
2595
|
arguments: [Address];
|
|
2214
|
-
}, version?: bigint): Promise<
|
|
2596
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2215
2597
|
function delegationPoolExists(client: AptosClient, request: {
|
|
2216
2598
|
type_arguments: [];
|
|
2217
2599
|
arguments: [Address];
|
|
2218
|
-
}, version?: bigint): Promise<
|
|
2600
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2219
2601
|
function getAddStakeFee(client: AptosClient, request: {
|
|
2220
2602
|
type_arguments: [];
|
|
2221
2603
|
arguments: [Address, bigint];
|
|
2222
|
-
}, version?: bigint): Promise<
|
|
2604
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2223
2605
|
function getDelegationPoolStake(client: AptosClient, request: {
|
|
2224
2606
|
type_arguments: [];
|
|
2225
2607
|
arguments: [Address];
|
|
2226
|
-
}, version?: bigint): Promise<
|
|
2608
|
+
}, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
|
|
2227
2609
|
function getOwnedPoolAddress(client: AptosClient, request: {
|
|
2228
2610
|
type_arguments: [];
|
|
2229
2611
|
arguments: [Address];
|
|
2230
|
-
}, version?: bigint): Promise<
|
|
2612
|
+
}, version?: bigint): Promise<[Address]>;
|
|
2231
2613
|
function getPendingWithdrawal(client: AptosClient, request: {
|
|
2232
2614
|
type_arguments: [];
|
|
2233
2615
|
arguments: [Address, Address];
|
|
2234
|
-
}, version?: bigint): Promise<
|
|
2616
|
+
}, version?: bigint): Promise<[Boolean, bigint]>;
|
|
2235
2617
|
function getStake(client: AptosClient, request: {
|
|
2236
2618
|
type_arguments: [];
|
|
2237
2619
|
arguments: [Address, Address];
|
|
2238
|
-
}, version?: bigint): Promise<
|
|
2620
|
+
}, version?: bigint): Promise<[bigint, bigint, bigint]>;
|
|
2239
2621
|
function observedLockupCycle(client: AptosClient, request: {
|
|
2240
2622
|
type_arguments: [];
|
|
2241
2623
|
arguments: [Address];
|
|
2242
|
-
}, version?: bigint): Promise<
|
|
2624
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2243
2625
|
function operatorCommissionPercentage(client: AptosClient, request: {
|
|
2244
2626
|
type_arguments: [];
|
|
2245
2627
|
arguments: [Address];
|
|
2246
|
-
}, version?: bigint): Promise<
|
|
2628
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2247
2629
|
function ownerCapExists(client: AptosClient, request: {
|
|
2248
2630
|
type_arguments: [];
|
|
2249
2631
|
arguments: [Address];
|
|
2250
|
-
}, version?: bigint): Promise<
|
|
2632
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2251
2633
|
function shareholdersCountActivePool(client: AptosClient, request: {
|
|
2252
2634
|
type_arguments: [];
|
|
2253
2635
|
arguments: [Address];
|
|
2254
|
-
}, version?: bigint): Promise<
|
|
2636
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2255
2637
|
}
|
|
2256
2638
|
}
|
|
2257
2639
|
export declare namespace reconfiguration {
|
|
@@ -2282,6 +2664,7 @@ export declare namespace reconfiguration {
|
|
|
2282
2664
|
data_decoded: NewEpochEvent;
|
|
2283
2665
|
type_arguments: [];
|
|
2284
2666
|
}
|
|
2667
|
+
namespace entry { }
|
|
2285
2668
|
namespace view { }
|
|
2286
2669
|
}
|
|
2287
2670
|
export declare namespace transaction_fee {
|
|
@@ -2301,6 +2684,7 @@ export declare namespace transaction_fee {
|
|
|
2301
2684
|
const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
|
|
2302
2685
|
function type(): TypeDescriptor<CollectedFeesPerBlock>;
|
|
2303
2686
|
}
|
|
2687
|
+
namespace entry { }
|
|
2304
2688
|
namespace view { }
|
|
2305
2689
|
}
|
|
2306
2690
|
export declare namespace aptos_governance {
|
|
@@ -2394,19 +2778,37 @@ export declare namespace aptos_governance {
|
|
|
2394
2778
|
const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
|
|
2395
2779
|
function type(): TypeDescriptor<VotingRecords>;
|
|
2396
2780
|
}
|
|
2781
|
+
namespace entry {
|
|
2782
|
+
function addApprovedScriptHashScript(client: AptosClient, account: AptosAccount, request: {
|
|
2783
|
+
type_arguments: [];
|
|
2784
|
+
arguments: [bigint];
|
|
2785
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2786
|
+
function createProposal(client: AptosClient, account: AptosAccount, request: {
|
|
2787
|
+
type_arguments: [];
|
|
2788
|
+
arguments: [Address, string, string, string];
|
|
2789
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2790
|
+
function createProposalV2(client: AptosClient, account: AptosAccount, request: {
|
|
2791
|
+
type_arguments: [];
|
|
2792
|
+
arguments: [Address, string, string, string, Boolean];
|
|
2793
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2794
|
+
function vote(client: AptosClient, account: AptosAccount, request: {
|
|
2795
|
+
type_arguments: [];
|
|
2796
|
+
arguments: [Address, bigint, Boolean];
|
|
2797
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
2798
|
+
}
|
|
2397
2799
|
namespace view {
|
|
2398
2800
|
function getMinVotingThreshold(client: AptosClient, request: {
|
|
2399
2801
|
type_arguments: [];
|
|
2400
2802
|
arguments: [];
|
|
2401
|
-
}, version?: bigint): Promise<
|
|
2803
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2402
2804
|
function getRequiredProposerStake(client: AptosClient, request: {
|
|
2403
2805
|
type_arguments: [];
|
|
2404
2806
|
arguments: [];
|
|
2405
|
-
}, version?: bigint): Promise<
|
|
2807
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2406
2808
|
function getVotingDurationSecs(client: AptosClient, request: {
|
|
2407
2809
|
type_arguments: [];
|
|
2408
2810
|
arguments: [];
|
|
2409
|
-
}, version?: bigint): Promise<
|
|
2811
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2410
2812
|
}
|
|
2411
2813
|
}
|
|
2412
2814
|
export declare namespace bls12381_algebra {
|
|
@@ -2515,6 +2917,7 @@ export declare namespace bls12381_algebra {
|
|
|
2515
2917
|
const TYPE_QNAME = "0x1::bls12381_algebra::HashG2XmdSha256SswuRo";
|
|
2516
2918
|
function type(): TypeDescriptor<HashG2XmdSha256SswuRo>;
|
|
2517
2919
|
}
|
|
2920
|
+
namespace entry { }
|
|
2518
2921
|
namespace view { }
|
|
2519
2922
|
}
|
|
2520
2923
|
export declare namespace consensus_config {
|
|
@@ -2525,6 +2928,7 @@ export declare namespace consensus_config {
|
|
|
2525
2928
|
const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
|
|
2526
2929
|
function type(): TypeDescriptor<ConsensusConfig>;
|
|
2527
2930
|
}
|
|
2931
|
+
namespace entry { }
|
|
2528
2932
|
namespace view { }
|
|
2529
2933
|
}
|
|
2530
2934
|
export declare namespace execution_config {
|
|
@@ -2535,6 +2939,7 @@ export declare namespace execution_config {
|
|
|
2535
2939
|
const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
|
|
2536
2940
|
function type(): TypeDescriptor<ExecutionConfig>;
|
|
2537
2941
|
}
|
|
2942
|
+
namespace entry { }
|
|
2538
2943
|
namespace view { }
|
|
2539
2944
|
}
|
|
2540
2945
|
export declare namespace multisig_account {
|
|
@@ -2705,55 +3110,126 @@ export declare namespace multisig_account {
|
|
|
2705
3110
|
data_decoded: VoteEvent;
|
|
2706
3111
|
type_arguments: [];
|
|
2707
3112
|
}
|
|
3113
|
+
namespace entry {
|
|
3114
|
+
function addOwner(client: AptosClient, account: AptosAccount, request: {
|
|
3115
|
+
type_arguments: [];
|
|
3116
|
+
arguments: [Address];
|
|
3117
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3118
|
+
function addOwners(client: AptosClient, account: AptosAccount, request: {
|
|
3119
|
+
type_arguments: [];
|
|
3120
|
+
arguments: [Address[]];
|
|
3121
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3122
|
+
function approveTransaction(client: AptosClient, account: AptosAccount, request: {
|
|
3123
|
+
type_arguments: [];
|
|
3124
|
+
arguments: [Address, bigint];
|
|
3125
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3126
|
+
function create(client: AptosClient, account: AptosAccount, request: {
|
|
3127
|
+
type_arguments: [];
|
|
3128
|
+
arguments: [bigint, string[], string[]];
|
|
3129
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3130
|
+
function createTransaction(client: AptosClient, account: AptosAccount, request: {
|
|
3131
|
+
type_arguments: [];
|
|
3132
|
+
arguments: [Address, string];
|
|
3133
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3134
|
+
function createTransactionWithHash(client: AptosClient, account: AptosAccount, request: {
|
|
3135
|
+
type_arguments: [];
|
|
3136
|
+
arguments: [Address, string];
|
|
3137
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3138
|
+
function createWithExistingAccount(client: AptosClient, account: AptosAccount, request: {
|
|
3139
|
+
type_arguments: [];
|
|
3140
|
+
arguments: [
|
|
3141
|
+
Address,
|
|
3142
|
+
Address[],
|
|
3143
|
+
bigint,
|
|
3144
|
+
number,
|
|
3145
|
+
string,
|
|
3146
|
+
string,
|
|
3147
|
+
string[],
|
|
3148
|
+
string[]
|
|
3149
|
+
];
|
|
3150
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3151
|
+
function createWithOwners(client: AptosClient, account: AptosAccount, request: {
|
|
3152
|
+
type_arguments: [];
|
|
3153
|
+
arguments: [Address[], bigint, string[], string[]];
|
|
3154
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3155
|
+
function executeRejectedTransaction(client: AptosClient, account: AptosAccount, request: {
|
|
3156
|
+
type_arguments: [];
|
|
3157
|
+
arguments: [Address];
|
|
3158
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3159
|
+
function rejectTransaction(client: AptosClient, account: AptosAccount, request: {
|
|
3160
|
+
type_arguments: [];
|
|
3161
|
+
arguments: [Address, bigint];
|
|
3162
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3163
|
+
function removeOwner(client: AptosClient, account: AptosAccount, request: {
|
|
3164
|
+
type_arguments: [];
|
|
3165
|
+
arguments: [Address];
|
|
3166
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3167
|
+
function removeOwners(client: AptosClient, account: AptosAccount, request: {
|
|
3168
|
+
type_arguments: [];
|
|
3169
|
+
arguments: [Address[]];
|
|
3170
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3171
|
+
function updateMetadata(client: AptosClient, account: AptosAccount, request: {
|
|
3172
|
+
type_arguments: [];
|
|
3173
|
+
arguments: [string[], string[]];
|
|
3174
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3175
|
+
function updateSignaturesRequired(client: AptosClient, account: AptosAccount, request: {
|
|
3176
|
+
type_arguments: [];
|
|
3177
|
+
arguments: [bigint];
|
|
3178
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3179
|
+
function voteTransanction(client: AptosClient, account: AptosAccount, request: {
|
|
3180
|
+
type_arguments: [];
|
|
3181
|
+
arguments: [Address, bigint, Boolean];
|
|
3182
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3183
|
+
}
|
|
2708
3184
|
namespace view {
|
|
2709
3185
|
function canBeExecuted(client: AptosClient, request: {
|
|
2710
3186
|
type_arguments: [];
|
|
2711
3187
|
arguments: [Address, bigint];
|
|
2712
|
-
}, version?: bigint): Promise<
|
|
3188
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2713
3189
|
function canBeRejected(client: AptosClient, request: {
|
|
2714
3190
|
type_arguments: [];
|
|
2715
3191
|
arguments: [Address, bigint];
|
|
2716
|
-
}, version?: bigint): Promise<
|
|
3192
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2717
3193
|
function getNextMultisigAccountAddress(client: AptosClient, request: {
|
|
2718
3194
|
type_arguments: [];
|
|
2719
3195
|
arguments: [Address];
|
|
2720
|
-
}, version?: bigint): Promise<
|
|
3196
|
+
}, version?: bigint): Promise<[Address]>;
|
|
2721
3197
|
function getNextTransactionPayload(client: AptosClient, request: {
|
|
2722
3198
|
type_arguments: [];
|
|
2723
3199
|
arguments: [Address, string];
|
|
2724
|
-
}, version?: bigint): Promise<
|
|
3200
|
+
}, version?: bigint): Promise<[string]>;
|
|
2725
3201
|
function getPendingTransactions(client: AptosClient, request: {
|
|
2726
3202
|
type_arguments: [];
|
|
2727
3203
|
arguments: [Address];
|
|
2728
|
-
}, version?: bigint): Promise<
|
|
3204
|
+
}, version?: bigint): Promise<[multisig_account.MultisigTransaction[]]>;
|
|
2729
3205
|
function getTransaction(client: AptosClient, request: {
|
|
2730
3206
|
type_arguments: [];
|
|
2731
3207
|
arguments: [Address, bigint];
|
|
2732
|
-
}, version?: bigint): Promise<
|
|
3208
|
+
}, version?: bigint): Promise<[multisig_account.MultisigTransaction]>;
|
|
2733
3209
|
function lastResolvedSequenceNumber(client: AptosClient, request: {
|
|
2734
3210
|
type_arguments: [];
|
|
2735
3211
|
arguments: [Address];
|
|
2736
|
-
}, version?: bigint): Promise<
|
|
3212
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2737
3213
|
function metadata(client: AptosClient, request: {
|
|
2738
3214
|
type_arguments: [];
|
|
2739
3215
|
arguments: [Address];
|
|
2740
|
-
}, version?: bigint): Promise<
|
|
3216
|
+
}, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
|
|
2741
3217
|
function nextSequenceNumber(client: AptosClient, request: {
|
|
2742
3218
|
type_arguments: [];
|
|
2743
3219
|
arguments: [Address];
|
|
2744
|
-
}, version?: bigint): Promise<
|
|
3220
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2745
3221
|
function numSignaturesRequired(client: AptosClient, request: {
|
|
2746
3222
|
type_arguments: [];
|
|
2747
3223
|
arguments: [Address];
|
|
2748
|
-
}, version?: bigint): Promise<
|
|
3224
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2749
3225
|
function owners(client: AptosClient, request: {
|
|
2750
3226
|
type_arguments: [];
|
|
2751
3227
|
arguments: [Address];
|
|
2752
|
-
}, version?: bigint): Promise<
|
|
3228
|
+
}, version?: bigint): Promise<[Address[]]>;
|
|
2753
3229
|
function vote(client: AptosClient, request: {
|
|
2754
3230
|
type_arguments: [];
|
|
2755
3231
|
arguments: [Address, bigint, Address];
|
|
2756
|
-
}, version?: bigint): Promise<
|
|
3232
|
+
}, version?: bigint): Promise<[Boolean, Boolean]>;
|
|
2757
3233
|
}
|
|
2758
3234
|
}
|
|
2759
3235
|
export declare namespace pool_u64_unbound {
|
|
@@ -2767,6 +3243,7 @@ export declare namespace pool_u64_unbound {
|
|
|
2767
3243
|
const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
|
|
2768
3244
|
function type(): TypeDescriptor<Pool>;
|
|
2769
3245
|
}
|
|
3246
|
+
namespace entry { }
|
|
2770
3247
|
namespace view { }
|
|
2771
3248
|
}
|
|
2772
3249
|
export declare namespace resource_account {
|
|
@@ -2777,6 +3254,20 @@ export declare namespace resource_account {
|
|
|
2777
3254
|
const TYPE_QNAME = "0x1::resource_account::Container";
|
|
2778
3255
|
function type(): TypeDescriptor<Container>;
|
|
2779
3256
|
}
|
|
3257
|
+
namespace entry {
|
|
3258
|
+
function createResourceAccount(client: AptosClient, account: AptosAccount, request: {
|
|
3259
|
+
type_arguments: [];
|
|
3260
|
+
arguments: [string, string];
|
|
3261
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3262
|
+
function createResourceAccountAndFund(client: AptosClient, account: AptosAccount, request: {
|
|
3263
|
+
type_arguments: [];
|
|
3264
|
+
arguments: [string, string, bigint];
|
|
3265
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3266
|
+
function createResourceAccountAndPublishPackage(client: AptosClient, account: AptosAccount, request: {
|
|
3267
|
+
type_arguments: [];
|
|
3268
|
+
arguments: [string, string, string[]];
|
|
3269
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3270
|
+
}
|
|
2780
3271
|
namespace view { }
|
|
2781
3272
|
}
|
|
2782
3273
|
export declare namespace staking_contract {
|
|
@@ -2958,34 +3449,81 @@ export declare namespace staking_contract {
|
|
|
2958
3449
|
data_decoded: UpdateVoterEvent;
|
|
2959
3450
|
type_arguments: [];
|
|
2960
3451
|
}
|
|
3452
|
+
namespace entry {
|
|
3453
|
+
function addStake(client: AptosClient, account: AptosAccount, request: {
|
|
3454
|
+
type_arguments: [];
|
|
3455
|
+
arguments: [Address, bigint];
|
|
3456
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3457
|
+
function createStakingContract(client: AptosClient, account: AptosAccount, request: {
|
|
3458
|
+
type_arguments: [];
|
|
3459
|
+
arguments: [Address, Address, bigint, bigint, string];
|
|
3460
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3461
|
+
function distribute(client: AptosClient, account: AptosAccount, request: {
|
|
3462
|
+
type_arguments: [];
|
|
3463
|
+
arguments: [Address, Address];
|
|
3464
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3465
|
+
function requestCommission(client: AptosClient, account: AptosAccount, request: {
|
|
3466
|
+
type_arguments: [];
|
|
3467
|
+
arguments: [Address, Address];
|
|
3468
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3469
|
+
function resetLockup(client: AptosClient, account: AptosAccount, request: {
|
|
3470
|
+
type_arguments: [];
|
|
3471
|
+
arguments: [Address];
|
|
3472
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3473
|
+
function switchOperator(client: AptosClient, account: AptosAccount, request: {
|
|
3474
|
+
type_arguments: [];
|
|
3475
|
+
arguments: [Address, Address, bigint];
|
|
3476
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3477
|
+
function switchOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
|
|
3478
|
+
type_arguments: [];
|
|
3479
|
+
arguments: [Address, Address];
|
|
3480
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3481
|
+
function unlockRewards(client: AptosClient, account: AptosAccount, request: {
|
|
3482
|
+
type_arguments: [];
|
|
3483
|
+
arguments: [Address];
|
|
3484
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3485
|
+
function unlockStake(client: AptosClient, account: AptosAccount, request: {
|
|
3486
|
+
type_arguments: [];
|
|
3487
|
+
arguments: [Address, bigint];
|
|
3488
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3489
|
+
function updateCommision(client: AptosClient, account: AptosAccount, request: {
|
|
3490
|
+
type_arguments: [];
|
|
3491
|
+
arguments: [Address, bigint];
|
|
3492
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3493
|
+
function updateVoter(client: AptosClient, account: AptosAccount, request: {
|
|
3494
|
+
type_arguments: [];
|
|
3495
|
+
arguments: [Address, Address];
|
|
3496
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3497
|
+
}
|
|
2961
3498
|
namespace view {
|
|
2962
3499
|
function commissionPercentage(client: AptosClient, request: {
|
|
2963
3500
|
type_arguments: [];
|
|
2964
3501
|
arguments: [Address, Address];
|
|
2965
|
-
}, version?: bigint): Promise<
|
|
3502
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2966
3503
|
function lastRecordedPrincipal(client: AptosClient, request: {
|
|
2967
3504
|
type_arguments: [];
|
|
2968
3505
|
arguments: [Address, Address];
|
|
2969
|
-
}, version?: bigint): Promise<
|
|
3506
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2970
3507
|
function pendingDistributionCounts(client: AptosClient, request: {
|
|
2971
3508
|
type_arguments: [];
|
|
2972
3509
|
arguments: [Address, Address];
|
|
2973
|
-
}, version?: bigint): Promise<
|
|
3510
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
2974
3511
|
function stakePoolAddress(client: AptosClient, request: {
|
|
2975
3512
|
type_arguments: [];
|
|
2976
3513
|
arguments: [Address, Address];
|
|
2977
|
-
}, version?: bigint): Promise<
|
|
3514
|
+
}, version?: bigint): Promise<[Address]>;
|
|
2978
3515
|
function stakingContractAmounts(client: AptosClient, request: {
|
|
2979
3516
|
type_arguments: [];
|
|
2980
3517
|
arguments: [Address, Address];
|
|
2981
|
-
}, version?: bigint): Promise<
|
|
3518
|
+
}, version?: bigint): Promise<[bigint, bigint, bigint]>;
|
|
2982
3519
|
function stakingContractExists(client: AptosClient, request: {
|
|
2983
3520
|
type_arguments: [];
|
|
2984
3521
|
arguments: [Address, Address];
|
|
2985
|
-
}, version?: bigint): Promise<
|
|
3522
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
2986
3523
|
}
|
|
2987
3524
|
}
|
|
2988
3525
|
export declare namespace system_addresses {
|
|
3526
|
+
namespace entry { }
|
|
2989
3527
|
namespace view { }
|
|
2990
3528
|
}
|
|
2991
3529
|
export declare namespace table_with_length {
|
|
@@ -2997,6 +3535,7 @@ export declare namespace table_with_length {
|
|
|
2997
3535
|
const TYPE_QNAME = "0x1::table_with_length::TableWithLength";
|
|
2998
3536
|
function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<TableWithLength<T0, T1>>;
|
|
2999
3537
|
}
|
|
3538
|
+
namespace entry { }
|
|
3000
3539
|
namespace view { }
|
|
3001
3540
|
}
|
|
3002
3541
|
export declare namespace aggregator_factory {
|
|
@@ -3007,6 +3546,7 @@ export declare namespace aggregator_factory {
|
|
|
3007
3546
|
const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
|
|
3008
3547
|
function type(): TypeDescriptor<AggregatorFactory>;
|
|
3009
3548
|
}
|
|
3549
|
+
namespace entry { }
|
|
3010
3550
|
namespace view { }
|
|
3011
3551
|
}
|
|
3012
3552
|
export declare namespace governance_proposal {
|
|
@@ -3017,6 +3557,7 @@ export declare namespace governance_proposal {
|
|
|
3017
3557
|
const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
|
|
3018
3558
|
function type(): TypeDescriptor<GovernanceProposal>;
|
|
3019
3559
|
}
|
|
3560
|
+
namespace entry { }
|
|
3020
3561
|
namespace view { }
|
|
3021
3562
|
}
|
|
3022
3563
|
export declare namespace optional_aggregator {
|
|
@@ -3036,9 +3577,11 @@ export declare namespace optional_aggregator {
|
|
|
3036
3577
|
const TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";
|
|
3037
3578
|
function type(): TypeDescriptor<OptionalAggregator>;
|
|
3038
3579
|
}
|
|
3580
|
+
namespace entry { }
|
|
3039
3581
|
namespace view { }
|
|
3040
3582
|
}
|
|
3041
3583
|
export declare namespace transaction_context {
|
|
3584
|
+
namespace entry { }
|
|
3042
3585
|
namespace view { }
|
|
3043
3586
|
}
|
|
3044
3587
|
export declare namespace primary_fungible_store {
|
|
@@ -3049,27 +3592,33 @@ export declare namespace primary_fungible_store {
|
|
|
3049
3592
|
const TYPE_QNAME = "0x1::primary_fungible_store::DeriveRefPod";
|
|
3050
3593
|
function type(): TypeDescriptor<DeriveRefPod>;
|
|
3051
3594
|
}
|
|
3595
|
+
namespace entry {
|
|
3596
|
+
function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
|
|
3597
|
+
type_arguments: [string];
|
|
3598
|
+
arguments: [object_.Object<T0>, Address, bigint];
|
|
3599
|
+
}, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
|
|
3600
|
+
}
|
|
3052
3601
|
namespace view {
|
|
3053
3602
|
function balance<T0 = any>(client: AptosClient, request: {
|
|
3054
3603
|
type_arguments: [string];
|
|
3055
3604
|
arguments: [Address, object_.Object<T0>];
|
|
3056
|
-
}, version?: bigint): Promise<
|
|
3605
|
+
}, version?: bigint): Promise<[bigint]>;
|
|
3057
3606
|
function isFrozen<T0 = any>(client: AptosClient, request: {
|
|
3058
3607
|
type_arguments: [string];
|
|
3059
3608
|
arguments: [Address, object_.Object<T0>];
|
|
3060
|
-
}, version?: bigint): Promise<
|
|
3609
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
3061
3610
|
function primaryStore<T0 = any>(client: AptosClient, request: {
|
|
3062
3611
|
type_arguments: [string];
|
|
3063
3612
|
arguments: [Address, object_.Object<T0>];
|
|
3064
|
-
}, version?: bigint): Promise<
|
|
3613
|
+
}, version?: bigint): Promise<[object_.Object<fungible_asset.FungibleStore>]>;
|
|
3065
3614
|
function primaryStoreAddress<T0 = any>(client: AptosClient, request: {
|
|
3066
3615
|
type_arguments: [string];
|
|
3067
3616
|
arguments: [Address, object_.Object<T0>];
|
|
3068
|
-
}, version?: bigint): Promise<
|
|
3617
|
+
}, version?: bigint): Promise<[Address]>;
|
|
3069
3618
|
function primaryStoreExists<T0 = any>(client: AptosClient, request: {
|
|
3070
3619
|
type_arguments: [string];
|
|
3071
3620
|
arguments: [Address, object_.Object<T0>];
|
|
3072
|
-
}, version?: bigint): Promise<
|
|
3621
|
+
}, version?: bigint): Promise<[Boolean]>;
|
|
3073
3622
|
}
|
|
3074
3623
|
}
|
|
3075
3624
|
export declare namespace transaction_validation {
|
|
@@ -3085,6 +3634,7 @@ export declare namespace transaction_validation {
|
|
|
3085
3634
|
const TYPE_QNAME = "0x1::transaction_validation::TransactionValidation";
|
|
3086
3635
|
function type(): TypeDescriptor<TransactionValidation>;
|
|
3087
3636
|
}
|
|
3637
|
+
namespace entry { }
|
|
3088
3638
|
namespace view { }
|
|
3089
3639
|
}
|
|
3090
3640
|
export declare function loadAllTypes(coder: MoveCoder): void;
|