solidity-codecs 0.0.1-beta.2 → 0.1.0

package/dist/solidity-codecs.mjs

@@ -12,50 +12,21 @@ 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/codecs/address.ts
+import { fromHex as fromHex2, toHex } from "@unstoppablejs/utils";
+import { keccak_256 } from "@noble/hashes/sha3";
 
 // src/internal/toInternalBytes.ts
-var HEX_MAP = {
-  0: 0,
-  1: 1,
-  2: 2,
-  3: 3,
-  4: 4,
-  5: 5,
-  6: 6,
-  7: 7,
-  8: 8,
-  9: 9,
-  a: 10,
-  b: 11,
-  c: 12,
-  d: 13,
-  e: 14,
-  f: 15,
-  A: 10,
-  B: 11,
-  C: 12,
-  D: 13,
-  E: 14,
-  F: 15
-};
-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);
-  if (isOdd)
-    bytes2[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;
-  }
-  return bytes2;
-}
+import { fromHex } from "@unstoppablejs/utils";
 var InternalUint8Array = class extends Uint8Array {
   constructor(buffer) {
     super(buffer);
@@ -66,83 +37,92 @@ var InternalUint8Array = class extends Uint8Array {
 };
 var toInternalBytes = (fn) => (buffer) => fn(buffer instanceof InternalUint8Array ? buffer : new InternalUint8Array(buffer instanceof Uint8Array ? buffer.buffer : typeof buffer === "string" ? fromHex(buffer).buffer : buffer));
 
-// src/internal/mergeUint8.ts
-var mergeUint8 = (...inputs) => {
-  const len = inputs.length;
-  let totalLen = 0;
-  for (let i = 0; i < len; i++)
-    totalLen += inputs[i].byteLength;
-  const result = new Uint8Array(totalLen);
-  for (let idx = 0, at = 0; idx < len; idx++) {
-    const current = inputs[idx];
-    result.set(current, at);
-    at += current.byteLength;
-  }
-  return result;
-};
+// src/internal/range32.ts
+var range32 = Array(32).fill(0).map((_, idx) => idx + 1);
 
-// src/internal/mapObject.ts
-function mapObject(input, mapper) {
-  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, mapper(value, key)]));
-}
+// src/codecs/address.ts
+var address = createCodec((input) => {
+  const result = new Uint8Array(32);
+  result.set(fromHex2(input), 12);
+  return result;
+}, toInternalBytes((bytes33) => {
+  const binaryAddress = new Uint8Array(bytes33.buffer, bytes33.i + 12, 20);
+  bytes33.i += 32;
+  const nonChecksum = toHex(binaryAddress);
+  const hashedAddres = toHex(keccak_256(nonChecksum.slice(2)));
+  const result = new Array(41);
+  result[0] = "0x";
+  for (let i = 2; i < 42; i++) {
+    const char = nonChecksum[i];
+    result.push(parseInt(hashedAddres[i], 16) > 7 ? char.toUpperCase() : char);
+  }
+  return result.join("");
+}));
 
-// 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((bytes33) => {
     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 = bytes33.i + 32;
+    for (let idx = bytes33.i + (32 - n64 * 8); idx < nextBlock; idx += 8)
+      result = result << 64n | bytes33.v.getBigUint64(idx);
+    bytes33.i = nextBlock;
     return result;
-  });
-};
-var cache = /* @__PURE__ */ new Map();
-var uint = (nBits) => {
-  let cached = cache.get(nBits);
-  if (cached)
-    return cached;
-  const nBytes = nBits / 8;
-  cached = createCodec(encode(nBytes), decode(nBytes));
-  cache.set(nBits, cached);
-  return cached;
+  }));
 };
+var [
+  uint8,
+  uint16,
+  uint24,
+  uint32,
+  uint40,
+  uint48,
+  uint56,
+  uint64,
+  uint72,
+  uint80,
+  uint88,
+  uint96,
+  uint104,
+  uint112,
+  uint120,
+  uint128,
+  uint136,
+  uint144,
+  uint152,
+  uint160,
+  uint168,
+  uint176,
+  uint184,
+  uint192,
+  uint200,
+  uint208,
+  uint226,
+  uint224,
+  uint232,
+  uint240,
+  uint248,
+  uint256
+] = range32.map(getCodec);
+var uint = uint256;
 
 // src/codecs/bool.ts
