solidity-codecs 0.0.1-beta.3 → 0.1.1

package/dist/solidity-codecs.js

@@ -21,46 +21,12 @@ var enhanceEncoder = (encoder, mapper) => dyn(encoder, (value) => encoder(mapper
 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 bytes = new Uint8Array(nBytes);
-  if (isOdd)
-    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]];
-    bytes[isOdd + i++] = a << 4 | b;
-  }
-  return bytes;
-}
+import { fromHex } from "@unstoppablejs/utils";
 var InternalUint8Array = class extends Uint8Array {
   constructor(buffer) {
     super(buffer);
@@ -71,20 +37,27 @@ 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;
-  }
+// src/internal/range32.ts
+var range32 = Array(32).fill(0).map((_, idx) => idx + 1);
+
+// 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 getCodec = (nBytes) => {
@@ -98,37 +71,58 @@ var getCodec = (nBytes) => {
       input >>= 64n;
     }
     return result;
-  }, toInternalBytes((bytes) => {
+  }, toInternalBytes((bytes33) => {
     let result = 0n;
-    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;
+    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 = getCodec(nBytes);
-  cache.set(nBits, cached);
-  return cached;
-};
-Uint.enc = (nBits) => Uint(nBits).enc;
-Uint.dec = (nBits) => Uint(nBits).dec;
+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) {
     ;
@@ -136,36 +130,69 @@ var strEnc = (str2) => {
   }
   return mergeUint8(...args);
 };
-strEnc.dyn = true;
-var textDecoder = new TextDecoder();
-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;
-  bytes.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.dyn = true;
-var str = createCodec(strEnc, strDec);
-str.dyn = true;
+bytesDec.dyn = true;
+var bytes = createCodec(bytesEnc, bytesDec);
+bytes.dyn = true;
+
+// 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/Bytes.ts
-var bytesEnc = (nBytes) => (bytes) => {
-  if (bytes.length === 32)
-    return bytes;
+// src/codecs/BytesX.ts
+var bytesEnc2 = (nBytes) => (bytes33) => {
+  if (bytes33.length === nBytes && nBytes === 32)
+    return bytes33;
   const result = new Uint8Array(32);
-  result.set(bytes.length === nBytes ? bytes : bytes.slice(0, nBytes));
+  result.set(bytes33.length === nBytes ? bytes33 : bytes33.slice(0, nBytes));
   return result;
 };
-var bytesDec = (nBytes) => toInternalBytes((bytes) => {
-  const result = new Uint8Array(bytes.buffer, bytes.i, nBytes);
-  bytes.i += 32;
+var bytesDec2 = (nBytes) => toInternalBytes((bytes33) => {
+  const result = new Uint8Array(bytes33.buffer, bytes33.i, nBytes);
+  bytes33.i += 32;
   return result;
 });
-var Bytes = (nBytes) => createCodec(bytesEnc(nBytes), bytesDec(nBytes));
-Bytes.enc = bytesEnc;
-Bytes.dec = bytesDec;
+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
 var signGetters = {
@@ -206,62 +233,72 @@ var getCodec2 = (nBytes) => {
     }
     let idx = 32;
     for (let i = sequence.length - 1; i > 0; i--) {
-      const [bytes2, shift, fn2] = sequence[i];
-      idx -= bytes2;
-      dv[usignSetters[bytes2]](idx, fn2(input));
+      const [bytes34, shift, fn2] = sequence[i];
+      idx -= bytes34;
+      dv[usignSetters[bytes34]](idx, fn2(input));
       input >>= shift;
     }
-    const [bytes, , fn] = sequence[0];
-    idx -= bytes;
-    dv[signSetters[bytes]](idx, fn(input));
+    const [bytes33, , fn] = sequence[0];
+    idx -= bytes33;
+    dv[signSetters[bytes33]](idx, fn(input));
     return result;
   };
-  const dec = toInternalBytes((bytes) => {
-    let idx = bytes.i + 32 - nBytes;
+  const dec = toInternalBytes((bytes33) => {
+    let idx = bytes33.i + 32 - nBytes;
     const bits = sequence[0][0];
-    let result = BigInt(bytes.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(bytes.v[usignGetters[bits2]](idx));
+      result = result << shift | BigInt(bytes33.v[usignGetters[bits2]](idx));
       idx += bits2;
     }
-    bytes.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 = getCodec2(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 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;
-  };
-};
-var Fixed = creator(Int);
-var Ufixed = creator(Uint);
+var Fixed = (baseCodec, decimals) => enhanceCodec(baseCodec, (x) => x.value, (value) => ({ value, decimals }));
 
 // src/codecs/Tuple.ts
-var uint2562 = Uint(256);
+import { mergeUint8 as mergeUint82 } from "@unstoppablejs/utils";
 var dynamicEnc = (...encoders) => {
   const res = (values) => {
     const mapped = values.map((value, idx) => encoders[idx](value));
@@ -278,31 +315,31 @@ var dynamicEnc = (...encoders) => {
       }
     }
     dinamics.forEach((idx) => {
-      resultArray[idx] = uint2562.enc(len);
+      resultArray[idx] = uint[0](len);
       const data = mapped[idx];
       resultArray.push(data);
       len += BigInt(data.length);
     });
-    return mergeUint8(...resultArray);
+    return mergeUint82(...resultArray);
   };
   res.dyn = true;
   return res;
 };
-var staticEnc = (...encoders) => (values) => mergeUint8(...values.map((value, idx) => encoders[idx](value)));
-var staticDec = (...decoders) => toInternalBytes((bytes) => decoders.map((decoder) => decoder(bytes)));
+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((bytes) => {
+  const res = toInternalBytes((bytes33) => {
     const result = new Array(decoders.length);
-    let start = bytes.i;
+    let start = bytes33.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;
+        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](bytes);
+        result[i] = decoders[i](bytes33);
       }
     }
     return result;
@@ -325,53 +362,146 @@ var Struct = (codecs) => {
 };
 
 // src/codecs/Vector.ts
-var uint2563 = Uint(256);
+import { mergeUint8 as mergeUint83 } from "@unstoppablejs/utils";
 var vectorEnc = (inner, size) => {
   if (size >= 0) {
-    const res = (value) => mergeUint8(...value.map(inner));
-    res.dyn = inner.dyn;
-    return res;
+    const encoder2 = (value) => mergeUint83(...value.map(inner));
+    encoder2.dyn = inner.dyn;
+    return encoder2;
   }
-  const result = (value) => mergeUint8(uint2563.enc(BigInt(value.length)), ...value.map(inner));
-  result.dyn = true;
-  return result;
+  const encoder = (value) => mergeUint83(uint[0](BigInt(value.length)), ...value.map(inner));
+  encoder.dyn = true;
+  return encoder;
 };
 var vectorDec = (getter, size) => {
-  const result = toInternalBytes((bytes) => {
-    const nElements = size >= 0 ? size : Number(uint2563.dec(bytes));
-    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(bytes);
+      decoded[i] = getter(bytes33);
     }
-    return result2;
+    return decoded;
   });
   if (size == null)
-    result.dyn = true;
-  return result;
+    decoder.dyn = true;
+  return decoder;
 };
 var Vector = (inner, size) => {
-  const result = createCodec(vectorEnc(inner[0], size), vectorDec(inner[1], size));
+  const codec = createCodec(vectorEnc(inner[0], size), vectorDec(inner[1], size));
   if (size == null)
-    result.dyn = true;
-  return result;
+    codec.dyn = true;
+  return codec;
 };
-Vector.enc = vectorEnc;
-Vector.dec = vectorDec;
 export {
-  Bytes,
   Fixed,
-  Int,
   Struct,
   Tuple,
-  Ufixed,
-  Uint,
   Vector,
+  address,
   bool,
+  bytes,
+  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,
-  dyn,
   enhanceCodec,
   enhanceDecoder,
   enhanceEncoder,
-  str
+  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,
+  uint,
+  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