solidity-codecs 0.0.1-beta.1

package/README.md

@@ -0,0 +1 @@
+# @unstoppablejs/solidity-codecs

package/dist/codecs/Bytes.d.ts

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

package/dist/codecs/Enum.d.ts

@@ -0,0 +1,57 @@
+import { Codec, Decoder, Encoder, StringRecord } from "../types"
+export declare const Enum: {
+  <
+    O extends StringRecord<Codec<any>>,
+    OT extends {
+      [K in keyof O]: O[K] extends Codec<infer D>
+        ? D extends undefined
+          ? {
+              tag: K
+              value?: undefined
+            }
+          : {
+              tag: K
+              value: D
+            }
+        : unknown
+    },
+  >(
+    inner: O,
+  ): Codec<OT[keyof O]>
+  enc: <
+    O_1 extends StringRecord<Encoder<any>>,
+    OT_1 extends {
+      [K_1 in keyof O_1]: O_1[K_1] extends Encoder<infer D_1>
+        ? D_1 extends undefined
+          ? {
+              tag: K_1
+              value?: undefined
+            }
+          : {
+              tag: K_1
+              value: D_1
+            }
+        : unknown
+    },
+  >(
+    inner: O_1,
+  ) => Encoder<OT_1[keyof O_1]>
+  dec: <
+    O_2 extends StringRecord<Decoder<any>>,
+    OT_2 extends {
+      [K_2 in keyof O_2]: O_2[K_2] extends Decoder<infer D_2>
+        ? D_2 extends undefined
+          ? {
+              tag: K_2
+              value?: undefined
+            }
+          : {
+              tag: K_2
+              value: D_2
+            }
+        : unknown
+    },
+  >(
+    inner: O_2,
+  ) => Decoder<OT_2[keyof O_2]>
+}

package/dist/codecs/Option.d.ts

@@ -0,0 +1,6 @@
+import { Decoder, Encoder, Codec } from "../types"
+export declare const Option: {
+  <T>(inner: Codec<T>): Codec<void | T | undefined>
+  enc: <T_1>(inner: Encoder<T_1>) => Encoder<void | T_1 | undefined>
+  dec: <T_2>(inner: Decoder<T_2>) => Decoder<void | T_2 | undefined>
+}

package/dist/codecs/Result.d.ts

@@ -0,0 +1,22 @@
+import { Decoder, Encoder, Codec } from "../types"
+declare type ResultPayload<OK, KO> =
+  | {
+      success: true
+      value: OK
+    }
+  | {
+      success: false
+      value: KO
+    }
+export declare const Result: {
+  <OK, KO>(okCodec: Codec<OK>, koCodec: Codec<KO>): Codec<ResultPayload<OK, KO>>
+  dec: <OK_1, KO_1>(
+    okDecoder: Decoder<OK_1>,
+    koDecoder: Decoder<KO_1>,
+  ) => Decoder<ResultPayload<OK_1, KO_1>>
+  enc: <OK_2, KO_2>(
+    okEncoder: Encoder<OK_2>,
+    koEncoder: Encoder<KO_2>,
+  ) => Encoder<ResultPayload<OK_2, KO_2>>
+}
+export {}

package/dist/codecs/Struct.d.ts

@@ -0,0 +1,25 @@
+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>
+}

package/dist/codecs/Tuple.d.ts

@@ -0,0 +1,25 @@
+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]>
+}

package/dist/codecs/Vector.d.ts

@@ -0,0 +1,14 @@
+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 {}

package/dist/codecs/bool.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from "../types";
+export declare const bool: Codec<boolean>;

package/dist/codecs/bytes.d.ts

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

package/dist/codecs/call.d.ts

@@ -0,0 +1,6 @@
+import { Codec, Decoder, Encoder } from "../types";
+export declare const call: {
+    <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]>;
+};

package/dist/codecs/compact.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from "../types"
+export declare const compact: Codec<number | bigint>

package/dist/codecs/fixed-width-ints.d.ts

@@ -0,0 +1,11 @@
+import { Codec } from "../types"
+export declare const u8: Codec<number>
+export declare const u16: Codec<number>
+export declare const u32: Codec<number>
+export declare const u64: Codec<bigint>
+export declare const i8: Codec<number>
+export declare const i16: Codec<number>
+export declare const i32: Codec<number>
+export declare const i64: Codec<bigint>
+export declare const u128: Codec<bigint>
+export declare const i128: Codec<bigint>

package/dist/codecs/fixed.d.ts

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

package/dist/codecs/index.d.ts

@@ -0,0 +1,10 @@
+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";

package/dist/codecs/int.d.ts

@@ -0,0 +1,6 @@
+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>;
+};

package/dist/codecs/str.d.ts

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

package/dist/codecs/struct.d.ts

@@ -0,0 +1,6 @@
+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>;
+};

package/dist/codecs/tuple.d.ts

@@ -0,0 +1,6 @@
+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]>;
+};

package/dist/codecs/uint.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from "../types";
+export declare const uint: (nBits: number) => Codec<bigint>;

package/dist/codecs/vector.d.ts

@@ -0,0 +1,6 @@
+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/void.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from "../types"
+export declare const _void: Codec<undefined>

package/dist/index.cjs

@@ -0,0 +1,7 @@
+"use strict"
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./scale-ts.cjs.production.min.js")
+} else {
+  module.exports = require("./scale-ts.cjs.development.js")
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./utils";
+export * from "./types";
+export * from "./codecs";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict"
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./scale-ts.cjs.production.min.js")
+} else {
+  module.exports = require("./scale-ts.cjs.development.js")
+}