-var bool = enhanceCodec(uint(8), (value) => value ? 1n : 0n, Boolean);
+var bool = enhanceCodec(uint8, (value) => value ? 1n : 0n, Boolean);
 
-// src/codecs/str.ts
-var uint256 = uint(256);
-var textEncoder = new TextEncoder();
-var strEnc = (str2) => {
-  const val = textEncoder.encode(str2);
-  const args = [uint256.enc(BigInt(val.length)), val];
+// src/codecs/bytes.ts
+import { mergeUint8 } from "@unstoppablejs/utils";
+var bytesEnc = (val) => {
+  const args = [uint[0](BigInt(val.length)), val];
   const extra = val.length % 32;
   if (extra > 0) {
     ;
@@ -150,82 +130,71 @@ var strEnc = (str2) => {
   }
   return mergeUint8(...args);
 };
-strEnc.din = true;
-var textDecoder = new TextDecoder();
-var strDec = toInternalBytes((bytes2) => {
-  let nElements = Number(uint256.dec(bytes2));
-  const dv = new DataView(bytes2.buffer, bytes2.i, nElements);
-  const extra = nElements % 32;
-  const padding = extra && 32 - extra;
-  bytes2.i += nElements + padding;
-  return textDecoder.decode(dv);
+bytesEnc.dyn = true;
+var bytesDec = toInternalBytes((bytes33) => {
+  let nElements = Number(uint[1](bytes33));
+  const result = new Uint8Array(bytes33.buffer, bytes33.i, nElements);
+  bytes33.i += nElements + nElements % 32;
+  return result;
 });
-strDec.din = true;
-var str = createCodec(strEnc, strDec);
-str.din = true;
+bytesDec.dyn = true;
+var bytes = createCodec(bytesEnc, bytesDec);
+bytes.dyn = true;
 
-// src/codecs/bytes.ts
-var bytesEnc = (nBytes) => (bytes2) => {
-  if (bytes2.length === 32)
-    return bytes2;
+// src/codecs/str.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var str = enhanceCodec(bytes, textEncoder.encode.bind(textEncoder), textDecoder.decode.bind(textDecoder));
+
+// src/codecs/BytesX.ts
+var bytesEnc2 = (nBytes) => (bytes33) => {
+  if (bytes33.length === nBytes && nBytes === 32)
+    return bytes33;
   const result = new Uint8Array(32);
-  result.set(bytes2.length === nBytes ? bytes2 : bytes2.slice(0, nBytes));
+  result.set(bytes33.length === nBytes ? bytes33 : bytes33.slice(0, nBytes));
   return result;
 };
-var bytesDec = (nBytes) => toInternalBytes((bytes2) => {
-  const result = new Uint8Array(bytes2.buffer, bytes2.i, nBytes);
-  bytes2.i += 32;
-  return result;
-});
-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);
-    }
-  }
+var bytesDec2 = (nBytes) => toInternalBytes((bytes33) => {
+  const result = new Uint8Array(bytes33.buffer, bytes33.i, nBytes);
+  bytes33.i += 32;
   return result;
 });
-var call = (...codecs) => createCodec(callEnc(...codecs.map(([encoder]) => encoder)), callDec(...codecs.map(([, decoder]) => decoder)));
-call.enc = callEnc;
-call.dec = callDec;
+var [
+  bytes1,
+  bytes2,
+  bytes3,
+  bytes4,
+  bytes5,
+  bytes6,
+  bytes7,
+  bytes8,
+  bytes9,
+  bytes10,
+  bytes11,
+  bytes12,
+  bytes13,
+  bytes14,
+  bytes15,
+  bytes16,
+  bytes17,
+  bytes18,
+  bytes19,
+  bytes20,
+  bytes21,
+  bytes22,
+  bytes23,
+  bytes24,
+  bytes25,
+  bytes26,
+  bytes27,
+  bytes28,
+  bytes29,
+  bytes30,
+  bytes31,
+  bytes32
+] = range32.map((nBytes) => createCodec(bytesEnc2(nBytes), bytesDec2(nBytes)));
 
-// src/codecs/int.ts
+// src/codecs/Int.ts
 var signGetters = {
   "1": "getInt8",
   "2": "getInt16",
@@ -246,7 +215,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 = [
@@ -258,127 +227,281 @@ 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 [bytes34, shift, fn2] = sequence[i];
+      idx -= bytes34;
+      dv[usignSetters[bytes34]](idx, fn2(input));
       input >>= shift;
     }
-    const [bytes2, , fn] = sequence[0];
-    idx -= bytes2;
-    dv[signSetters[bytes2]](idx, fn(input));
+    const [bytes33, , fn] = sequence[0];
+    idx -= bytes33;
+    dv[signSetters[bytes33]](idx, fn(input));
     return result;
   };
-  const dec = toInternalBytes((bytes2) => {
-    let idx = bytes2.i + 32 - nBytes;
+  const dec = toInternalBytes((bytes33) => {
+    let idx = bytes33.i + 32 - nBytes;
     const bits = sequence[0][0];
-    let result = BigInt(bytes2.v[signGetters[bits]](idx));
+    let result = BigInt(bytes33.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(bytes33.v[usignGetters[bits2]](idx));
       idx += bits2;
     }
-    bytes2.i += 32;
+    bytes33.i += 32;
     return result;
   });
   return createCodec(enc, dec);
 };
-var cache2 = /* @__PURE__ */ new Map();
-var int = (nBits) => {
-  let cached = cache2.get(nBits);
-  if (cached)
-    return cached;
-  const nBytes = nBits / 8;
-  cached = getCodec(nBytes);
-  cache2.set(nBits, cached);
-  return cached;
-};
-int.enc = (nBits) => int(nBits).enc;
-int.dec = (nBits) => int(nBits).dec;
+var [
+  int8,
+  int16,
+  int24,
+  int32,
+  int40,
+  int48,
+  int56,
+  int64,
+  int72,
+  int80,
+  int88,
+  int96,
+  int104,
+  int112,
+  int120,
+  int128,
+  int136,
+  int144,
+  int152,
+  int160,
+  int168,
+  int176,
+  int184,
+  int192,
+  int200,
+  int208,
+  int226,
+  int224,
+  int232,
+  int240,
+  int248,
+  int256
+] = range32.map(getCodec2);
+var int = int256;
+
+// src/codecs/Fixed.ts
+var Fixed = (baseCodec, decimals) => enhanceCodec(baseCodec, (x) => x.value, (value) => ({ value, decimals }));
 
-// src/codecs/fixed.ts
-var creator = (codec) => {
-  const cache3 = /* @__PURE__ */ new Map();
-  return (nBits, decimals) => {
-    const key = decimals << 8 | nBits;
-    let cached = cache3.get(key);
-    if (cached)
-      return cached;
-    cached = enhanceCodec(codec(nBits), (x) => x.value, (value) => ({ value, decimals }));
-    cache3.set(key, cached);
-    return cached;
+// src/codecs/Tuple.ts
+import { mergeUint8 as mergeUint82 } from "@unstoppablejs/utils";
+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] = uint[0](len);
+      const data = mapped[idx];
+      resultArray.push(data);
+      len += BigInt(data.length);
+    });
+    return mergeUint82(...resultArray);
   };
+  res.dyn = true;
+  return res;
 };
