@metamask/delegation-core 1.0.0 → 2.0.0

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.
Files changed (9) hide show
  1. package/CHANGELOG.md +19 -1
  2. package/README.md +8 -8
  3. package/dist/index.cjs +621 -43
  4. package/dist/index.cjs.map +1 -1
  5. package/dist/index.d.cts +143 -66
  6. package/dist/index.d.ts +143 -66
  7. package/dist/index.mjs +626 -48
  8. package/dist/index.mjs.map +1 -1
  9. package/package.json +1 -1
package/dist/index.d.ts CHANGED
@@ -15,7 +15,14 @@ type DelegationStruct<TBytes extends BytesLike = BytesLike> = {
15
15
  signature: TBytes;
16
16
  };
17
17
 
18
+ declare enum BalanceChangeType {
19
+ Increase = 0,
20
+ Decrease = 1
21
+ }
22
+
18
23
  type ResultValue = 'hex' | 'bytes';
24
+ type ResultType<TResultValue extends ResultValue> = TResultValue extends 'hex' ? Hex : Uint8Array;
25
+ type DecodedBytesLike<TResultValue extends ResultValue> = ResultType<TResultValue>;
19
26
  type EncodingOptions<TResultValue extends ResultValue> = {
20
27
  out: TResultValue;
21
28
  };
@@ -25,13 +32,15 @@ type ValueLteTerms = {
25
32
  };
26
33
  declare function createValueLteTerms(terms: ValueLteTerms, options?: EncodingOptions<'hex'>): Hex;
27
34
  declare function createValueLteTerms(terms: ValueLteTerms, options: EncodingOptions<'bytes'>): Uint8Array;
35
+ declare function decodeValueLteTerms(terms: BytesLike): ValueLteTerms;
28
36
 
29
37
  type TimestampTerms = {
30
- timestampAfterThreshold: number;
31
- timestampBeforeThreshold: number;
38
+ afterThreshold: number;
39
+ beforeThreshold: number;
32
40
  };
