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