-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;
-
-// 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]));
+var staticEnc = (...encoders) => (values) => mergeUint82(...values.map((value, idx) => encoders[idx](value)));
+var staticDec = (...decoders) => toInternalBytes((bytes33) => decoders.map((decoder) => decoder(bytes33)));
+var dynamicDec = (...decoders) => {
+  const res = toInternalBytes((bytes33) => {
+    const result = new Array(decoders.length);
+    let start = bytes33.i;
+    for (let i = 0; i < decoders.length; i++) {
+      if (decoders[i].dyn) {
+        const offset = Number(uint[1](bytes33));
+        const current = bytes33.i;
+        bytes33.i = start + offset;
+        result[i] = decoders[i](bytes33);
+        bytes33.i = current;
+      } else {
+        result[i] = decoders[i](bytes33);
+      }
+    }
+    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;
 };
-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])));
+
+// 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
+import { mergeUint8 as mergeUint83 } from "@unstoppablejs/utils";
 var vectorEnc = (inner, size) => {
-  if (size >= 0)
-    return (value) => mergeUint8(...value.map(inner));
-  const result = (value) => mergeUint8(uint2563.enc(BigInt(value.length)), ...value.map(inner));
-  result.din = true;
-  return result;
+  if (size >= 0) {
+    const encoder2 = (value) => mergeUint83(...value.map(inner));
+    encoder2.dyn = inner.dyn;
+    return encoder2;
+  }
+  const encoder = (value) => mergeUint83(uint[0](BigInt(value.length)), ...value.map(inner));
+  encoder.dyn = true;
+  return encoder;
 };
 var vectorDec = (getter, size) => {
-  const result = toInternalBytes((bytes2) => {
-    const nElements = size >= 0 ? size : Number(uint2563.dec(bytes2));
-    const result2 = new Array(nElements);
+  const decoder = toInternalBytes((bytes33) => {
+    const nElements = size >= 0 ? size : Number(uint[1](bytes33));
+    const decoded = new Array(nElements);
     for (let i = 0; i < nElements; i++) {
-      result2[i] = getter(bytes2);
+      decoded[i] = getter(bytes33);
     }
-    return result2;
+    return decoded;
   });
   if (size == null)
-    result.din = true;
-  return result;
+    decoder.dyn = true;
+  return decoder;
 };
-var vector = (inner, size) => {
-  const result = createCodec(vectorEnc(inner[0], size), vectorDec(inner[1], size));
+var Vector = (inner, size) => {
+  const codec = createCodec(vectorEnc(inner[0], size), vectorDec(inner[1], size));
   if (size == null)
-    result.din = true;
-  return result;
+    codec.dyn = true;
+  return codec;
 };
-vector.enc = vectorEnc;
-vector.dec = vectorDec;
 export {
+  Fixed,
+  Struct,
+  Tuple,
+  Vector,
+  address,
   bool,
   bytes,
-  call,
+  bytes1,
+  bytes10,
+  bytes11,
+  bytes12,
+  bytes13,
+  bytes14,
+  bytes15,
+  bytes16,
+  bytes17,
+  bytes18,
+  bytes19,
+  bytes2,
+  bytes20,
+  bytes21,
+  bytes22,
+  bytes23,
+  bytes24,
+  bytes25,
+  bytes26,
+  bytes27,
+  bytes28,
+  bytes29,
+  bytes3,
+  bytes30,
+  bytes31,
+  bytes32,
+  bytes4,
+  bytes5,
+  bytes6,
+  bytes7,
+  bytes8,
+  bytes9,
   createCodec,
   enhanceCodec,
   enhanceDecoder,
   enhanceEncoder,
-  fixed,
   int,
+  int104,
+  int112,
+  int120,
+  int128,
+  int136,
+  int144,
+  int152,
+  int16,
+  int160,
+  int168,
+  int176,
+  int184,
+  int192,
+  int200,
+  int208,
+  int224,
+  int226,
+  int232,
+  int24,
+  int240,
+  int248,
+  int256,
+  int32,
+  int40,
+  int48,
+  int56,
+  int64,
+  int72,
+  int8,
+  int80,
+  int88,
+  int96,
   str,
-  struct,
-  tuple,
-  ufixed,
   uint,
-  vector
+  uint104,
+  uint112,
+  uint120,
+  uint128,
+  uint136,
+  uint144,
+  uint152,
+  uint16,
+  uint160,
+  uint168,
+  uint176,
+  uint184,
+  uint192,
+  uint200,
+  uint208,
+  uint224,
+  uint226,
+  uint232,
+  uint24,
+  uint240,
+  uint248,
+  uint256,
+  uint32,
+  uint40,
+  uint48,
+  uint56,
+  uint64,
+  uint72,
+  uint8,
+  uint80,
+  uint88,
+  uint96
 };
 //# sourceMappingURL=solidity-codecs.js.map