solidity-codecs 0.0.1-beta.2 → 0.0.1-beta.3

package/dist/codecs/Bytes.d.ts

@@ -1,6 +1,6 @@
-import { Encoder, Decoder, Codec } from "../types"
+import { Encoder, Decoder, Codec } from "../types";
 export declare const Bytes: {
-  (nBytes: number): Codec<Uint8Array>
-  enc: (nBytes: number) => Encoder<Uint8Array>
-  dec: (nBytes: number) => Decoder<Uint8Array>
-}
+    (nBytes: number): Codec<Uint8Array>;
+    enc: (nBytes: number) => Encoder<Uint8Array>;
+    dec: (nBytes: number) => Decoder<Uint8Array>;
+};

package/dist/codecs/Fixed.d.ts

@@ -0,0 +1,3 @@
+import { Codec, Decimal } from "../types";
+export declare const Fixed: (nBits: number, decimals: number) => Codec<Decimal>;
+export declare const Ufixed: (nBits: number, decimals: number) => Codec<Decimal>;

package/dist/codecs/{int.d.ts → Int.d.ts}

@@ -1,5 +1,5 @@
 import { Encoder, Codec } from "../types";
-export declare const int: {
+export declare const Int: {
     (nBits: number): Codec<bigint>;
     enc(nBits: number): Encoder<bigint>;
     dec(nBits: number): import("../types").Decoder<bigint>;

package/dist/codecs/Struct.d.ts

@@ -1,25 +1,2 @@
-import { Codec, Decoder, Encoder, StringRecord } from "../types"
-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>
-  enc: <
-    A_1 extends StringRecord<Encoder<any>>,
-    OT_1 extends {
-      [K_1 in keyof A_1]: A_1[K_1] extends Encoder<infer D_1> ? D_1 : unknown
-    },
-  >(
-    encoders: A_1,
-  ) => Encoder<OT_1>
-  dec: <
-    A_2 extends StringRecord<Decoder<any>>,
-    OT_2 extends {
-      [K_2 in keyof A_2]: A_2[K_2] extends Decoder<infer D_2> ? D_2 : unknown
-    },
-  >(
-    decoders: A_2,
-  ) => Decoder<OT_2>
-}
+import { Codec, StringRecord } from "../types";
+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

@@ -1,25 +1,2 @@
-import { Codec, Decoder, Encoder } from "../types"
-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]>
-  enc: <
-    A_1 extends Encoder<any>[],
-    OT_1 extends {
-      [K_1 in keyof A_1]: A_1[K_1] extends Encoder<infer D_1> ? D_1 : unknown
-    },
-  >(
-    ...encoders: A_1
-  ) => Encoder<[...OT_1]>
-  dec: <
-    A_2 extends Decoder<any>[],
-    OT_2 extends {
-      [K_2 in keyof A_2]: A_2[K_2] extends Decoder<infer D_2> ? D_2 : unknown
-    },
-  >(
-    ...decoders: A_2
-  ) => Decoder<[...OT_2]>
-}
+import { Codec } from "../types";
+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/Uint.d.ts

@@ -0,0 +1,6 @@
+import { Codec } from "../types";
+export declare const Uint: {
+    (nBits: number): Codec<bigint>;
+    enc(nBits: number): import("../types").Encoder<bigint>;
+    dec(nBits: number): import("../types").Decoder<bigint>;
+};

package/dist/codecs/Vector.d.ts

@@ -1,14 +1,6 @@
-import { Codec, Decoder, Encoder } from "../types"
-declare function VectorDec<T>(
-  getter: Decoder<T>,
-  size?: number,
-): Decoder<Array<T>>
-export declare function Vector<T>(
-  inner: Codec<T>,
-  size?: number,
-): Codec<Array<T>>
-export declare namespace Vector {
-  var enc: <T>(inner: Encoder<T>, size?: number | undefined) => Encoder<T[]>
-  var dec: typeof VectorDec
-}
-export {}
+import { Codec, Decoder, Encoder } from "../types";
+export declare const Vector: {
+    <T>(inner: Codec<T>, size?: number | undefined): Codec<T[]>;
+    enc: <T_1>(inner: Encoder<T_1>, size?: number | undefined) => Encoder<T_1[]>;
+    dec: <T_2>(getter: Decoder<T_2>, size?: number | undefined) => Decoder<T_2[]>;
+};

