solidity-codecs 0.0.1-beta.2 → 0.0.1-beta.3
Sign up to get free protection for your applications and to get access to all the features.
- package/dist/codecs/Bytes.d.ts +5 -5
- package/dist/codecs/Fixed.d.ts +3 -0
- package/dist/codecs/{int.d.ts → Int.d.ts} +1 -1
- package/dist/codecs/Struct.d.ts +2 -25
- package/dist/codecs/Tuple.d.ts +2 -25
- package/dist/codecs/Uint.d.ts +6 -0
- package/dist/codecs/Vector.d.ts +6 -14
- package/dist/codecs/index.d.ts +7 -8
- package/dist/solidity-codecs.cjs.development.js +159 -166
- 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 +159 -166
- package/dist/solidity-codecs.js.map +3 -3
- package/dist/solidity-codecs.mjs +159 -166
- package/dist/solidity-codecs.mjs.map +3 -3
- package/dist/types.d.ts +4 -4
- package/dist/utils.d.ts +6 -1
- package/package.json +1 -1
- package/dist/codecs/Enum.d.ts +0 -57
- package/dist/codecs/Option.d.ts +0 -6
- package/dist/codecs/Result.d.ts +0 -22
- package/dist/codecs/bytes.d.ts +0 -6
- package/dist/codecs/call.d.ts +0 -6
- package/dist/codecs/compact.d.ts +0 -2
- package/dist/codecs/fixed-width-ints.d.ts +0 -11
- package/dist/codecs/fixed.d.ts +0 -3
- package/dist/codecs/struct.d.ts +0 -6
- package/dist/codecs/tuple.d.ts +0 -6
- package/dist/codecs/uint.d.ts +0 -2
- package/dist/codecs/vector.d.ts +0 -6
- package/dist/codecs/void.d.ts +0 -2
- package/dist/scale-ts.cjs.development.js +0 -427
- package/dist/scale-ts.cjs.development.js.map +0 -7
- package/dist/scale-ts.cjs.production.min.js +0 -318
- package/dist/scale-ts.cjs.production.min.js.map +0 -7
- package/dist/scale-ts.es2017.js +0 -403
- package/dist/scale-ts.es2017.js.map +0 -7
- package/dist/scale-ts.es2019.mjs +0 -348
- package/dist/scale-ts.es2019.mjs.map +0 -7
- package/dist/test-utils.d.ts +0 -5
package/dist/codecs/Bytes.d.ts
CHANGED
@@ -1,6 +1,6 @@
|
|
1
|
-
import { Encoder, Decoder, Codec } from "../types"
|
1
|
+
import { Encoder, Decoder, Codec } from "../types";
|
2
2
|
export declare const Bytes: {
|
3
|
-
|
4
|
-
|
5
|
-
|
6
|
-
}
|
3
|
+
(nBytes: number): Codec<Uint8Array>;
|
4
|
+
enc: (nBytes: number) => Encoder<Uint8Array>;
|
5
|
+
dec: (nBytes: number) => Decoder<Uint8Array>;
|
6
|
+
};
|
package/dist/codecs/Struct.d.ts
CHANGED
@@ -1,25 +1,2 @@
|
|
1
|
-
import { Codec,
|
2
|
-
export declare const Struct: {
|
3
|
-
<
|
4
|
-
A extends StringRecord<Codec<any>>,
|
5
|
-
OT extends { [K in keyof A]: A[K] extends Codec<infer D> ? D : unknown },
|
6
|
-
>(
|
7
|
-
codecs: A,
|
8
|
-
): Codec<OT>
|
9
|
-
enc: <
|
10
|
-
A_1 extends StringRecord<Encoder<any>>,
|
11
|
-
OT_1 extends {
|
12
|
-
[K_1 in keyof A_1]: A_1[K_1] extends Encoder<infer D_1> ? D_1 : unknown
|
13
|
-
},
|
14
|
-
>(
|
15
|
-
encoders: A_1,
|
16
|
-
) => Encoder<OT_1>
|
17
|
-
dec: <
|
18
|
-
A_2 extends StringRecord<Decoder<any>>,
|
19
|
-
OT_2 extends {
|
20
|
-
[K_2 in keyof A_2]: A_2[K_2] extends Decoder<infer D_2> ? D_2 : unknown
|
21
|
-
},
|
22
|
-
>(
|
23
|
-
decoders: A_2,
|
24
|
-
) => Decoder<OT_2>
|
25
|
-
}
|
1
|
+
import { Codec, StringRecord } from "../types";
|
2
|
+
export declare const Struct: <A extends StringRecord<Codec<any>>, OT extends { [K in keyof A]: A[K] extends Codec<infer D> ? D : unknown; }>(codecs: A) => Codec<OT>;
|
package/dist/codecs/Tuple.d.ts
CHANGED
@@ -1,25 +1,2 @@
|
|
1
|
-
import { Codec
|
2
|
-
export declare const Tuple: {
|
3
|
-
<
|
4
|
-
A extends Codec<any>[],
|
5
|
-
OT extends { [K in keyof A]: A[K] extends Codec<infer D> ? D : unknown },
|
6
|
-
>(
|
7
|
-
...codecs: A
|
8
|
-
): Codec<[...OT]>
|
9
|
-
enc: <
|
10
|
-
A_1 extends Encoder<any>[],
|
11
|
-
OT_1 extends {
|
12
|
-
[K_1 in keyof A_1]: A_1[K_1] extends Encoder<infer D_1> ? D_1 : unknown
|
13
|
-
},
|
14
|
-
>(
|
15
|
-
...encoders: A_1
|
16
|
-
) => Encoder<[...OT_1]>
|
17
|
-
dec: <
|
18
|
-
A_2 extends Decoder<any>[],
|
19
|
-
OT_2 extends {
|
20
|
-
[K_2 in keyof A_2]: A_2[K_2] extends Decoder<infer D_2> ? D_2 : unknown
|
21
|
-
},
|
22
|
-
>(
|
23
|
-
...decoders: A_2
|
24
|
-
) => Decoder<[...OT_2]>
|
25
|
-
}
|
1
|
+
import { Codec } from "../types";
|
2
|
+
export declare const Tuple: <A extends Codec<any>[], OT extends { [K in keyof A]: A[K] extends Codec<infer D> ? D : unknown; }>(...codecs: A) => Codec<[...OT]>;
|
package/dist/codecs/Vector.d.ts
CHANGED
@@ -1,14 +1,6 @@
|
|
1
|
-
import { Codec, Decoder, Encoder } from "../types"
|
2
|
-
declare
|
3
|
-
|
4
|
-
|
5
|
-
|
6
|
-
|
7
|
-
inner: Codec<T>,
|
8
|
-
size?: number,
|
9
|
-
): Codec<Array<T>>
|
10
|
-
export declare namespace Vector {
|
11
|
-
var enc: <T>(inner: Encoder<T>, size?: number | undefined) => Encoder<T[]>
|
12
|
-
var dec: typeof VectorDec
|
13
|
-
}
|
14
|
-
export {}
|
1
|
+
import { Codec, Decoder, Encoder } from "../types";
|
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
|
+
};
|
package/dist/codecs/index.d.ts
CHANGED
@@ -1,10 +1,9 @@
|
|
1
1
|
export { bool } from "./bool";
|
2
2
|
export { str } from "./str";
|
3
|
-
export {
|
4
|
-
export {
|
5
|
-
export {
|
6
|
-
export {
|
7
|
-
export {
|
8
|
-
export {
|
9
|
-
export {
|
10
|
-
export { vector } from "./vector";
|
3
|
+
export { Bytes } from "./Bytes";
|
4
|
+
export { Fixed, Ufixed } from "./Fixed";
|
5
|
+
export { Int } from "./Int";
|
6
|
+
export { Struct } from "./Struct";
|
7
|
+
export { Tuple } from "./Tuple";
|
8
|
+
export { Uint } from "./Uint";
|
9
|
+
export { Vector } from "./Vector";
|
@@ -24,21 +24,21 @@ var __publicField = (obj, key, value) => {
|
|
24
24
|
// src/index.ts
|
25
25
|
var src_exports = {};
|
26
26
|
__export(src_exports, {
|
27
|
+
Bytes: () => Bytes,
|
28
|
+
Fixed: () => Fixed,
|
29
|
+
Int: () => Int,
|
30
|
+
Struct: () => Struct,
|
31
|
+
Tuple: () => Tuple,
|
32
|
+
Ufixed: () => Ufixed,
|
33
|
+
Uint: () => Uint,
|
34
|
+
Vector: () => Vector,
|
27
35
|
bool: () => bool,
|
28
|
-
bytes: () => bytes,
|
29
|
-
call: () => call,
|
30
36
|
createCodec: () => createCodec,
|
37
|
+
dyn: () => dyn,
|
31
38
|
enhanceCodec: () => enhanceCodec,
|
32
39
|
enhanceDecoder: () => enhanceDecoder,
|
33
40
|
enhanceEncoder: () => enhanceEncoder,
|
34
|
-
|
35
|
-
int: () => int,
|
36
|
-
str: () => str,
|
37
|
-
struct: () => struct,
|
38
|
-
tuple: () => tuple,
|
39
|
-
ufixed: () => ufixed,
|
40
|
-
uint: () => uint,
|
41
|
-
vector: () => vector
|
41
|
+
str: () => str
|
42
42
|
});
|
43
43
|
module.exports = __toCommonJS(src_exports);
|
44
44
|
|
@@ -49,9 +49,14 @@ var createCodec = (encoder, decoder) => {
|
|
49
49
|
result.dec = decoder;
|
50
50
|
return result;
|
51
51
|
};
|
52
|
-
var
|
53
|
-
|
54
|
-
|
52
|
+
var dyn = (input, output) => {
|
53
|
+
if (input.dyn)
|
54
|
+
output.dyn = true;
|
55
|
+
return output;
|
56
|
+
};
|
57
|
+
var enhanceEncoder = (encoder, mapper) => dyn(encoder, (value) => encoder(mapper(value)));
|
58
|
+
var enhanceDecoder = (decoder, mapper) => dyn(decoder, (value) => mapper(decoder(value)));
|
59
|
+
var enhanceCodec = (codec, toFrom, fromTo) => dyn(codec, createCodec(enhanceEncoder(codec[0], toFrom), enhanceDecoder(codec[1], fromTo)));
|
55
60
|
|
56
61
|
// src/internal/toInternalBytes.ts
|
57
62
|
var HEX_MAP = {
|
@@ -82,16 +87,16 @@ function fromHex(hexString) {
|
|
82
87
|
const isOdd = hexString.length % 2;
|
83
88
|
const base = (hexString[1] === "x" ? 2 : 0) + isOdd;
|
84
89
|
const nBytes = (hexString.length - base) / 2 + isOdd;
|
85
|
-
const
|
90
|
+
const bytes = new Uint8Array(nBytes);
|
86
91
|
if (isOdd)
|
87
|
-
|
92
|
+
bytes[0] = 0 | HEX_MAP[hexString[2]];
|
88
93
|
for (let i = 0; i < nBytes; ) {
|
89
94
|
const idx = base + i * 2;
|
90
95
|
const a = HEX_MAP[hexString[idx]];
|
91
96
|
const b = HEX_MAP[hexString[idx + 1]];
|
92
|
-
|
97
|
+
bytes[isOdd + i++] = a << 4 | b;
|
93
98
|
}
|
94
|
-
return
|
99
|
+
return bytes;
|
95
100
|
}
|
96
101
|
var InternalUint8Array = class extends Uint8Array {
|
97
102
|
constructor(buffer) {
|
@@ -118,64 +123,45 @@ var mergeUint8 = (...inputs) => {
|
|
118
123
|
return result;
|
119
124
|
};
|
120
125
|
|
121
|
-
// src/
|
122
|
-
|
123
|
-
|
124
|
-
|
125
|
-
|
126
|
-
// src/codecs/uint.ts
|
127
|
-
var encode = (nBytes) => {
|
128
|
-
const n64 = nBytes / 8 | 0;
|
129
|
-
const n16 = nBytes % 8 / 2 | 0;
|
130
|
-
const isOdd = nBytes % 2;
|
131
|
-
return (input) => {
|
126
|
+
// src/codecs/Uint.ts
|
127
|
+
var getCodec = (nBytes) => {
|
128
|
+
const n64 = Math.ceil(nBytes / 8);
|
129
|
+
return createCodec((input) => {
|
132
130
|
const result = new Uint8Array(32);
|
133
131
|
const dv = new DataView(result.buffer);
|
134
|
-
|
135
|
-
|
136
|
-
dv.setUint8(--idx, Number(input & 255n));
|
137
|
-
input >>= 8n;
|
138
|
-
}
|
139
|
-
for (let i = 0; i < n16; i++) {
|
140
|
-
idx -= 2;
|
141
|
-
dv.setUint16(idx, Number(input & 65535n));
|
142
|
-
input >>= 16n;
|
143
|
-
}
|
144
|
-
const idxLimit = idx - n64 * 8;
|
145
|
-
for (idx -= 8; idx >= idxLimit; idx -= 8) {
|
132
|
+
const idxLimit = 32 - n64 * 8;
|
133
|
+
for (let idx = 24; idx >= idxLimit; idx -= 8) {
|
146
134
|
dv.setBigUint64(idx, input);
|
147
135
|
input >>= 64n;
|
148
136
|
}
|
149
137
|
return result;
|
150
|
-
}
|
151
|
-
};
|
152
|
-
var decode = (nBytes) => {
|
153
|
-
const n64 = Math.ceil(nBytes / 8);
|
154
|
-
return toInternalBytes((bytes2) => {
|
138
|
+
}, toInternalBytes((bytes) => {
|
155
139
|
let result = 0n;
|
156
|
-
const nextBlock =
|
157
|
-
for (let idx =
|
158
|
-
result = result << 64n |
|
159
|
-
|
140
|
+
const nextBlock = bytes.i + 32;
|
141
|
+
for (let idx = bytes.i + (32 - n64 * 8); idx < nextBlock; idx += 8)
|
142
|
+
result = result << 64n | bytes.v.getBigUint64(idx);
|
143
|
+
bytes.i = nextBlock;
|
160
144
|
return result;
|
161
|
-
});
|
145
|
+
}));
|
162
146
|
};
|
163
147
|
var cache = /* @__PURE__ */ new Map();
|
164
|
-
var
|
148
|
+
var Uint = (nBits) => {
|
165
149
|
let cached = cache.get(nBits);
|
166
150
|
if (cached)
|
167
151
|
return cached;
|
168
152
|
const nBytes = nBits / 8;
|
169
|
-
cached =
|
153
|
+
cached = getCodec(nBytes);
|
170
154
|
cache.set(nBits, cached);
|
171
155
|
return cached;
|
172
156
|
};
|
157
|
+
Uint.enc = (nBits) => Uint(nBits).enc;
|
158
|
+
Uint.dec = (nBits) => Uint(nBits).dec;
|
173
159
|
|
174
160
|
// src/codecs/bool.ts
|
175
|
-
var bool = enhanceCodec(
|
161
|
+
var bool = enhanceCodec(Uint(8), (value) => value ? 1n : 0n, Boolean);
|
176
162
|
|
177
163
|
// src/codecs/str.ts
|
178
|
-
var uint256 =
|
164
|
+
var uint256 = Uint(256);
|
179
165
|
var textEncoder = new TextEncoder();
|
180
166
|
var strEnc = (str2) => {
|
181
167
|
const val = textEncoder.encode(str2);
|
@@ -187,82 +173,38 @@ var strEnc = (str2) => {
|
|
187
173
|
}
|
188
174
|
return mergeUint8(...args);
|
189
175
|
};
|
190
|
-
strEnc.
|
176
|
+
strEnc.dyn = true;
|
191
177
|
var textDecoder = new TextDecoder();
|
192
|
-
var strDec = toInternalBytes((
|
193
|
-
let nElements = Number(uint256.dec(
|
194
|
-
const dv = new DataView(
|
178
|
+
var strDec = toInternalBytes((bytes) => {
|
179
|
+
let nElements = Number(uint256.dec(bytes));
|
180
|
+
const dv = new DataView(bytes.buffer, bytes.i, nElements);
|
195
181
|
const extra = nElements % 32;
|
196
182
|
const padding = extra && 32 - extra;
|
197
|
-
|
183
|
+
bytes.i += nElements + padding;
|
198
184
|
return textDecoder.decode(dv);
|
199
185
|
});
|
200
|
-
strDec.
|
186
|
+
strDec.dyn = true;
|
201
187
|
var str = createCodec(strEnc, strDec);
|
202
|
-
str.
|
188
|
+
str.dyn = true;
|
203
189
|
|
204
|
-
// src/codecs/
|
205
|
-
var bytesEnc = (nBytes) => (
|
206
|
-
if (
|
207
|
-
return
|
190
|
+
// src/codecs/Bytes.ts
|
191
|
+
var bytesEnc = (nBytes) => (bytes) => {
|
192
|
+
if (bytes.length === 32)
|
193
|
+
return bytes;
|
208
194
|
const result = new Uint8Array(32);
|
209
|
-
result.set(
|
195
|
+
result.set(bytes.length === nBytes ? bytes : bytes.slice(0, nBytes));
|
210
196
|
return result;
|
211
197
|
};
|
212
|
-
var bytesDec = (nBytes) => toInternalBytes((
|
213
|
-
const result = new Uint8Array(
|
214
|
-
|
198
|
+
var bytesDec = (nBytes) => toInternalBytes((bytes) => {
|
199
|
+
const result = new Uint8Array(bytes.buffer, bytes.i, nBytes);
|
200
|
+
bytes.i += 32;
|
215
201
|
return result;
|
216
202
|
});
|
217
|
-
var
|
218
|
-
|
219
|
-
|
203
|
+
var Bytes = (nBytes) => createCodec(bytesEnc(nBytes), bytesDec(nBytes));
|
204
|
+
Bytes.enc = bytesEnc;
|
205
|
+
Bytes.dec = bytesDec;
|
220
206
|
|
221
|
-
// src/codecs/
|
222
|
-
var uint2562 = uint(256);
|
223
|
-
var callEnc = (...encoders) => (values) => {
|
224
|
-
const mapped = values.map((value, idx) => encoders[idx](value));
|
225
|
-
const resultArray = new Array(encoders.length);
|
226
|
-
const dinamics = [];
|
227
|
-
let len = 0n;
|
228
|
-
for (let i = 0; i < encoders.length; i++) {
|
229
|
-
if (encoders[i].din) {
|
230
|
-
dinamics.push(i);
|
231
|
-
len += 32n;
|
232
|
-
} else {
|
233
|
-
resultArray[i] = mapped[i];
|
234
|
-
len += BigInt(mapped[i].length);
|
235
|
-
}
|
236
|
-
}
|
237
|
-
dinamics.forEach((idx) => {
|
238
|
-
resultArray[idx] = uint2562.enc(len);
|
239
|
-
const data = mapped[idx];
|
240
|
-
resultArray.push(data);
|
241
|
-
len += BigInt(data.length);
|
242
|
-
});
|
243
|
-
return mergeUint8(...resultArray);
|
244
|
-
};
|
245
|
-
var callDec = (...decoders) => toInternalBytes((bytes2) => {
|
246
|
-
const result = new Array(decoders.length);
|
247
|
-
let start = bytes2.i;
|
248
|
-
for (let i = 0; i < decoders.length; i++) {
|
249
|
-
if (decoders[i].din) {
|
250
|
-
const offset = Number(uint2562.dec(bytes2));
|
251
|
-
const current = bytes2.i;
|
252
|
-
bytes2.i = start + offset;
|
253
|
-
result[i] = decoders[i](bytes2);
|
254
|
-
bytes2.i = current;
|
255
|
-
} else {
|
256
|
-
result[i] = decoders[i](bytes2);
|
257
|
-
}
|
258
|
-
}
|
259
|
-
return result;
|
260
|
-
});
|
261
|
-
var call = (...codecs) => createCodec(callEnc(...codecs.map(([encoder]) => encoder)), callDec(...codecs.map(([, decoder]) => decoder)));
|
262
|
-
call.enc = callEnc;
|
263
|
-
call.dec = callDec;
|
264
|
-
|
265
|
-
// src/codecs/int.ts
|
207
|
+
// src/codecs/Int.ts
|
266
208
|
var signGetters = {
|
267
209
|
"1": "getInt8",
|
268
210
|
"2": "getInt16",
|
@@ -283,7 +225,7 @@ var usignSetters = {
|
|
283
225
|
"2": "setUint16",
|
284
226
|
"8": "setBigUint64"
|
285
227
|
};
|
286
|
-
var
|
228
|
+
var getCodec2 = (nBytes) => {
|
287
229
|
const n64 = nBytes / 8 | 0;
|
288
230
|
const n16 = nBytes % 8 / 2 | 0;
|
289
231
|
const sequence = [
|
@@ -295,47 +237,51 @@ var getCodec = (nBytes) => {
|
|
295
237
|
const enc = (input) => {
|
296
238
|
const result = new Uint8Array(32);
|
297
239
|
const dv = new DataView(result.buffer);
|
240
|
+
if (input < 0n) {
|
241
|
+
for (let i = 0; i < 32 - nBytes; i += 8)
|
242
|
+
dv.setBigInt64(i, -1n);
|
243
|
+
}
|
298
244
|
let idx = 32;
|
299
245
|
for (let i = sequence.length - 1; i > 0; i--) {
|
300
|
-
const [
|
301
|
-
idx -=
|
302
|
-
dv[usignSetters[
|
246
|
+
const [bytes2, shift, fn2] = sequence[i];
|
247
|
+
idx -= bytes2;
|
248
|
+
dv[usignSetters[bytes2]](idx, fn2(input));
|
303
249
|
input >>= shift;
|
304
250
|
}
|
305
|
-
const [
|
306
|
-
idx -=
|
307
|
-
dv[signSetters[
|
251
|
+
const [bytes, , fn] = sequence[0];
|
252
|
+
idx -= bytes;
|
253
|
+
dv[signSetters[bytes]](idx, fn(input));
|
308
254
|
return result;
|
309
255
|
};
|
310
|
-
const dec = toInternalBytes((
|
311
|
-
let idx =
|
256
|
+
const dec = toInternalBytes((bytes) => {
|
257
|
+
let idx = bytes.i + 32 - nBytes;
|
312
258
|
const bits = sequence[0][0];
|
313
|
-
let result = BigInt(
|
259
|
+
let result = BigInt(bytes.v[signGetters[bits]](idx));
|
314
260
|
idx += bits;
|
315
261
|
for (let i = 1; i < sequence.length; i++) {
|
316
262
|
const [bits2, shift] = sequence[i];
|
317
|
-
result = result << shift | BigInt(
|
263
|
+
result = result << shift | BigInt(bytes.v[usignGetters[bits2]](idx));
|
318
264
|
idx += bits2;
|
319
265
|
}
|
320
|
-
|
266
|
+
bytes.i += 32;
|
321
267
|
return result;
|
322
268
|
});
|
323
269
|
return createCodec(enc, dec);
|
324
270
|
};
|
325
271
|
var cache2 = /* @__PURE__ */ new Map();
|
326
|
-
var
|
272
|
+
var Int = (nBits) => {
|
327
273
|
let cached = cache2.get(nBits);
|
328
274
|
if (cached)
|
329
275
|
return cached;
|
330
276
|
const nBytes = nBits / 8;
|
331
|
-
cached =
|
277
|
+
cached = getCodec2(nBytes);
|
332
278
|
cache2.set(nBits, cached);
|
333
279
|
return cached;
|
334
280
|
};
|
335
|
-
|
336
|
-
|
281
|
+
Int.enc = (nBits) => Int(nBits).enc;
|
282
|
+
Int.dec = (nBits) => Int(nBits).dec;
|
337
283
|
|
338
|
-
// src/codecs/
|
284
|
+
// src/codecs/Fixed.ts
|
339
285
|
var creator = (codec) => {
|
340
286
|
const cache3 = /* @__PURE__ */ new Map();
|
341
287
|
return (nBits, decimals) => {
|
@@ -348,57 +294,104 @@ var creator = (codec) => {
|
|
348
294
|
return cached;
|
349
295
|
};
|
350
296
|
};
|
351
|
-
var
|
352
|
-
var
|
353
|
-
|
354
|
-
// src/codecs/tuple.ts
|
355
|
-
var tupleDec = (...decoders) => toInternalBytes((bytes2) => decoders.map((decoder) => decoder(bytes2)));
|
356
|
-
var tupleEnc = (...encoders) => (values) => mergeUint8(...values.map((value, idx) => encoders[idx](value)));
|
357
|
-
var tuple = (...codecs) => createCodec(tupleEnc(...codecs.map(([encoder]) => encoder)), tupleDec(...codecs.map(([, decoder]) => decoder)));
|
358
|
-
tuple.enc = tupleEnc;
|
359
|
-
tuple.dec = tupleDec;
|
297
|
+
var Fixed = creator(Int);
|
298
|
+
var Ufixed = creator(Uint);
|
360
299
|
|
361
|
-
// src/codecs/
|
362
|
-
var
|
363
|
-
|
364
|
-
|
300
|
+
// src/codecs/Tuple.ts
|
301
|
+
var uint2562 = Uint(256);
|
302
|
+
var dynamicEnc = (...encoders) => {
|
303
|
+
const res = (values) => {
|
304
|
+
const mapped = values.map((value, idx) => encoders[idx](value));
|
305
|
+
const resultArray = new Array(encoders.length);
|
306
|
+
const dinamics = [];
|
307
|
+
let len = 0n;
|
308
|
+
for (let i = 0; i < encoders.length; i++) {
|
309
|
+
if (encoders[i].dyn) {
|
310
|
+
dinamics.push(i);
|
311
|
+
len += 32n;
|
312
|
+
} else {
|
313
|
+
resultArray[i] = mapped[i];
|
314
|
+
len += BigInt(mapped[i].length);
|
315
|
+
}
|
316
|
+
}
|
317
|
+
dinamics.forEach((idx) => {
|
318
|
+
resultArray[idx] = uint2562.enc(len);
|
319
|
+
const data = mapped[idx];
|
320
|
+
resultArray.push(data);
|
321
|
+
len += BigInt(data.length);
|
322
|
+
});
|
323
|
+
return mergeUint8(...resultArray);
|
324
|
+
};
|
325
|
+
res.dyn = true;
|
326
|
+
return res;
|
365
327
|
};
|
366
|
-
var
|
367
|
-
|
368
|
-
|
328
|
+
var staticEnc = (...encoders) => (values) => mergeUint8(...values.map((value, idx) => encoders[idx](value)));
|
329
|
+
var staticDec = (...decoders) => toInternalBytes((bytes) => decoders.map((decoder) => decoder(bytes)));
|
330
|
+
var dynamicDec = (...decoders) => {
|
331
|
+
const res = toInternalBytes((bytes) => {
|
332
|
+
const result = new Array(decoders.length);
|
333
|
+
let start = bytes.i;
|
334
|
+
for (let i = 0; i < decoders.length; i++) {
|
335
|
+
if (decoders[i].dyn) {
|
336
|
+
const offset = Number(uint2562.dec(bytes));
|
337
|
+
const current = bytes.i;
|
338
|
+
bytes.i = start + offset;
|
339
|
+
result[i] = decoders[i](bytes);
|
340
|
+
bytes.i = current;
|
341
|
+
} else {
|
342
|
+
result[i] = decoders[i](bytes);
|
343
|
+
}
|
344
|
+
}
|
345
|
+
return result;
|
346
|
+
});
|
347
|
+
res.dyn = true;
|
348
|
+
return res;
|
349
|
+
};
|
350
|
+
var Tuple = (...codecs) => {
|
351
|
+
const isDyn = codecs.some((c) => c.dyn);
|
352
|
+
const [enc, dec] = isDyn ? [dynamicEnc, dynamicDec] : [staticEnc, staticDec];
|
353
|
+
const res = createCodec(enc(...codecs.map(([encoder]) => encoder)), dec(...codecs.map(([, decoder]) => decoder)));
|
354
|
+
res.dyn = isDyn;
|
355
|
+
return res;
|
356
|
+
};
|
357
|
+
|
358
|
+
// src/codecs/Struct.ts
|
359
|
+
var Struct = (codecs) => {
|
360
|
+
const keys = Object.keys(codecs);
|
361
|
+
return enhanceCodec(Tuple(...Object.values(codecs)), (input) => keys.map((k) => input[k]), (tuple) => Object.fromEntries(tuple.map((value, idx) => [keys[idx], value])));
|
369
362
|
};
|
370
|
-
var struct = (codecs) => createCodec(structEnc(mapObject(codecs, (x) => x[0])), structDec(mapObject(codecs, (x) => x[1])));
|
371
|
-
struct.enc = structEnc;
|
372
|
-
struct.dec = structDec;
|
373
363
|
|
374
|
-
// src/codecs/
|
375
|
-
var uint2563 =
|
364
|
+
// src/codecs/Vector.ts
|
365
|
+
var uint2563 = Uint(256);
|
376
366
|
var vectorEnc = (inner, size) => {
|
377
|
-
if (size >= 0)
|
378
|
-
|
367
|
+
if (size >= 0) {
|
368
|
+
const res = (value) => mergeUint8(...value.map(inner));
|
369
|
+
res.dyn = inner.dyn;
|
370
|
+
return res;
|
371
|
+
}
|
379
372
|
const result = (value) => mergeUint8(uint2563.enc(BigInt(value.length)), ...value.map(inner));
|
380
|
-
result.
|
373
|
+
result.dyn = true;
|
381
374
|
return result;
|
382
375
|
};
|
383
376
|
var vectorDec = (getter, size) => {
|
384
|
-
const result = toInternalBytes((
|
385
|
-
const nElements = size >= 0 ? size : Number(uint2563.dec(
|
377
|
+
const result = toInternalBytes((bytes) => {
|
378
|
+
const nElements = size >= 0 ? size : Number(uint2563.dec(bytes));
|
386
379
|
const result2 = new Array(nElements);
|
387
380
|
for (let i = 0; i < nElements; i++) {
|
388
|
-
result2[i] = getter(
|
381
|
+
result2[i] = getter(bytes);
|
389
382
|
}
|
390
383
|
return result2;
|
391
384
|
});
|
392
385
|
if (size == null)
|
393
|
-
result.
|
386
|
+
result.dyn = true;
|
394
387
|
return result;
|
395
388
|
};
|
396
|
-
var
|
389
|
+
var Vector = (inner, size) => {
|
397
390
|
const result = createCodec(vectorEnc(inner[0], size), vectorDec(inner[1], size));
|
398
391
|
if (size == null)
|
399
|
-
result.
|
392
|
+
result.dyn = true;
|
400
393
|
return result;
|
401
394
|
};
|
402
|
-
|
403
|
-
|
395
|
+
Vector.enc = vectorEnc;
|
396
|
+
Vector.dec = vectorDec;
|
404
397
|
//# sourceMappingURL=solidity-codecs.cjs.development.js.map
|