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

package/dist/codecs/BytesX.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from "../types";
+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

@@ -1,3 +1,6 @@
-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>;
+import { Codec } from "../types";
+export interface Decimal<T extends number = number> {
+    value: bigint;
+    decimals: T;
+}
+export declare const Fixed: <D extends number>(baseCodec: Codec<bigint>, decimals: D) => Codec<Decimal<D>>;

package/dist/codecs/Int.d.ts

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

package/dist/codecs/Uint.d.ts

@@ -1,6 +1,4 @@
 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>;
-};
+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>;
+export declare const uint: Codec<bigint>;
+export declare const address: Codec<bigint>;

package/dist/codecs/Vector.d.ts

@@ -1,6 +1,2 @@
-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[]>;
-};
+import { Codec } from "../types";
+export declare const Vector: <T>(inner: Codec<T>, size?: number | undefined) => Codec<T[]>;

package/dist/codecs/bytes.d.ts

@@ -0,0 +1 @@
+export declare const bytes: import("../types").Codec<Uint8Array>;

package/dist/codecs/index.d.ts

@@ -1,9 +1,10 @@
 export { bool } from "./bool";
+export { bytes } from "./bytes";
 export { str } from "./str";
-export { Bytes } from "./Bytes";
-export { Fixed, Ufixed } from "./Fixed";
-export { Int } from "./Int";
+export * from "./BytesX";
+export * from "./Int";
+export * from "./Uint";
+export * from "./Fixed";
 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,116 @@ 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,
+  address: () => address,
   bool: () => bool,
+  bytes: () => bytes,
+  bytes1: () => bytes1,
+  bytes10: () => bytes10,
+  bytes11: () => bytes11,
+  bytes12: () => bytes12,
+  bytes13: () => bytes13,
+  bytes14: () => bytes14,
+  bytes15: () => bytes15,
+  bytes16: () => bytes16,
+  bytes17: () => bytes17,
+  bytes18: () => bytes18,
+  bytes19: () => bytes19,
+  bytes2: () => bytes2,
+  bytes20: () => bytes20,
+  bytes21: () => bytes21,
+  bytes22: () => bytes22,
+  bytes23: () => bytes23,
+  bytes24: () => bytes24,
+  bytes25: () => bytes25,
+  bytes26: () => bytes26,
+  bytes27: () => bytes27,
+  bytes28: () => bytes28,
+  bytes29: () => bytes29,
+  bytes3: () => bytes3,
+  bytes30: () => bytes30,
+  bytes31: () => bytes31,
+  bytes32: () => bytes32,
+  bytes4: () => bytes4,
+  bytes5: () => bytes5,
+  bytes6: () => bytes6,
+  bytes7: () => bytes7,
+  bytes8: () => bytes8,
+  bytes9: () => bytes9,
   createCodec: () => createCodec,
-  dyn: () => dyn,
   enhanceCodec: () => enhanceCodec,
   enhanceDecoder: () => enhanceDecoder,
   enhanceEncoder: () => enhanceEncoder,
-  str: () => str
+  int: () => int,
+  int104: () => int104,
+  int112: () => int112,
+  int120: () => int120,
+  int128: () => int128,
+  int136: () => int136,
+  int144: () => int144,
+  int152: () => int152,
+  int16: () => int16,
+  int160: () => int160,
+  int168: () => int168,
+  int176: () => int176,
+  int184: () => int184,
+  int192: () => int192,
+  int200: () => int200,
+  int208: () => int208,
+  int224: () => int224,
+  int226: () => int226,
+  int232: () => int232,
+  int24: () => int24,
+  int240: () => int240,
+  int248: () => int248,
+  int256: () => int256,
+  int32: () => int32,
+  int40: () => int40,
+  int48: () => int48,
+  int56: () => int56,
+  int64: () => int64,
+  int72: () => int72,
+  int8: () => int8,
+  int80: () => int80,
+  int88: () => int88,
+  int96: () => int96,
+  str: () => str,
+  uint: () => uint,
+  uint104: () => uint104,
+  uint112: () => uint112,
+  uint120: () => uint120,
+  uint128: () => uint128,
+  uint136: () => uint136,
+  uint144: () => uint144,
+  uint152: () => uint152,
+  uint16: () => uint16,
+  uint160: () => uint160,
+  uint168: () => uint168,
+  uint176: () => uint176,
+  uint184: () => uint184,
+  uint192: () => uint192,
+  uint200: () => uint200,
+  uint208: () => uint208,
+  uint224: () => uint224,
+  uint226: () => uint226,
+  uint232: () => uint232,
+  uint24: () => uint24,
+  uint240: () => uint240,
+  uint248: () => uint248,
+  uint256: () => uint256,
+  uint32: () => uint32,
+  uint40: () => uint40,
+  uint48: () => uint48,
+  uint56: () => uint56,
+  uint64: () => uint64,
+  uint72: () => uint72,
+  uint8: () => uint8,
+  uint80: () => uint80,
+  uint88: () => uint88,
+  uint96: () => uint96
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -87,16 +182,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 bytes = new Uint8Array(nBytes);
+  const bytes33 = new Uint8Array(nBytes);
   if (isOdd)
-    bytes[0] = 0 | HEX_MAP[hexString[2]];
+    bytes33[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;
+    bytes33[isOdd + i++] = a << 4 | b;
   }
-  return bytes;
+  return bytes33;
 }
 var InternalUint8Array = class extends Uint8Array {
   constructor(buffer) {
@@ -123,6 +218,9 @@ var mergeUint8 = (...inputs) => {
   return result;
 };
 
+// src/internal/range32.ts
+var range32 = Array(32).fill(0).map((_, idx) => idx + 1);
+
 // src/codecs/Uint.ts
 var getCodec = (nBytes) => {
   const n64 = Math.ceil(nBytes / 8);
@@ -135,37 +233,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;
+var address = uint160;
 
 // 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
+var bytesEnc = (val) => {
+  const args = [uint[0](BigInt(val.length)), val];
   const extra = val.length % 32;
   if (extra > 0) {
     ;
@@ -173,36 +292,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 = {
@@ -243,62 +395,71 @@ 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);
 var dynamicEnc = (...encoders) => {
   const res = (values) => {
     const mapped = values.map((value, idx) => encoders[idx](value));
@@ -315,7 +476,7 @@ 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);
@@ -326,20 +487,20 @@ var dynamicEnc = (...encoders) => {
   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 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;
@@ -362,36 +523,33 @@ var Struct = (codecs) => {
 };
 
 // src/codecs/Vector.ts
-var uint2563 = Uint(256);
 var vectorEnc = (inner, size) => {
   if (size >= 0) {
-    const res = (value) => mergeUint8(...value.map(inner));
-    res.dyn = inner.dyn;
-    return res;
+    const encoder2 = (value) => mergeUint8(...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) => mergeUint8(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;
 //# sourceMappingURL=solidity-codecs.cjs.development.js.map