package/dist/codecs/index.d.ts

@@ -1,10 +1,9 @@
 export { bool } from "./bool";
 export { str } from "./str";
-export { bytes } from "./bytes";
-export { call } from "./call";
-export { fixed, ufixed } from "./fixed";
-export { int } from "./int";
-export { struct } from "./struct";
-export { tuple } from "./tuple";
-export { uint } from "./uint";
-export { vector } from "./vector";
+export { Bytes } from "./Bytes";
+export { Fixed, Ufixed } from "./Fixed";
+export { Int } from "./Int";
+export { Struct } from "./Struct";
+export { Tuple } from "./Tuple";
+export { Uint } from "./Uint";
+export { Vector } from "./Vector";

package/dist/solidity-codecs.cjs.development.js

@@ -24,21 +24,21 @@ var __publicField = (obj, key, value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  Bytes: () => Bytes,
+  Fixed: () => Fixed,
+  Int: () => Int,
+  Struct: () => Struct,
+  Tuple: () => Tuple,
+  Ufixed: () => Ufixed,
+  Uint: () => Uint,
+  Vector: () => Vector,
   bool: () => bool,
-  bytes: () => bytes,
-  call: () => call,
   createCodec: () => createCodec,
+  dyn: () => dyn,
   enhanceCodec: () => enhanceCodec,
   enhanceDecoder: () => enhanceDecoder,
   enhanceEncoder: () => enhanceEncoder,
-  fixed: () => fixed,
-  int: () => int,
-  str: () => str,
-  struct: () => struct,
-  tuple: () => tuple,
-  ufixed: () => ufixed,
-  uint: () => uint,
-  vector: () => vector
+  str: () => str
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -49,9 +49,14 @@ var createCodec = (encoder, decoder) => {
   result.dec = decoder;
   return result;
 };
-var enhanceEncoder = (encoder, mapper) => (value) => encoder(mapper(value));
-var enhanceDecoder = (decoder, mapper) => (value) => mapper(decoder(value));
-var enhanceCodec = ([encoder, decoder], toFrom, fromTo) => createCodec(enhanceEncoder(encoder, toFrom), enhanceDecoder(decoder, fromTo));
+var dyn = (input, output) => {
+  if (input.dyn)
+    output.dyn = true;
+  return output;
+};
+var enhanceEncoder = (encoder, mapper) => dyn(encoder, (value) => encoder(mapper(value)));
+var enhanceDecoder = (decoder, mapper) => dyn(decoder, (value) => mapper(decoder(value)));
+var enhanceCodec = (codec, toFrom, fromTo) => dyn(codec, createCodec(enhanceEncoder(codec[0], toFrom), enhanceDecoder(codec[1], fromTo)));
 
 // src/internal/toInternalBytes.ts
 var HEX_MAP = {
@@ -82,16 +87,16 @@ function fromHex(hexString) {
   const isOdd = hexString.length % 2;
   const base = (hexString[1] === "x" ? 2 : 0) + isOdd;
   const nBytes = (hexString.length - base) / 2 + isOdd;
-  const bytes2 = new Uint8Array(nBytes);
+  const bytes = new Uint8Array(nBytes);
   if (isOdd)
-    bytes2[0] = 0 | HEX_MAP[hexString[2]];
+    bytes[0] = 0 | HEX_MAP[hexString[2]];
   for (let i = 0; i < nBytes; ) {
     const idx = base + i * 2;
     const a = HEX_MAP[hexString[idx]];
     const b = HEX_MAP[hexString[idx + 1]];
-    bytes2[isOdd + i++] = a << 4 | b;
+    bytes[isOdd + i++] = a << 4 | b;
   }
-  return bytes2;
+  return bytes;
 }
 var InternalUint8Array = class extends Uint8Array {
   constructor(buffer) {
@@ -118,64 +123,45 @@ var mergeUint8 = (...inputs) => {
   return result;
 };
 
-// src/internal/mapObject.ts
-function mapObject(input, mapper) {
-  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, mapper(value, key)]));
-}
-
-// src/codecs/uint.ts
-var encode = (nBytes) => {
-  const n64 = nBytes / 8 | 0;
-  const n16 = nBytes % 8 / 2 | 0;
-  const isOdd = nBytes % 2;
-  return (input) => {
+// src/codecs/Uint.ts
+var getCodec = (nBytes) => {
+  const n64 = Math.ceil(nBytes / 8);
+  return createCodec((input) => {
     const result = new Uint8Array(32);
     const dv = new DataView(result.buffer);
-    let idx = 32;
-    if (isOdd) {
-      dv.setUint8(--idx, Number(input & 255n));
-      input >>= 8n;
-    }
-    for (let i = 0; i < n16; i++) {
-      idx -= 2;
-      dv.setUint16(idx, Number(input & 65535n));
-      input >>= 16n;
-    }
-    const idxLimit = idx - n64 * 8;
-    for (idx -= 8; idx >= idxLimit; idx -= 8) {
+    const idxLimit = 32 - n64 * 8;
+    for (let idx = 24; idx >= idxLimit; idx -= 8) {
       dv.setBigUint64(idx, input);
       input >>= 64n;
     }
     return result;
-  };
-};
-var decode = (nBytes) => {
-  const n64 = Math.ceil(nBytes / 8);
-  return toInternalBytes((bytes2) => {
+  }, toInternalBytes((bytes) => {
     let result = 0n;
-    const nextBlock = bytes2.i + 32;
-    for (let idx = bytes2.i + (32 - n64 * 8); idx < nextBlock; idx += 8)
-      result = result << 64n | bytes2.v.getBigUint64(idx);
-    bytes2.i = nextBlock;
+    const nextBlock = bytes.i + 32;
+    for (let idx = bytes.i + (32 - n64 * 8); idx < nextBlock; idx += 8)
+      result = result << 64n | bytes.v.getBigUint64(idx);
+    bytes.i = nextBlock;
     return result;
-  });
+  }));
 };
 var cache = /* @__PURE__ */ new Map();
-var uint = (nBits) => {
+var Uint = (nBits) => {
   let cached = cache.get(nBits);
   if (cached)
     return cached;
   const nBytes = nBits / 8;
-  cached = createCodec(encode(nBytes), decode(nBytes));
+  cached = getCodec(nBytes);
   cache.set(nBits, cached);
   return cached;
 };
+Uint.enc = (nBits) => Uint(nBits).enc;
+Uint.dec = (nBits) => Uint(nBits).dec;
 
 // src/codecs/bool.ts
-var bool = enhanceCodec(uint(8), (value) => value ? 1n : 0n, Boolean);
+var bool = enhanceCodec(Uint(8), (value) => value ? 1n : 0n, Boolean);
 
 // src/codecs/str.ts
-var uint256 = uint(256);
+var uint256 = Uint(256);
 var textEncoder = new TextEncoder();
 var strEnc = (str2) => {
   const val = textEncoder.encode(str2);
@@ -187,82 +173,38 @@ var strEnc = (str2) => {
   }
   return mergeUint8(...args);
 };
-strEnc.din = true;
+strEnc.dyn = true;
 var textDecoder = new TextDecoder();
-var strDec = toInternalBytes((bytes2) => {
-  let nElements = Number(uint256.dec(bytes2));
-  const dv = new DataView(bytes2.buffer, bytes2.i, nElements);
+var strDec = toInternalBytes((bytes) => {
+  let nElements = Number(uint256.dec(bytes));
+  const dv = new DataView(bytes.buffer, bytes.i, nElements);
   const extra = nElements % 32;
   const padding = extra && 32 - extra;
-  bytes2.i += nElements + padding;
+  bytes.i += nElements + padding;
   return textDecoder.decode(dv);
 });
-strDec.din = true;
+strDec.dyn = true;
 var str = createCodec(strEnc, strDec);
-str.din = true;
+str.dyn = true;
 
-// src/codecs/bytes.ts
-var bytesEnc = (nBytes) => (bytes2) => {
-  if (bytes2.length === 32)
-    return bytes2;
+// src/codecs/Bytes.ts
+var bytesEnc = (nBytes) => (bytes) => {
+  if (bytes.length === 32)
+    return bytes;
   const result = new Uint8Array(32);
-  result.set(bytes2.length === nBytes ? bytes2 : bytes2.slice(0, nBytes));
+  result.set(bytes.length === nBytes ? bytes : bytes.slice(0, nBytes));
   return result;
 };
-var bytesDec = (nBytes) => toInternalBytes((bytes2) => {
-  const result = new Uint8Array(bytes2.buffer, bytes2.i, nBytes);
-  bytes2.i += 32;
+var bytesDec = (nBytes) => toInternalBytes((bytes) => {
+  const result = new Uint8Array(bytes.buffer, bytes.i, nBytes);
+  bytes.i += 32;
   return result;
 });
-var bytes = (nBytes) => createCodec(bytesEnc(nBytes), bytesDec(nBytes));
-bytes.enc = bytesEnc;
-bytes.dec = bytesDec;
+var Bytes = (nBytes) => createCodec(bytesEnc(nBytes), bytesDec(nBytes));
+Bytes.enc = bytesEnc;
+Bytes.dec = bytesDec;
 
-// src/codecs/call.ts
-var uint2562 = uint(256);
-var callEnc = (...encoders) => (values) => {
-  const mapped = values.map((value, idx) => encoders[idx](value));
-  const resultArray = new Array(encoders.length);
-  const dinamics = [];
-  let len = 0n;
-  for (let i = 0; i < encoders.length; i++) {
-    if (encoders[i].din) {
-      dinamics.push(i);
-      len += 32n;
-    } else {
-      resultArray[i] = mapped[i];
-      len += BigInt(mapped[i].length);
-    }
-  }
-  dinamics.forEach((idx) => {
-    resultArray[idx] = uint2562.enc(len);
-    const data = mapped[idx];
-    resultArray.push(data);
-    len += BigInt(data.length);
-  });
-  return mergeUint8(...resultArray);
-};
-var callDec = (...decoders) => toInternalBytes((bytes2) => {
-  const result = new Array(decoders.length);
-  let start = bytes2.i;
-  for (let i = 0; i < decoders.length; i++) {
-    if (decoders[i].din) {
-      const offset = Number(uint2562.dec(bytes2));
-      const current = bytes2.i;
-      bytes2.i = start + offset;
-      result[i] = decoders[i](bytes2);
-      bytes2.i = current;
-    } else {
-      result[i] = decoders[i](bytes2);
-    }
-  }
-  return result;
-});
-var call = (...codecs) => createCodec(callEnc(...codecs.map(([encoder]) => encoder)), callDec(...codecs.map(([, decoder]) => decoder)));
-call.enc = callEnc;
-call.dec = callDec;
-
-// src/codecs/int.ts
+// src/codecs/Int.ts
 var signGetters = {
   "1": "getInt8",
   "2": "getInt16",
@@ -283,7 +225,7 @@ var usignSetters = {
   "2": "setUint16",
   "8": "setBigUint64"
 };
-var getCodec = (nBytes) => {
+var getCodec2 = (nBytes) => {
   const n64 = nBytes / 8 | 0;
   const n16 = nBytes % 8 / 2 | 0;
   const sequence = [
@@ -295,47 +237,51 @@ var getCodec = (nBytes) => {
   const enc = (input) => {
     const result = new Uint8Array(32);
     const dv = new DataView(result.buffer);
+    if (input < 0n) {
+      for (let i = 0; i < 32 - nBytes; i += 8)
+        dv.setBigInt64(i, -1n);
+    }
     let idx = 32;
     for (let i = sequence.length - 1; i > 0; i--) {
-      const [bytes3, shift, fn2] = sequence[i];
-      idx -= bytes3;
-      dv[usignSetters[bytes3]](idx, fn2(input));
+      const [bytes2, shift, fn2] = sequence[i];
+      idx -= bytes2;
+      dv[usignSetters[bytes2]](idx, fn2(input));
       input >>= shift;
     }
-    const [bytes2, , fn] = sequence[0];
-    idx -= bytes2;
-    dv[signSetters[bytes2]](idx, fn(input));
+    const [bytes, , fn] = sequence[0];
+    idx -= bytes;
+    dv[signSetters[bytes]](idx, fn(input));
     return result;
   };
-  const dec = toInternalBytes((bytes2) => {
-    let idx = bytes2.i + 32 - nBytes;
+  const dec = toInternalBytes((bytes) => {
+    let idx = bytes.i + 32 - nBytes;
     const bits = sequence[0][0];
-    let result = BigInt(bytes2.v[signGetters[bits]](idx));
+    let result = BigInt(bytes.v[signGetters[bits]](idx));
     idx += bits;
     for (let i = 1; i < sequence.length; i++) {
       const [bits2, shift] = sequence[i];
-      result = result << shift | BigInt(bytes2.v[usignGetters[bits2]](idx));
+      result = result << shift | BigInt(bytes.v[usignGetters[bits2]](idx));
       idx += bits2;
     }
-    bytes2.i += 32;
+    bytes.i += 32;
     return result;
   });
   return createCodec(enc, dec);
 };
 var cache2 = /* @__PURE__ */ new Map();
-var int = (nBits) => {
+var Int = (nBits) => {
   let cached = cache2.get(nBits);
   if (cached)
     return cached;
   const nBytes = nBits / 8;
-  cached = getCodec(nBytes);
+  cached = getCodec2(nBytes);
   cache2.set(nBits, cached);
   return cached;
 };
-int.enc = (nBits) => int(nBits).enc;
-int.dec = (nBits) => int(nBits).dec;
+Int.enc = (nBits) => Int(nBits).enc;
+Int.dec = (nBits) => Int(nBits).dec;
 
-// src/codecs/fixed.ts
+// src/codecs/Fixed.ts
 var creator = (codec) => {
   const cache3 = /* @__PURE__ */ new Map();
   return (nBits, decimals) => {
@@ -348,57 +294,104 @@ var creator = (codec) => {
     return cached;
   };
 };
-var fixed = creator(int);
-var ufixed = creator(uint);
-
-// src/codecs/tuple.ts
-var tupleDec = (...decoders) => toInternalBytes((bytes2) => decoders.map((decoder) => decoder(bytes2)));
-var tupleEnc = (...encoders) => (values) => mergeUint8(...values.map((value, idx) => encoders[idx](value)));
-var tuple = (...codecs) => createCodec(tupleEnc(...codecs.map(([encoder]) => encoder)), tupleDec(...codecs.map(([, decoder]) => decoder)));
-tuple.enc = tupleEnc;
-tuple.dec = tupleDec;
+var Fixed = creator(Int);
+var Ufixed = creator(Uint);
 
-// src/codecs/struct.ts
-var structEnc = (encoders) => {
-  const keys = Object.keys(encoders);
-  return enhanceEncoder(tuple.enc(...Object.values(encoders)), (input) => keys.map((k) => input[k]));
+// src/codecs/Tuple.ts
+var uint2562 = Uint(256);
+var dynamicEnc = (...encoders) => {
+  const res = (values) => {
+    const mapped = values.map((value, idx) => encoders[idx](value));
+    const resultArray = new Array(encoders.length);
+    const dinamics = [];
+    let len = 0n;
+    for (let i = 0; i < encoders.length; i++) {
+      if (encoders[i].dyn) {
+        dinamics.push(i);
+        len += 32n;
+      } else {
+        resultArray[i] = mapped[i];
+        len += BigInt(mapped[i].length);
+      }
+    }
+    dinamics.forEach((idx) => {
+      resultArray[idx] = uint2562.enc(len);
+      const data = mapped[idx];
+      resultArray.push(data);
+      len += BigInt(data.length);
+    });
+    return mergeUint8(...resultArray);
+  };
+  res.dyn = true;
+  return res;
 };
-var structDec = (decoders) => {
-  const keys = Object.keys(decoders);
-  return enhanceDecoder(tuple.dec(...Object.values(decoders)), (tuple2) => Object.fromEntries(tuple2.map((value, idx) => [keys[idx], value])));
+var staticEnc = (...encoders) => (values) => mergeUint8(...values.map((value, idx) => encoders[idx](value)));
+var staticDec = (...decoders) => toInternalBytes((bytes) => decoders.map((decoder) => decoder(bytes)));
+var dynamicDec = (...decoders) => {
+  const res = toInternalBytes((bytes) => {
+    const result = new Array(decoders.length);
+    let start = bytes.i;
+    for (let i = 0; i < decoders.length; i++) {
+      if (decoders[i].dyn) {
+        const offset = Number(uint2562.dec(bytes));
+        const current = bytes.i;
+        bytes.i = start + offset;
+        result[i] = decoders[i](bytes);
+        bytes.i = current;
+      } else {
+        result[i] = decoders[i](bytes);
+      }
+    }
+    return result;
+  });
+  res.dyn = true;
+  return res;
+};
+var Tuple = (...codecs) => {
+  const isDyn = codecs.some((c) => c.dyn);
+  const [enc, dec] = isDyn ? [dynamicEnc, dynamicDec] : [staticEnc, staticDec];
+  const res = createCodec(enc(...codecs.map(([encoder]) => encoder)), dec(...codecs.map(([, decoder]) => decoder)));
+  res.dyn = isDyn;
+  return res;
+};
+
+// src/codecs/Struct.ts
+var Struct = (codecs) => {
+  const keys = Object.keys(codecs);
+  return enhanceCodec(Tuple(...Object.values(codecs)), (input) => keys.map((k) => input[k]), (tuple) => Object.fromEntries(tuple.map((value, idx) => [keys[idx], value])));
 };
-var struct = (codecs) => createCodec(structEnc(mapObject(codecs, (x) => x[0])), structDec(mapObject(codecs, (x) => x[1])));
-struct.enc = structEnc;
-struct.dec = structDec;
 
-// src/codecs/vector.ts
-var uint2563 = uint(256);
+// src/codecs/Vector.ts
+var uint2563 = Uint(256);
 var vectorEnc = (inner, size) => {
-  if (size >= 0)
-    return (value) => mergeUint8(...value.map(inner));
+  if (size >= 0) {
+    const res = (value) => mergeUint8(...value.map(inner));
+    res.dyn = inner.dyn;
+    return res;
+  }
   const result = (value) => mergeUint8(uint2563.enc(BigInt(value.length)), ...value.map(inner));
-  result.din = true;
+  result.dyn = true;
   return result;
 };
 var vectorDec = (getter, size) => {
-  const result = toInternalBytes((bytes2) => {
-    const nElements = size >= 0 ? size : Number(uint2563.dec(bytes2));
+  const result = toInternalBytes((bytes) => {
+    const nElements = size >= 0 ? size : Number(uint2563.dec(bytes));
     const result2 = new Array(nElements);
     for (let i = 0; i < nElements; i++) {
-      result2[i] = getter(bytes2);
+      result2[i] = getter(bytes);
     }
     return result2;
   });
   if (size == null)
-    result.din = true;
+    result.dyn = true;
   return result;
 };
-var vector = (inner, size) => {
+var Vector = (inner, size) => {
   const result = createCodec(vectorEnc(inner[0], size), vectorDec(inner[1], size));
   if (size == null)
-    result.din = true;
+    result.dyn = true;
   return result;
 };
-vector.enc = vectorEnc;
-vector.dec = vectorDec;
+Vector.enc = vectorEnc;
+Vector.dec = vectorDec;
 //# sourceMappingURL=solidity-codecs.cjs.development.js.map