33
41
  declare function createTimestampTerms(terms: TimestampTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
34
42
  declare function createTimestampTerms(terms: TimestampTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
43
+ declare function decodeTimestampTerms(terms: BytesLike): TimestampTerms;
35
44
 
36
45
  type NativeTokenPeriodTransferTerms = {
37
46
  periodAmount: bigint;
@@ -40,42 +49,51 @@ type NativeTokenPeriodTransferTerms = {
40
49
  };
41
50
  declare function createNativeTokenPeriodTransferTerms(terms: NativeTokenPeriodTransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
42
51
  declare function createNativeTokenPeriodTransferTerms(terms: NativeTokenPeriodTransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
52
+ declare function decodeNativeTokenPeriodTransferTerms(terms: BytesLike): NativeTokenPeriodTransferTerms;
43
53
 
44
- type ExactCalldataTerms = {
45
- calldata: BytesLike;
54
+ type ExactCalldataTerms<TBytesLike extends BytesLike = BytesLike> = {
55
+ calldata: TBytesLike;
46
56
  };
47
57
  declare function createExactCalldataTerms(terms: ExactCalldataTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
48
58
  declare function createExactCalldataTerms(terms: ExactCalldataTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
59
+ declare function decodeExactCalldataTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactCalldataTerms<DecodedBytesLike<'hex'>>;
60
+ declare function decodeExactCalldataTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactCalldataTerms<DecodedBytesLike<'bytes'>>;
49
61
 
50
- type ExactCalldataBatchTerms = {
62
+ type ExactCalldataBatchTerms<TBytesLike extends BytesLike = BytesLike> = {
51
63
  executions: {
52
- target: BytesLike;
64
+ target: TBytesLike;
53
65
  value: bigint;
54
- callData: BytesLike;
66
+ callData: TBytesLike;
55
67
  }[];
56
68
  };
57
69
  declare function createExactCalldataBatchTerms(terms: ExactCalldataBatchTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
58
70
  declare function createExactCalldataBatchTerms(terms: ExactCalldataBatchTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
71
+ declare function decodeExactCalldataBatchTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactCalldataBatchTerms<DecodedBytesLike<'hex'>>;
72
+ declare function decodeExactCalldataBatchTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactCalldataBatchTerms<DecodedBytesLike<'bytes'>>;
59
73
 
60
- type ExactExecutionTerms = {
74
+ type ExactExecutionTerms<TBytesLike extends BytesLike = BytesLike> = {
61
75
  execution: {
62
- target: BytesLike;
76
+ target: TBytesLike;
63
77
  value: bigint;
64
- callData: BytesLike;
78
+ callData: TBytesLike;
65
79
  };
66
80
  };
67
81
  declare function createExactExecutionTerms(terms: ExactExecutionTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
68
82
  declare function createExactExecutionTerms(terms: ExactExecutionTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
83
+ declare function decodeExactExecutionTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactExecutionTerms<DecodedBytesLike<'hex'>>;
84
+ declare function decodeExactExecutionTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactExecutionTerms<DecodedBytesLike<'bytes'>>;
69
85
 
70
- type ExactExecutionBatchTerms = {
86
+ type ExactExecutionBatchTerms<TBytesLike extends BytesLike = BytesLike> = {
71
87
  executions: {
72
- target: BytesLike;
88
+ target: TBytesLike;
73
89
  value: bigint;
74
- callData: BytesLike;
90
+ callData: TBytesLike;
75
91
  }[];
76
92
  };
77
93
  declare function createExactExecutionBatchTerms(terms: ExactExecutionBatchTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
78
94
  declare function createExactExecutionBatchTerms(terms: ExactExecutionBatchTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
95
+ declare function decodeExactExecutionBatchTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactExecutionBatchTerms<DecodedBytesLike<'hex'>>;
96
+ declare function decodeExactExecutionBatchTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactExecutionBatchTerms<DecodedBytesLike<'bytes'>>;
79
97
 
80
98
  type NativeTokenStreamingTerms = {
81
99
  initialAmount: bigint;
@@ -85,30 +103,36 @@ type NativeTokenStreamingTerms = {
85
103
  };
86
104
  declare function createNativeTokenStreamingTerms(terms: NativeTokenStreamingTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
87
105
  declare function createNativeTokenStreamingTerms(terms: NativeTokenStreamingTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
106
+ declare function decodeNativeTokenStreamingTerms(terms: BytesLike): NativeTokenStreamingTerms;
88
107
 
89
108
  type NativeTokenTransferAmountTerms = {
90
109
  maxAmount: bigint;
91
110
  };
92
111
  declare function createNativeTokenTransferAmountTerms(terms: NativeTokenTransferAmountTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
93
112
  declare function createNativeTokenTransferAmountTerms(terms: NativeTokenTransferAmountTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
113
+ declare function decodeNativeTokenTransferAmountTerms(terms: BytesLike): NativeTokenTransferAmountTerms;
94
114
 
95
- type NativeTokenPaymentTerms = {
96
- recipient: BytesLike;
115
+ type NativeTokenPaymentTerms<TBytesLike extends BytesLike = BytesLike> = {
116
+ recipient: TBytesLike;
97
117
  amount: bigint;
98
118
  };
99
119
  declare function createNativeTokenPaymentTerms(terms: NativeTokenPaymentTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
100
120
  declare function createNativeTokenPaymentTerms(terms: NativeTokenPaymentTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
121
+ declare function decodeNativeTokenPaymentTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): NativeTokenPaymentTerms<DecodedBytesLike<'hex'>>;
122
+ declare function decodeNativeTokenPaymentTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): NativeTokenPaymentTerms<DecodedBytesLike<'bytes'>>;
101
123
 
102
- type NativeBalanceChangeTerms = {
103
- recipient: BytesLike;
124
+ type NativeBalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
125
+ recipient: TBytesLike;
104
126
  balance: bigint;
105
- changeType: number;
127
+ changeType: BalanceChangeType;
106
128
  };
107
129
  declare function createNativeBalanceChangeTerms(terms: NativeBalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
108
130
  declare function createNativeBalanceChangeTerms(terms: NativeBalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
131
+ declare function decodeNativeBalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): NativeBalanceChangeTerms<DecodedBytesLike<'hex'>>;
132
+ declare function decodeNativeBalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): NativeBalanceChangeTerms<DecodedBytesLike<'bytes'>>;
109
133
 
110
- type ERC20StreamingTerms = {
111
- tokenAddress: BytesLike;
134
+ type ERC20StreamingTerms<TBytesLike extends BytesLike = BytesLike> = {
135
+ tokenAddress: TBytesLike;
112
136
  initialAmount: bigint;
113
137
  maxAmount: bigint;
114
138
  amountPerSecond: bigint;
@@ -116,88 +140,112 @@ type ERC20StreamingTerms = {
116
140
  };
117
141
  declare function createERC20StreamingTerms(terms: ERC20StreamingTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
118
142
  declare function createERC20StreamingTerms(terms: ERC20StreamingTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
143
+ declare function decodeERC20StreamingTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20StreamingTerms<DecodedBytesLike<'hex'>>;
144
+ declare function decodeERC20StreamingTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20StreamingTerms<DecodedBytesLike<'bytes'>>;
119
145
 
120
- type ERC20TokenPeriodTransferTerms = {
121
- tokenAddress: BytesLike;
146
+ type ERC20TokenPeriodTransferTerms<TBytesLike extends BytesLike = BytesLike> = {
147
+ tokenAddress: TBytesLike;
122
148
  periodAmount: bigint;
123
149
  periodDuration: number;
124
150
  startDate: number;
125
151
  };
126
152
  declare function createERC20TokenPeriodTransferTerms(terms: ERC20TokenPeriodTransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
127
153
  declare function createERC20TokenPeriodTransferTerms(terms: ERC20TokenPeriodTransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
154
+ declare function decodeERC20TokenPeriodTransferTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20TokenPeriodTransferTerms<DecodedBytesLike<'hex'>>;
155
+ declare function decodeERC20TokenPeriodTransferTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20TokenPeriodTransferTerms<DecodedBytesLike<'bytes'>>;
128
156
 
129
- type ERC20TransferAmountTerms = {
130
- tokenAddress: BytesLike;
157
+ type ERC20TransferAmountTerms<TBytesLike extends BytesLike = BytesLike> = {
158
+ tokenAddress: TBytesLike;
131
159
  maxAmount: bigint;
132
160
  };
133
161
  declare function createERC20TransferAmountTerms(terms: ERC20TransferAmountTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
134
162
  declare function createERC20TransferAmountTerms(terms: ERC20TransferAmountTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
163
+ declare function decodeERC20TransferAmountTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20TransferAmountTerms<DecodedBytesLike<'hex'>>;
164
+ declare function decodeERC20TransferAmountTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20TransferAmountTerms<DecodedBytesLike<'bytes'>>;
135
165
 
136
- type ERC20BalanceChangeTerms = {
137
- tokenAddress: BytesLike;
138
- recipient: BytesLike;
166
+ type ERC20BalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
167
+ tokenAddress: TBytesLike;
168
+ recipient: TBytesLike;
139
169
  balance: bigint;
140
- changeType: number;
170
+ changeType: BalanceChangeType;
141
171
  };
142
172
  declare function createERC20BalanceChangeTerms(terms: ERC20BalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
143
173
  declare function createERC20BalanceChangeTerms(terms: ERC20BalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
174
+ declare function decodeERC20BalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20BalanceChangeTerms<DecodedBytesLike<'hex'>>;
175
+ declare function decodeERC20BalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20BalanceChangeTerms<DecodedBytesLike<'bytes'>>;
144
176
 
145
- type ERC721BalanceChangeTerms = {
146
- tokenAddress: BytesLike;
147
- recipient: BytesLike;
177
+ type ERC721BalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
178
+ tokenAddress: TBytesLike;
179
+ recipient: TBytesLike;
148
180
  amount: bigint;
149
- changeType: number;
181
+ changeType: BalanceChangeType;
150
182
  };
151
183
  declare function createERC721BalanceChangeTerms(terms: ERC721BalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
152
184
  declare function createERC721BalanceChangeTerms(terms: ERC721BalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
185
+ declare function decodeERC721BalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC721BalanceChangeTerms<DecodedBytesLike<'hex'>>;
186
+ declare function decodeERC721BalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC721BalanceChangeTerms<DecodedBytesLike<'bytes'>>;
153
187
 
154
- type ERC721TransferTerms = {
155
- tokenAddress: BytesLike;
188
+ type ERC721TransferTerms<TBytesLike extends BytesLike = BytesLike> = {
189
+ tokenAddress: TBytesLike;
156
190
  tokenId: bigint;
157
191
  };
158
192
  declare function createERC721TransferTerms(terms: ERC721TransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
159
193
  declare function createERC721TransferTerms(terms: ERC721TransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
194
+ declare function decodeERC721TransferTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC721TransferTerms<DecodedBytesLike<'hex'>>;
195
+ declare function decodeERC721TransferTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC721TransferTerms<DecodedBytesLike<'bytes'>>;
160
196
 
161
- type ERC1155BalanceChangeTerms = {
162
- tokenAddress: BytesLike;
163
- recipient: BytesLike;
197
+ type ERC1155BalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
198
+ tokenAddress: TBytesLike;
199
+ recipient: TBytesLike;
164
200
  tokenId: bigint;
165
201
  balance: bigint;
166
- changeType: number;
202
+ changeType: BalanceChangeType;
167
203
  };
168
204
  declare function createERC1155BalanceChangeTerms(terms: ERC1155BalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
169
205
  declare function createERC1155BalanceChangeTerms(terms: ERC1155BalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
206
+ declare function decodeERC1155BalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC1155BalanceChangeTerms<DecodedBytesLike<'hex'>>;
207
+ declare function decodeERC1155BalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC1155BalanceChangeTerms<DecodedBytesLike<'bytes'>>;
170
208
 
171
- type NonceTerms = {
172
- nonce: BytesLike;
209
+ type NonceTerms<TBytesLike extends BytesLike = BytesLike> = {
210
+ nonce: TBytesLike;
173
211
  };
174
212
  declare function createNonceTerms(terms: NonceTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
175
213
  declare function createNonceTerms(terms: NonceTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
214
+ declare function decodeNonceTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): NonceTerms<DecodedBytesLike<'hex'>>;
215
+ declare function decodeNonceTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): NonceTerms<DecodedBytesLike<'bytes'>>;
176
216
 
177
- type AllowedCalldataTerms = {
217
+ type AllowedCalldataTerms<TBytesLike extends BytesLike = BytesLike> = {
178
218
  startIndex: number;
179
- value: BytesLike;
219
+ value: TBytesLike;
180
220
  };
181
221
  declare function createAllowedCalldataTerms(terms: AllowedCalldataTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
182
222
  declare function createAllowedCalldataTerms(terms: AllowedCalldataTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
223
+ declare function decodeAllowedCalldataTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): AllowedCalldataTerms<DecodedBytesLike<'hex'>>;
224
+ declare function decodeAllowedCalldataTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): AllowedCalldataTerms<DecodedBytesLike<'bytes'>>;
183
225
 
184
- type AllowedMethodsTerms = {
185
- selectors: BytesLike[];
226
+ type AllowedMethodsTerms<TBytesLike extends BytesLike = BytesLike> = {
227
+ selectors: TBytesLike[];
186
228
  };
187
229
  declare function createAllowedMethodsTerms(terms: AllowedMethodsTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
188
230
  declare function createAllowedMethodsTerms(terms: AllowedMethodsTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
231
+ declare function decodeAllowedMethodsTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): AllowedMethodsTerms<DecodedBytesLike<'hex'>>;
232
+ declare function decodeAllowedMethodsTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): AllowedMethodsTerms<DecodedBytesLike<'bytes'>>;
189
233
 
190
- type AllowedTargetsTerms = {
191
- targets: BytesLike[];
234
+ type AllowedTargetsTerms<TBytesLike extends BytesLike = BytesLike> = {
235
+ targets: TBytesLike[];
192
236
  };
193
237
  declare function createAllowedTargetsTerms(terms: AllowedTargetsTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
194
238
  declare function createAllowedTargetsTerms(terms: AllowedTargetsTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
239
+ declare function decodeAllowedTargetsTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): AllowedTargetsTerms<DecodedBytesLike<'hex'>>;
240
+ declare function decodeAllowedTargetsTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): AllowedTargetsTerms<DecodedBytesLike<'bytes'>>;
195
241
 
196
- type ArgsEqualityCheckTerms = {
197
- args: BytesLike;
242
+ type ArgsEqualityCheckTerms<TBytesLike extends BytesLike = BytesLike> = {
243
+ args: TBytesLike;
198
244
  };
199
245
  declare function createArgsEqualityCheckTerms(terms: ArgsEqualityCheckTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
200
246
  declare function createArgsEqualityCheckTerms(terms: ArgsEqualityCheckTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
247
+ declare function decodeArgsEqualityCheckTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ArgsEqualityCheckTerms<DecodedBytesLike<'hex'>>;
248
+ declare function decodeArgsEqualityCheckTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ArgsEqualityCheckTerms<DecodedBytesLike<'bytes'>>;
201
249
 
202
250
  type BlockNumberTerms = {
203
251
  afterThreshold: bigint;
@@ -205,60 +253,89 @@ type BlockNumberTerms = {
205
253
  };
206
254
  declare function createBlockNumberTerms(terms: BlockNumberTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
207
255
  declare function createBlockNumberTerms(terms: BlockNumberTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
256
+ declare function decodeBlockNumberTerms(terms: BytesLike): BlockNumberTerms;
208
257
 
209
- type DeployedTerms = {
210
- contractAddress: BytesLike;
211
- salt: BytesLike;
212
- bytecode: BytesLike;
258
+ type DeployedTerms<TBytesLike extends BytesLike = BytesLike> = {
259
+ contractAddress: TBytesLike;
260
+ salt: TBytesLike;
261
+ bytecode: TBytesLike;
213
262
  };
214
263
  declare function createDeployedTerms(terms: DeployedTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
215
264
  declare function createDeployedTerms(terms: DeployedTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
265
+ declare function decodeDeployedTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): DeployedTerms<DecodedBytesLike<'hex'>>;
266
+ declare function decodeDeployedTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): DeployedTerms<DecodedBytesLike<'bytes'>>;
216
267
 
217
268
  type IdTerms = {
218
269
  id: bigint | number;
219
270
  };
220
271
  declare function createIdTerms(terms: IdTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
221
272
  declare function createIdTerms(terms: IdTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
273
+ declare function decodeIdTerms(terms: BytesLike): IdTerms;
222
274
 
223
275
  type LimitedCallsTerms = {
224
276
  limit: number;
225
277
  };
226
278
  declare function createLimitedCallsTerms(terms: LimitedCallsTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
227
279
  declare function createLimitedCallsTerms(terms: LimitedCallsTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
280
+ declare function decodeLimitedCallsTerms(terms: BytesLike): LimitedCallsTerms;
228
281
 
229
- type TokenPeriodConfig = {
230
- token: BytesLike;
282
+ type TokenPeriodConfig<TBytesLike extends BytesLike = BytesLike> = {
283
+ token: TBytesLike;
231
284
  periodAmount: bigint;
232
285
  periodDuration: number;
233
286
  startDate: number;
234
287
  };
235
- type MultiTokenPeriodTerms = {
236
- tokenConfigs: TokenPeriodConfig[];
288
+ type MultiTokenPeriodTerms<TBytesLike extends BytesLike = BytesLike> = {
289
+ tokenConfigs: TokenPeriodConfig<TBytesLike>[];
237
290
  };
238
291
  declare function createMultiTokenPeriodTerms(terms: MultiTokenPeriodTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
239
292
  declare function createMultiTokenPeriodTerms(terms: MultiTokenPeriodTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
293
+ declare function decodeMultiTokenPeriodTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): MultiTokenPeriodTerms<DecodedBytesLike<'hex'>>;
294
+ declare function decodeMultiTokenPeriodTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): MultiTokenPeriodTerms<DecodedBytesLike<'bytes'>>;
240
295
 
241
- type OwnershipTransferTerms = {
242
- contractAddress: BytesLike;
296
+ type OwnershipTransferTerms<TBytesLike extends BytesLike = BytesLike> = {
297
+ contractAddress: TBytesLike;
243
298
  };
244
299
  declare function createOwnershipTransferTerms(terms: OwnershipTransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
245
300
  declare function createOwnershipTransferTerms(terms: OwnershipTransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
301
+ declare function decodeOwnershipTransferTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): OwnershipTransferTerms<DecodedBytesLike<'hex'>>;
302
+ declare function decodeOwnershipTransferTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): OwnershipTransferTerms<DecodedBytesLike<'bytes'>>;
246
303
 
247
- type RedeemerTerms = {
248
- redeemers: BytesLike[];
304
+ type RedeemerTerms<TBytesLike extends BytesLike = BytesLike> = {
305
+ redeemers: TBytesLike[];
249
306
  };
250
307
  declare function createRedeemerTerms(terms: RedeemerTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
251
308
  declare function createRedeemerTerms(terms: RedeemerTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
309
+ declare function decodeRedeemerTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): RedeemerTerms<DecodedBytesLike<'hex'>>;
310
+ declare function decodeRedeemerTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): RedeemerTerms<DecodedBytesLike<'bytes'>>;
252
311
 
253
- type SpecificActionERC20TransferBatchTerms = {
254
- tokenAddress: BytesLike;
255
- recipient: BytesLike;
312
+ type SpecificActionERC20TransferBatchTerms<TBytesLike extends BytesLike = BytesLike> = {
313
+ tokenAddress: TBytesLike;
314
+ recipient: TBytesLike;
256
315
  amount: bigint;
257
- target: BytesLike;
258
- calldata: BytesLike;
316
+ target: TBytesLike;
317
+ calldata: TBytesLike;
259
318
  };
260
319
  declare function createSpecificActionERC20TransferBatchTerms(terms: SpecificActionERC20TransferBatchTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
261
320
  declare function createSpecificActionERC20TransferBatchTerms(terms: SpecificActionERC20TransferBatchTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
321
+ declare function decodeSpecificActionERC20TransferBatchTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): SpecificActionERC20TransferBatchTerms<DecodedBytesLike<'hex'>>;
322
+ declare function decodeSpecificActionERC20TransferBatchTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): SpecificActionERC20TransferBatchTerms<DecodedBytesLike<'bytes'>>;
323
+
324
+ type LogicalOrWrapperTerms<TBytesLike extends BytesLike = BytesLike> = {
325
+ caveatGroups: CaveatStruct<TBytesLike>[][];
326
+ };
327
+ type LogicalOrWrapperArgs<TBytesLike extends BytesLike = BytesLike> = {
328
+ groupIndex: bigint;
329
+ caveatArgs: TBytesLike[];
330
+ };
331
+ declare function createLogicalOrWrapperTerms(terms: LogicalOrWrapperTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
332
+ declare function createLogicalOrWrapperTerms(terms: LogicalOrWrapperTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
333
+ declare function decodeLogicalOrWrapperTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): LogicalOrWrapperTerms<DecodedBytesLike<'hex'>>;
334
+ declare function decodeLogicalOrWrapperTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): LogicalOrWrapperTerms<DecodedBytesLike<'bytes'>>;
335
+ declare function createLogicalOrWrapperArgs(args: LogicalOrWrapperArgs, encodingOptions?: EncodingOptions<'hex'>): Hex;
336
+ declare function createLogicalOrWrapperArgs(args: LogicalOrWrapperArgs, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
337
+ declare function decodeLogicalOrWrapperArgs(args: BytesLike, encodingOptions?: EncodingOptions<'hex'>): LogicalOrWrapperArgs<DecodedBytesLike<'hex'>>;
338
+ declare function decodeLogicalOrWrapperArgs(args: BytesLike, encodingOptions: EncodingOptions<'bytes'>): LogicalOrWrapperArgs<DecodedBytesLike<'bytes'>>;
262
339
 
263
340
  declare const ANY_BENEFICIARY: "0x0000000000000000000000000000000000000a11";
264
341
  declare const ROOT_AUTHORITY: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
@@ -275,4 +352,4 @@ declare function decodeDelegation(encoded: BytesLike, options: EncodingOptions<'
275
352
  declare function hashDelegation(delegation: DelegationStruct, options?: EncodingOptions<'hex'>): Hex;
276
353
  declare function hashDelegation(delegation: DelegationStruct, options: EncodingOptions<'bytes'>): Uint8Array;
277
354
 
278
- export { ANY_BENEFICIARY, CAVEAT_TYPEHASH, type CaveatStruct as Caveat, DELEGATION_TYPEHASH, type DelegationStruct as Delegation, ROOT_AUTHORITY, createAllowedCalldataTerms, createAllowedMethodsTerms, createAllowedTargetsTerms, createArgsEqualityCheckTerms, createBlockNumberTerms, createDeployedTerms, createERC1155BalanceChangeTerms, createERC20BalanceChangeTerms, createERC20StreamingTerms, createERC20TokenPeriodTransferTerms, createERC20TransferAmountTerms, createERC721BalanceChangeTerms, createERC721TransferTerms, createExactCalldataBatchTerms, createExactCalldataTerms, createExactExecutionBatchTerms, createExactExecutionTerms, createIdTerms, createLimitedCallsTerms, createMultiTokenPeriodTerms, createNativeBalanceChangeTerms, createNativeTokenPaymentTerms, createNativeTokenPeriodTransferTerms, createNativeTokenStreamingTerms, createNativeTokenTransferAmountTerms, createNonceTerms, createOwnershipTransferTerms, createRedeemerTerms, createSpecificActionERC20TransferBatchTerms, createTimestampTerms, createValueLteTerms, decodeDelegation, decodeDelegations, encodeDelegation, encodeDelegations, hashDelegation };
355
+ export { ANY_BENEFICIARY, BalanceChangeType, CAVEAT_TYPEHASH, type CaveatStruct as Caveat, DELEGATION_TYPEHASH, type DelegationStruct as Delegation, ROOT_AUTHORITY, createAllowedCalldataTerms, createAllowedMethodsTerms, createAllowedTargetsTerms, createArgsEqualityCheckTerms, createBlockNumberTerms, createDeployedTerms, createERC1155BalanceChangeTerms, createERC20BalanceChangeTerms, createERC20StreamingTerms, createERC20TokenPeriodTransferTerms, createERC20TransferAmountTerms, createERC721BalanceChangeTerms, createERC721TransferTerms, createExactCalldataBatchTerms, createExactCalldataTerms, createExactExecutionBatchTerms, createExactExecutionTerms, createIdTerms, createLimitedCallsTerms, createLogicalOrWrapperArgs, createLogicalOrWrapperTerms, createMultiTokenPeriodTerms, createNativeBalanceChangeTerms, createNativeTokenPaymentTerms, createNativeTokenPeriodTransferTerms, createNativeTokenStreamingTerms, createNativeTokenTransferAmountTerms, createNonceTerms, createOwnershipTransferTerms, createRedeemerTerms, createSpecificActionERC20TransferBatchTerms, createTimestampTerms, createValueLteTerms, decodeAllowedCalldataTerms, decodeAllowedMethodsTerms, decodeAllowedTargetsTerms, decodeArgsEqualityCheckTerms, decodeBlockNumberTerms, decodeDelegation, decodeDelegations, decodeDeployedTerms, decodeERC1155BalanceChangeTerms, decodeERC20BalanceChangeTerms, decodeERC20StreamingTerms, decodeERC20TokenPeriodTransferTerms, decodeERC20TransferAmountTerms, decodeERC721BalanceChangeTerms, decodeERC721TransferTerms, decodeExactCalldataBatchTerms, decodeExactCalldataTerms, decodeExactExecutionBatchTerms, decodeExactExecutionTerms, decodeIdTerms, decodeLimitedCallsTerms, decodeLogicalOrWrapperArgs, decodeLogicalOrWrapperTerms, decodeMultiTokenPeriodTerms, decodeNativeBalanceChangeTerms, decodeNativeTokenPaymentTerms, decodeNativeTokenPeriodTransferTerms, decodeNativeTokenStreamingTerms, decodeNativeTokenTransferAmountTerms, decodeNonceTerms, decodeOwnershipTransferTerms, decodeRedeemerTerms, decodeSpecificActionERC20TransferBatchTerms, decodeTimestampTerms, decodeValueLteTerms, encodeDelegation, encodeDelegations, hashDelegation };