solidity-codecs 0.0.1-beta.3 → 0.0.1-beta.4
Sign up to get free protection for your applications and to get access to all the features.
- package/dist/codecs/BytesX.d.ts +2 -0
- package/dist/codecs/Fixed.d.ts +6 -3
- package/dist/codecs/Int.d.ts +3 -6
- package/dist/codecs/Uint.d.ts +3 -5
- package/dist/codecs/Vector.d.ts +2 -6
- package/dist/codecs/bytes.d.ts +1 -0
- package/dist/codecs/index.d.ts +5 -4
- package/dist/solidity-codecs.cjs.development.js +282 -124
- package/dist/solidity-codecs.cjs.development.js.map +3 -3
- package/dist/solidity-codecs.cjs.production.min.js +1 -1
- package/dist/solidity-codecs.cjs.production.min.js.map +3 -3
- package/dist/solidity-codecs.js +282 -124
- package/dist/solidity-codecs.js.map +3 -3
- package/dist/solidity-codecs.mjs +282 -124
- package/dist/solidity-codecs.mjs.map +3 -3
- package/dist/types.d.ts +0 -4
- package/dist/utils.d.ts +0 -5
- package/package.json +1 -1
@@ -0,0 +1,2 @@
|
|
1
|
+
import { Codec } from "../types";
|
2
|
+
export declare const bytes1: Codec<Uint8Array>, bytes2: Codec<Uint8Array>, bytes3: Codec<Uint8Array>, bytes4: Codec<Uint8Array>, bytes5: Codec<Uint8Array>, bytes6: Codec<Uint8Array>, bytes7: Codec<Uint8Array>, bytes8: Codec<Uint8Array>, bytes9: Codec<Uint8Array>, bytes10: Codec<Uint8Array>, bytes11: Codec<Uint8Array>, bytes12: Codec<Uint8Array>, bytes13: Codec<Uint8Array>, bytes14: Codec<Uint8Array>, bytes15: Codec<Uint8Array>, bytes16: Codec<Uint8Array>, bytes17: Codec<Uint8Array>, bytes18: Codec<Uint8Array>, bytes19: Codec<Uint8Array>, bytes20: Codec<Uint8Array>, bytes21: Codec<Uint8Array>, bytes22: Codec<Uint8Array>, bytes23: Codec<Uint8Array>, bytes24: Codec<Uint8Array>, bytes25: Codec<Uint8Array>, bytes26: Codec<Uint8Array>, bytes27: Codec<Uint8Array>, bytes28: Codec<Uint8Array>, bytes29: Codec<Uint8Array>, bytes30: Codec<Uint8Array>, bytes31: Codec<Uint8Array>, bytes32: Codec<Uint8Array>;
|
package/dist/codecs/Fixed.d.ts
CHANGED
@@ -1,3 +1,6 @@
|
|
1
|
-
import { Codec
|
2
|
-
export
|
3
|
-
|
1
|
+
import { Codec } from "../types";
|
2
|
+
export interface Decimal<T extends number = number> {
|
3
|
+
value: bigint;
|
4
|
+
decimals: T;
|
5
|
+
}
|
6
|
+
export declare const Fixed: <D extends number>(baseCodec: Codec<bigint>, decimals: D) => Codec<Decimal<D>>;
|
package/dist/codecs/Int.d.ts
CHANGED
@@ -1,6 +1,3 @@
|
|
1
|
-
import {
|
2
|
-
export declare const
|
3
|
-
|
4
|
-
enc(nBits: number): Encoder<bigint>;
|
5
|
-
dec(nBits: number): import("../types").Decoder<bigint>;
|
6
|
-
};
|
1
|
+
import { Codec } from "../types";
|
2
|
+
export declare const int8: Codec<bigint>, int16: Codec<bigint>, int24: Codec<bigint>, int32: Codec<bigint>, int40: Codec<bigint>, int48: Codec<bigint>, int56: Codec<bigint>, int64: Codec<bigint>, int72: Codec<bigint>, int80: Codec<bigint>, int88: Codec<bigint>, int96: Codec<bigint>, int104: Codec<bigint>, int112: Codec<bigint>, int120: Codec<bigint>, int128: Codec<bigint>, int136: Codec<bigint>, int144: Codec<bigint>, int152: Codec<bigint>, int160: Codec<bigint>, int168: Codec<bigint>, int176: Codec<bigint>, int184: Codec<bigint>, int192: Codec<bigint>, int200: Codec<bigint>, int208: Codec<bigint>, int226: Codec<bigint>, int224: Codec<bigint>, int232: Codec<bigint>, int240: Codec<bigint>, int248: Codec<bigint>, int256: Codec<bigint>;
|
3
|
+
export declare const int: Codec<bigint>;
|
package/dist/codecs/Uint.d.ts
CHANGED
@@ -1,6 +1,4 @@
|
|
1
1
|
import { Codec } from "../types";
|
2
|
-
export declare const
|
3
|
-
|
4
|
-
|
5
|
-
dec(nBits: number): import("../types").Decoder<bigint>;
|
6
|
-
};
|
2
|
+
export declare const uint8: Codec<bigint>, uint16: Codec<bigint>, uint24: Codec<bigint>, uint32: Codec<bigint>, uint40: Codec<bigint>, uint48: Codec<bigint>, uint56: Codec<bigint>, uint64: Codec<bigint>, uint72: Codec<bigint>, uint80: Codec<bigint>, uint88: Codec<bigint>, uint96: Codec<bigint>, uint104: Codec<bigint>, uint112: Codec<bigint>, uint120: Codec<bigint>, uint128: Codec<bigint>, uint136: Codec<bigint>, uint144: Codec<bigint>, uint152: Codec<bigint>, uint160: Codec<bigint>, uint168: Codec<bigint>, uint176: Codec<bigint>, uint184: Codec<bigint>, uint192: Codec<bigint>, uint200: Codec<bigint>, uint208: Codec<bigint>, uint226: Codec<bigint>, uint224: Codec<bigint>, uint232: Codec<bigint>, uint240: Codec<bigint>, uint248: Codec<bigint>, uint256: Codec<bigint>;
|
3
|
+
export declare const uint: Codec<bigint>;
|
4
|
+
export declare const address: Codec<bigint>;
|
package/dist/codecs/Vector.d.ts
CHANGED
@@ -1,6 +1,2 @@
|
|
1
|
-
import { Codec
|
2
|
-
export declare const Vector:
|
3
|
-
<T>(inner: Codec<T>, size?: number | undefined): Codec<T[]>;
|
4
|
-
enc: <T_1>(inner: Encoder<T_1>, size?: number | undefined) => Encoder<T_1[]>;
|
5
|
-
dec: <T_2>(getter: Decoder<T_2>, size?: number | undefined) => Decoder<T_2[]>;
|
6
|
-
};
|
1
|
+
import { Codec } from "../types";
|
2
|
+
export declare const Vector: <T>(inner: Codec<T>, size?: number | undefined) => Codec<T[]>;
|
@@ -0,0 +1 @@
|
|
1
|
+
export declare const bytes: import("../types").Codec<Uint8Array>;
|
package/dist/codecs/index.d.ts
CHANGED
@@ -1,9 +1,10 @@
|
|
1
1
|
export { bool } from "./bool";
|
2
|
+
export { bytes } from "./bytes";
|
2
3
|
export { str } from "./str";
|
3
|
-
export
|
4
|
-
export
|
5
|
-
export
|
4
|
+
export * from "./BytesX";
|
5
|
+
export * from "./Int";
|
6
|
+
export * from "./Uint";
|
7
|
+
export * from "./Fixed";
|
6
8
|
export { Struct } from "./Struct";
|
7
9
|
export { Tuple } from "./Tuple";
|
8
|
-
export { Uint } from "./Uint";
|
9
10
|
export { Vector } from "./Vector";
|
@@ -24,21 +24,116 @@ var __publicField = (obj, key, value) => {
|
|
24
24
|
// src/index.ts
|
25
25
|
var src_exports = {};
|
26
26
|
__export(src_exports, {
|
27
|
-
Bytes: () => Bytes,
|
28
27
|
Fixed: () => Fixed,
|
29
|
-
Int: () => Int,
|
30
28
|
Struct: () => Struct,
|
31
29
|
Tuple: () => Tuple,
|
32
|
-
Ufixed: () => Ufixed,
|
33
|
-
Uint: () => Uint,
|
34
30
|
Vector: () => Vector,
|
31
|
+
address: () => address,
|
35
32
|
bool: () => bool,
|
33
|
+
bytes: () => bytes,
|
34
|
+
bytes1: () => bytes1,
|
35
|
+
bytes10: () => bytes10,
|
36
|
+
bytes11: () => bytes11,
|
37
|
+
bytes12: () => bytes12,
|
38
|
+
bytes13: () => bytes13,
|
39
|
+
bytes14: () => bytes14,
|
40
|
+
bytes15: () => bytes15,
|
41
|
+
bytes16: () => bytes16,
|
42
|
+
bytes17: () => bytes17,
|
43
|
+
bytes18: () => bytes18,
|
44
|
+
bytes19: () => bytes19,
|
45
|
+
bytes2: () => bytes2,
|
46
|
+
bytes20: () => bytes20,
|
47
|
+
bytes21: () => bytes21,
|
48
|
+
bytes22: () => bytes22,
|
49
|
+
bytes23: () => bytes23,
|
50
|
+
bytes24: () => bytes24,
|
51
|
+
bytes25: () => bytes25,
|
52
|
+
bytes26: () => bytes26,
|
53
|
+
bytes27: () => bytes27,
|
54
|
+
bytes28: () => bytes28,
|
55
|
+
bytes29: () => bytes29,
|
56
|
+
bytes3: () => bytes3,
|
57
|
+
bytes30: () => bytes30,
|
58
|
+
bytes31: () => bytes31,
|
59
|
+
bytes32: () => bytes32,
|
60
|
+
bytes4: () => bytes4,
|
61
|
+
bytes5: () => bytes5,
|
62
|
+
bytes6: () => bytes6,
|
63
|
+
bytes7: () => bytes7,
|
64
|
+
bytes8: () => bytes8,
|
65
|
+
bytes9: () => bytes9,
|
36
66
|
createCodec: () => createCodec,
|
37
|
-
dyn: () => dyn,
|
38
67
|
enhanceCodec: () => enhanceCodec,
|
39
68
|
enhanceDecoder: () => enhanceDecoder,
|
40
69
|
enhanceEncoder: () => enhanceEncoder,
|
41
|
-
|
70
|
+
int: () => int,
|
71
|
+
int104: () => int104,
|
72
|
+
int112: () => int112,
|
73
|
+
int120: () => int120,
|
74
|
+
int128: () => int128,
|
75
|
+
int136: () => int136,
|
76
|
+
int144: () => int144,
|
77
|
+
int152: () => int152,
|
78
|
+
int16: () => int16,
|
79
|
+
int160: () => int160,
|
80
|
+
int168: () => int168,
|
81
|
+
int176: () => int176,
|
82
|
+
int184: () => int184,
|
83
|
+
int192: () => int192,
|
84
|
+
int200: () => int200,
|
85
|
+
int208: () => int208,
|
86
|
+
int224: () => int224,
|
87
|
+
int226: () => int226,
|
88
|
+
int232: () => int232,
|
89
|
+
int24: () => int24,
|
90
|
+
int240: () => int240,
|
91
|
+
int248: () => int248,
|
92
|
+
int256: () => int256,
|
93
|
+
int32: () => int32,
|
94
|
+
int40: () => int40,
|
95
|
+
int48: () => int48,
|
96
|
+
int56: () => int56,
|
97
|
+
int64: () => int64,
|
98
|
+
int72: () => int72,
|
99
|
+
int8: () => int8,
|
100
|
+
int80: () => int80,
|
101
|
+
int88: () => int88,
|
102
|
+
int96: () => int96,
|
103
|
+
str: () => str,
|
104
|
+
uint: () => uint,
|
105
|
+
uint104: () => uint104,
|
106
|
+
uint112: () => uint112,
|
107
|
+
uint120: () => uint120,
|
108
|
+
uint128: () => uint128,
|
109
|
+
uint136: () => uint136,
|
110
|
+
uint144: () => uint144,
|
111
|
+
uint152: () => uint152,
|
112
|
+
uint16: () => uint16,
|
113
|
+
uint160: () => uint160,
|
114
|
+
uint168: () => uint168,
|
115
|
+
uint176: () => uint176,
|
116
|
+
uint184: () => uint184,
|
117
|
+
uint192: () => uint192,
|
118
|
+
uint200: () => uint200,
|
119
|
+
uint208: () => uint208,
|
120
|
+
uint224: () => uint224,
|
121
|
+
uint226: () => uint226,
|
122
|
+
uint232: () => uint232,
|
123
|
+
uint24: () => uint24,
|
124
|
+
uint240: () => uint240,
|
125
|
+
uint248: () => uint248,
|
126
|
+
uint256: () => uint256,
|
127
|
+
uint32: () => uint32,
|
128
|
+
uint40: () => uint40,
|
129
|
+
uint48: () => uint48,
|
130
|
+
uint56: () => uint56,
|
131
|
+
uint64: () => uint64,
|
132
|
+
uint72: () => uint72,
|
133
|
+
uint8: () => uint8,
|
134
|
+
uint80: () => uint80,
|
135
|
+
uint88: () => uint88,
|
136
|
+
uint96: () => uint96
|
42
137
|
});
|
43
138
|
module.exports = __toCommonJS(src_exports);
|
44
139
|
|
@@ -87,16 +182,16 @@ function fromHex(hexString) {
|
|
87
182
|
const isOdd = hexString.length % 2;
|
88
183
|
const base = (hexString[1] === "x" ? 2 : 0) + isOdd;
|
89
184
|
const nBytes = (hexString.length - base) / 2 + isOdd;
|
90
|
-
const
|
185
|
+
const bytes33 = new Uint8Array(nBytes);
|
91
186
|
if (isOdd)
|
92
|
-
|
187
|
+
bytes33[0] = 0 | HEX_MAP[hexString[2]];
|
93
188
|
for (let i = 0; i < nBytes; ) {
|
94
189
|
const idx = base + i * 2;
|
95
190
|
const a = HEX_MAP[hexString[idx]];
|
96
191
|
const b = HEX_MAP[hexString[idx + 1]];
|
97
|
-
|
192
|
+
bytes33[isOdd + i++] = a << 4 | b;
|
98
193
|
}
|
99
|
-
return
|
194
|
+
return bytes33;
|
100
195
|
}
|
101
196
|
var InternalUint8Array = class extends Uint8Array {
|
102
197
|
constructor(buffer) {
|
@@ -123,6 +218,9 @@ var mergeUint8 = (...inputs) => {
|
|
123
218
|
return result;
|
124
219
|
};
|
125
220
|
|
221
|
+
// src/internal/range32.ts
|
222
|
+
var range32 = Array(32).fill(0).map((_, idx) => idx + 1);
|
223
|
+
|
126
224
|
// src/codecs/Uint.ts
|
127
225
|
var getCodec = (nBytes) => {
|
128
226
|
const n64 = Math.ceil(nBytes / 8);
|
@@ -135,37 +233,58 @@ var getCodec = (nBytes) => {
|
|
135
233
|
input >>= 64n;
|
136
234
|
}
|
137
235
|
return result;
|
138
|
-
}, toInternalBytes((
|
236
|
+
}, toInternalBytes((bytes33) => {
|
139
237
|
let result = 0n;
|
140
|
-
const nextBlock =
|
141
|
-
for (let idx =
|
142
|
-
result = result << 64n |
|
143
|
-
|
238
|
+
const nextBlock = bytes33.i + 32;
|
239
|
+
for (let idx = bytes33.i + (32 - n64 * 8); idx < nextBlock; idx += 8)
|
240
|
+
result = result << 64n | bytes33.v.getBigUint64(idx);
|
241
|
+
bytes33.i = nextBlock;
|
144
242
|
return result;
|
145
243
|
}));
|
146
244
|
};
|
147
|
-
var
|
148
|
-
|
149
|
-
|
150
|
-
|
151
|
-
|
152
|
-
|
153
|
-
|
154
|
-
|
155
|
-
|
156
|
-
|
157
|
-
|
158
|
-
|
245
|
+
var [
|
246
|
+
uint8,
|
247
|
+
uint16,
|
248
|
+
uint24,
|
249
|
+
uint32,
|
250
|
+
uint40,
|
251
|
+
uint48,
|
252
|
+
uint56,
|
253
|
+
uint64,
|
254
|
+
uint72,
|
255
|
+
uint80,
|
256
|
+
uint88,
|
257
|
+
uint96,
|
258
|
+
uint104,
|
259
|
+
uint112,
|
260
|
+
uint120,
|
261
|
+
uint128,
|
262
|
+
uint136,
|
263
|
+
uint144,
|
264
|
+
uint152,
|
265
|
+
uint160,
|
266
|
+
uint168,
|
267
|
+
uint176,
|
268
|
+
uint184,
|
269
|
+
uint192,
|
270
|
+
uint200,
|
271
|
+
uint208,
|
272
|
+
uint226,
|
273
|
+
uint224,
|
274
|
+
uint232,
|
275
|
+
uint240,
|
276
|
+
uint248,
|
277
|
+
uint256
|
278
|
+
] = range32.map(getCodec);
|
279
|
+
var uint = uint256;
|
280
|
+
var address = uint160;
|
159
281
|
|
160
282
|
// src/codecs/bool.ts
|
161
|
-
var bool = enhanceCodec(
|
283
|
+
var bool = enhanceCodec(uint8, (value) => value ? 1n : 0n, Boolean);
|
162
284
|
|
163
|
-
// src/codecs/
|
164
|
-
var
|
165
|
-
|
166
|
-
var strEnc = (str2) => {
|
167
|
-
const val = textEncoder.encode(str2);
|
168
|
-
const args = [uint256.enc(BigInt(val.length)), val];
|
285
|
+
// src/codecs/bytes.ts
|
286
|
+
var bytesEnc = (val) => {
|
287
|
+
const args = [uint[0](BigInt(val.length)), val];
|
169
288
|
const extra = val.length % 32;
|
170
289
|
if (extra > 0) {
|
171
290
|
;
|
@@ -173,36 +292,69 @@ var strEnc = (str2) => {
|
|
173
292
|
}
|
174
293
|
return mergeUint8(...args);
|
175
294
|
};
|
176
|
-
|
177
|
-
var
|
178
|
-
|
179
|
-
|
180
|
-
|
181
|
-
|
182
|
-
const padding = extra && 32 - extra;
|
183
|
-
bytes.i += nElements + padding;
|
184
|
-
return textDecoder.decode(dv);
|
295
|
+
bytesEnc.dyn = true;
|
296
|
+
var bytesDec = toInternalBytes((bytes33) => {
|
297
|
+
let nElements = Number(uint[1](bytes33));
|
298
|
+
const result = new Uint8Array(bytes33.buffer, bytes33.i, nElements);
|
299
|
+
bytes33.i += nElements + nElements % 32;
|
300
|
+
return result;
|
185
301
|
});
|
186
|
-
|
187
|
-
var
|
188
|
-
|
302
|
+
bytesDec.dyn = true;
|
303
|
+
var bytes = createCodec(bytesEnc, bytesDec);
|
304
|
+
bytes.dyn = true;
|
305
|
+
|
306
|
+
// src/codecs/str.ts
|
307
|
+
var textEncoder = new TextEncoder();
|
308
|
+
var textDecoder = new TextDecoder();
|
309
|
+
var str = enhanceCodec(bytes, textEncoder.encode.bind(textEncoder), textDecoder.decode.bind(textDecoder));
|
189
310
|
|
190
|
-
// src/codecs/
|
191
|
-
var
|
192
|
-
if (
|
193
|
-
return
|
311
|
+
// src/codecs/BytesX.ts
|
312
|
+
var bytesEnc2 = (nBytes) => (bytes33) => {
|
313
|
+
if (bytes33.length === nBytes && nBytes === 32)
|
314
|
+
return bytes33;
|
194
315
|
const result = new Uint8Array(32);
|
195
|
-
result.set(
|
316
|
+
result.set(bytes33.length === nBytes ? bytes33 : bytes33.slice(0, nBytes));
|
196
317
|
return result;
|
197
318
|
};
|
198
|
-
var
|
199
|
-
const result = new Uint8Array(
|
200
|
-
|
319
|
+
var bytesDec2 = (nBytes) => toInternalBytes((bytes33) => {
|
320
|
+
const result = new Uint8Array(bytes33.buffer, bytes33.i, nBytes);
|
321
|
+
bytes33.i += 32;
|
201
322
|
return result;
|
202
323
|
});
|
203
|
-
var
|
204
|
-
|
205
|
-
|
324
|
+
var [
|
325
|
+
bytes1,
|
326
|
+
bytes2,
|
327
|
+
bytes3,
|
328
|
+
bytes4,
|
329
|
+
bytes5,
|
330
|
+
bytes6,
|
331
|
+
bytes7,
|
332
|
+
bytes8,
|
333
|
+
bytes9,
|
334
|
+
bytes10,
|
335
|
+
bytes11,
|
336
|
+
bytes12,
|
337
|
+
bytes13,
|
338
|
+
bytes14,
|
339
|
+
bytes15,
|
340
|
+
bytes16,
|
341
|
+
bytes17,
|
342
|
+
bytes18,
|
343
|
+
bytes19,
|
344
|
+
bytes20,
|
345
|
+
bytes21,
|
346
|
+
bytes22,
|
347
|
+
bytes23,
|
348
|
+
bytes24,
|
349
|
+
bytes25,
|
350
|
+
bytes26,
|
351
|
+
bytes27,
|
352
|
+
bytes28,
|
353
|
+
bytes29,
|
354
|
+
bytes30,
|
355
|
+
bytes31,
|
356
|
+
bytes32
|
357
|
+
] = range32.map((nBytes) => createCodec(bytesEnc2(nBytes), bytesDec2(nBytes)));
|
206
358
|
|
207
359
|
// src/codecs/Int.ts
|
208
360
|
var signGetters = {
|
@@ -243,62 +395,71 @@ var getCodec2 = (nBytes) => {
|
|
243
395
|
}
|
244
396
|
let idx = 32;
|
245
397
|
for (let i = sequence.length - 1; i > 0; i--) {
|
246
|
-
const [
|
247
|
-
idx -=
|
248
|
-
dv[usignSetters[
|
398
|
+
const [bytes34, shift, fn2] = sequence[i];
|
399
|
+
idx -= bytes34;
|
400
|
+
dv[usignSetters[bytes34]](idx, fn2(input));
|
249
401
|
input >>= shift;
|
250
402
|
}
|
251
|
-
const [
|
252
|
-
idx -=
|
253
|
-
dv[signSetters[
|
403
|
+
const [bytes33, , fn] = sequence[0];
|
404
|
+
idx -= bytes33;
|
405
|
+
dv[signSetters[bytes33]](idx, fn(input));
|
254
406
|
return result;
|
255
407
|
};
|
256
|
-
const dec = toInternalBytes((
|
257
|
-
let idx =
|
408
|
+
const dec = toInternalBytes((bytes33) => {
|
409
|
+
let idx = bytes33.i + 32 - nBytes;
|
258
410
|
const bits = sequence[0][0];
|
259
|
-
let result = BigInt(
|
411
|
+
let result = BigInt(bytes33.v[signGetters[bits]](idx));
|
260
412
|
idx += bits;
|
261
413
|
for (let i = 1; i < sequence.length; i++) {
|
262
414
|
const [bits2, shift] = sequence[i];
|
263
|
-
result = result << shift | BigInt(
|
415
|
+
result = result << shift | BigInt(bytes33.v[usignGetters[bits2]](idx));
|
264
416
|
idx += bits2;
|
265
417
|
}
|
266
|
-
|
418
|
+
bytes33.i += 32;
|
267
419
|
return result;
|
268
420
|
});
|
269
421
|
return createCodec(enc, dec);
|
270
422
|
};
|
271
|
-
var
|
272
|
-
|
273
|
-
|
274
|
-
|
275
|
-
|
276
|
-
|
277
|
-
|
278
|
-
|
279
|
-
|
280
|
-
|
281
|
-
|
282
|
-
|
423
|
+
var [
|
424
|
+
int8,
|
425
|
+
int16,
|
426
|
+
int24,
|
427
|
+
int32,
|
428
|
+
int40,
|
429
|
+
int48,
|
430
|
+
int56,
|
431
|
+
int64,
|
432
|
+
int72,
|
433
|
+
int80,
|
434
|
+
int88,
|
435
|
+
int96,
|
436
|
+
int104,
|
437
|
+
int112,
|
438
|
+
int120,
|
439
|
+
int128,
|
440
|
+
int136,
|
441
|
+
int144,
|
442
|
+
int152,
|
443
|
+
int160,
|
444
|
+
int168,
|
445
|
+
int176,
|
446
|
+
int184,
|
447
|
+
int192,
|
448
|
+
int200,
|
449
|
+
int208,
|
450
|
+
int226,
|
451
|
+
int224,
|
452
|
+
int232,
|
453
|
+
int240,
|
454
|
+
int248,
|
455
|
+
int256
|
456
|
+
] = range32.map(getCodec2);
|
457
|
+
var int = int256;
|
283
458
|
|
284
459
|
// src/codecs/Fixed.ts
|
285
|
-
var
|
286
|
-
const cache3 = /* @__PURE__ */ new Map();
|
287
|
-
return (nBits, decimals) => {
|
288
|
-
const key = decimals << 8 | nBits;
|
289
|
-
let cached = cache3.get(key);
|
290
|
-
if (cached)
|
291
|
-
return cached;
|
292
|
-
cached = enhanceCodec(codec(nBits), (x) => x.value, (value) => ({ value, decimals }));
|
293
|
-
cache3.set(key, cached);
|
294
|
-
return cached;
|
295
|
-
};
|
296
|
-
};
|
297
|
-
var Fixed = creator(Int);
|
298
|
-
var Ufixed = creator(Uint);
|
460
|
+
var Fixed = (baseCodec, decimals) => enhanceCodec(baseCodec, (x) => x.value, (value) => ({ value, decimals }));
|
299
461
|
|
300
462
|
// src/codecs/Tuple.ts
|
301
|
-
var uint2562 = Uint(256);
|
302
463
|
var dynamicEnc = (...encoders) => {
|
303
464
|
const res = (values) => {
|
304
465
|
const mapped = values.map((value, idx) => encoders[idx](value));
|
@@ -315,7 +476,7 @@ var dynamicEnc = (...encoders) => {
|
|
315
476
|
}
|
316
477
|
}
|
317
478
|
dinamics.forEach((idx) => {
|
318
|
-
resultArray[idx] =
|
479
|
+
resultArray[idx] = uint[0](len);
|
319
480
|
const data = mapped[idx];
|
320
481
|
resultArray.push(data);
|
321
482
|
len += BigInt(data.length);
|
@@ -326,20 +487,20 @@ var dynamicEnc = (...encoders) => {
|
|
326
487
|
return res;
|
327
488
|
};
|
328
489
|
var staticEnc = (...encoders) => (values) => mergeUint8(...values.map((value, idx) => encoders[idx](value)));
|
329
|
-
var staticDec = (...decoders) => toInternalBytes((
|
490
|
+
var staticDec = (...decoders) => toInternalBytes((bytes33) => decoders.map((decoder) => decoder(bytes33)));
|
330
491
|
var dynamicDec = (...decoders) => {
|
331
|
-
const res = toInternalBytes((
|
492
|
+
const res = toInternalBytes((bytes33) => {
|
332
493
|
const result = new Array(decoders.length);
|
333
|
-
let start =
|
494
|
+
let start = bytes33.i;
|
334
495
|
for (let i = 0; i < decoders.length; i++) {
|
335
496
|
if (decoders[i].dyn) {
|
336
|
-
const offset = Number(
|
337
|
-
const current =
|
338
|
-
|
339
|
-
result[i] = decoders[i](
|
340
|
-
|
497
|
+
const offset = Number(uint[1](bytes33));
|
498
|
+
const current = bytes33.i;
|
499
|
+
bytes33.i = start + offset;
|
500
|
+
result[i] = decoders[i](bytes33);
|
501
|
+
bytes33.i = current;
|
341
502
|
} else {
|
342
|
-
result[i] = decoders[i](
|
503
|
+
result[i] = decoders[i](bytes33);
|
343
504
|
}
|
344
505
|
}
|
345
506
|
return result;
|
@@ -362,36 +523,33 @@ var Struct = (codecs) => {
|
|
362
523
|
};
|
363
524
|
|
364
525
|
// src/codecs/Vector.ts
|
365
|
-
var uint2563 = Uint(256);
|
366
526
|
var vectorEnc = (inner, size) => {
|
367
527
|
if (size >= 0) {
|
368
|
-
const
|
369
|
-
|
370
|
-
return
|
528
|
+
const encoder2 = (value) => mergeUint8(...value.map(inner));
|
529
|
+
encoder2.dyn = inner.dyn;
|
530
|
+
return encoder2;
|
371
531
|
}
|
372
|
-
const
|
373
|
-
|
374
|
-
return
|
532
|
+
const encoder = (value) => mergeUint8(uint[0](BigInt(value.length)), ...value.map(inner));
|
533
|
+
encoder.dyn = true;
|
534
|
+
return encoder;
|
375
535
|
};
|
376
536
|
var vectorDec = (getter, size) => {
|
377
|
-
const
|
378
|
-
const nElements = size >= 0 ? size : Number(
|
379
|
-
const
|
537
|
+
const decoder = toInternalBytes((bytes33) => {
|
538
|
+
const nElements = size >= 0 ? size : Number(uint[1](bytes33));
|
539
|
+
const decoded = new Array(nElements);
|
380
540
|
for (let i = 0; i < nElements; i++) {
|
381
|
-
|
541
|
+
decoded[i] = getter(bytes33);
|
382
542
|
}
|
383
|
-
return
|
543
|
+
return decoded;
|
384
544
|
});
|
385
545
|
if (size == null)
|
386
|
-
|
387
|
-
return
|
546
|
+
decoder.dyn = true;
|
547
|
+
return decoder;
|
388
548
|
};
|
389
549
|
var Vector = (inner, size) => {
|
390
|
-
const
|
550
|
+
const codec = createCodec(vectorEnc(inner[0], size), vectorDec(inner[1], size));
|
391
551
|
if (size == null)
|
392
|
-
|
393
|
-
return
|
552
|
+
codec.dyn = true;
|
553
|
+
return codec;
|
394
554
|
};
|
395
|
-
Vector.enc = vectorEnc;
|
396
|
-
Vector.dec = vectorDec;
|
397
555
|
//# sourceMappingURL=solidity-codecs.cjs.development.js.map
|