@alephium/web3 1.3.0 → 1.5.0

package/dist/src/address/address.js

@@ -67,18 +67,18 @@ function decodeAndValidateAddress(address) {
     if (addressType === AddressType.P2MPKH) {
         let multisig;
         try {
-            multisig = lockup_script_codec_1.lockupScriptCodec.decode(decoded).script;
+            multisig = lockup_script_codec_1.lockupScriptCodec.decode(decoded).value;
         }
         catch (_) {
             throw new Error(`Invalid multisig address: ${address}`);
         }
-        const n = multisig.publicKeyHashes.value.length;
-        const m = codec_1.compactSignedIntCodec.toI32(multisig.m);
+        const n = multisig.publicKeyHashes.length;
+        const m = multisig.m;
         if (n < m || m <= 0) {
             throw new Error(`Invalid multisig address, n: ${n}, m: ${m}`);
         }
-        const encodedNSize = codec_1.compactSignedIntCodec.encodeI32(n).length;
-        const encodedMSize = multisig.m.rest.length + 1;
+        const encodedNSize = codec_1.i32Codec.encode(n).length;
+        const encodedMSize = codec_1.i32Codec.encode(m).length;
         const size = encodedNSize + PublicKeyHashSize * n + encodedMSize + 1; // 1 for the P2MPKH prefix
         if (decoded.length === size)
             return decoded;
@@ -214,6 +214,12 @@ function subContractId(parentContractId, pathInHex, group) {
     if (group < 0 || group >= constants_1.TOTAL_NUMBER_OF_GROUPS) {
         throw new Error(`Invalid group ${group}`);
     }
+    if (!(0, utils_1.isHexString)(parentContractId)) {
+        throw new Error(`Invalid parent contract ID: ${parentContractId}, expected hex string`);
+    }
+    if (!(0, utils_1.isHexString)(pathInHex)) {
+        throw new Error(`Invalid path: ${pathInHex}, expected hex string`);
+    }
     const data = (0, utils_1.concatBytes)([(0, utils_1.hexToBinUnsafe)(parentContractId), (0, utils_1.hexToBinUnsafe)(pathInHex)]);
     const bytes = new Uint8Array([
         ...blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),

package/dist/src/api/api-alephium.d.ts

@@ -10,7 +10,6 @@ export interface AddressBalance {
     lockedBalance: string;
     /** @format x.x ALPH */
     lockedBalanceHint: string;
-    warning?: string;
 }
 /** AddressInfo */
 export interface AddressInfo {
@@ -75,7 +74,6 @@ export interface Balance {
     lockedTokenBalances?: Token[];
     /** @format int32 */
     utxoNum: number;
-    warning?: string;
 }
 /** Balances */
 export interface Balances {
@@ -473,6 +471,7 @@ export interface CompilerOptions {
     ignoreUnusedPrivateFunctionsWarnings?: boolean;
     ignoreUpdateFieldsCheckWarnings?: boolean;
     ignoreCheckExternalCallerWarnings?: boolean;
+    ignoreUnusedFunctionReturnWarnings?: boolean;
 }
 /** Confirmed */
 export interface Confirmed {
@@ -1015,7 +1014,6 @@ export interface UTXO {
 /** UTXOs */
 export interface UTXOs {
     utxos: UTXO[];
-    warning?: string;
 }
 /** Unauthorized */
 export interface Unauthorized {
@@ -1191,7 +1189,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 3.4.0
+ * @version 3.5.2
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/dist/src/api/api-alephium.js

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 3.4.0
+ * @version 3.5.2
  * @baseUrl ../
  */
 class Api extends HttpClient {

package/dist/src/codec/array-codec.d.ts

@@ -1,16 +1,8 @@
-import { Parser } from 'binary-parser';
-import { DecodedCompactInt } from './compact-int-codec';
 import { Codec } from './codec';
-export interface DecodedArray<T> {
-    length: DecodedCompactInt;
-    value: T[];
-}
-export declare class ArrayCodec<T> implements Codec<T[]> {
+import { Reader } from './reader';
+export declare class ArrayCodec<T> extends Codec<T[]> {
     private childCodec;
-    parser: Parser;
-    constructor(childCodec: Codec<T>, parser?: Parser);
+    constructor(childCodec: Codec<T>);
     encode(input: T[]): Uint8Array;
-    decode(input: Uint8Array): T[];
-    static arrayParser(parser: Parser): Parser;
-    fromArray(inputs: T[]): DecodedArray<T>;
+    _decode(input: Reader): T[];
 }

package/dist/src/codec/array-codec.js

@@ -18,41 +18,28 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-const binary_parser_1 = require("binary-parser");
 const compact_int_codec_1 = require("./compact-int-codec");
-class ArrayCodec {
-    constructor(childCodec, parser = ArrayCodec.arrayParser(childCodec.parser)) {
+const codec_1 = require("./codec");
+const utils_1 = require("../utils");
+class ArrayCodec extends codec_1.Codec {
+    constructor(childCodec) {
+        super();
         this.childCodec = childCodec;
-        this.parser = parser;
     }
     encode(input) {
-        const result = [...compact_int_codec_1.compactSignedIntCodec.encodeI256(BigInt(input.length))];
+        const bytes = [compact_int_codec_1.i32Codec.encode(input.length)];
         for (const element of input) {
-            result.push(...this.childCodec.encode(element));
+            bytes.push(this.childCodec.encode(element));
         }
-        return new Uint8Array(result);
+        return (0, utils_1.concatBytes)(bytes);
     }
-    decode(input) {
-        const result = this.parser.parse(input);
-        return result.value.map((v) => this.childCodec.decode(v.value));
-    }
-    static arrayParser(parser) {
-        return new binary_parser_1.Parser()
-            .nest('length', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .array('value', {
-            length: function (ctx) {
-                return compact_int_codec_1.compactSignedIntCodec.toI32(this['length']);
-            },
-            type: parser
-        });
-    }
-    fromArray(inputs) {
-        return {
-            length: compact_int_codec_1.compactSignedIntCodec.fromI32(inputs.length),
-            value: inputs
-        };
+    _decode(input) {
+        const length = compact_int_codec_1.i32Codec._decode(input);
+        const array = [];
+        for (let index = 0; index < length; index += 1) {
+            array.push(this.childCodec._decode(input));
+        }
+        return array;
     }
 }
 exports.ArrayCodec = ArrayCodec;

package/dist/src/codec/asset-output-codec.d.ts

@@ -1,22 +1,17 @@
-import { Parser } from 'binary-parser';
-import { ArrayCodec, DecodedArray } from './array-codec';
-import { DecodedCompactInt } from './compact-int-codec';
+import { ArrayCodec } from './array-codec';
 import { ByteString } from './bytestring-codec';
 import { LockupScript } from './lockup-script-codec';
 import { FixedAssetOutput } from '../api/api-alephium';
-import { Codec } from './codec';
+import { ObjectCodec } from './codec';
 import { Token } from './token-codec';
 export interface AssetOutput {
-    amount: DecodedCompactInt;
+    amount: bigint;
     lockupScript: LockupScript;
-    lockTime: Uint8Array;
-    tokens: DecodedArray<Token>;
+    lockTime: bigint;
+    tokens: Token[];
     additionalData: ByteString;
 }
-export declare class AssetOutputCodec implements Codec<AssetOutput> {
-    parser: Parser;
-    encode(input: AssetOutput): Uint8Array;
-    decode(input: Uint8Array): AssetOutput;
+export declare class AssetOutputCodec extends ObjectCodec<AssetOutput> {
     static toFixedAssetOutputs(txIdBytes: Uint8Array, outputs: AssetOutput[]): FixedAssetOutput[];
     static toFixedAssetOutput(txIdBytes: Uint8Array, output: AssetOutput, index: number): FixedAssetOutput;
     static fromFixedAssetOutputs(fixedOutputs: FixedAssetOutput[]): AssetOutput[];

package/dist/src/codec/asset-output-codec.js

@@ -18,76 +18,45 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-const binary_parser_1 = require("binary-parser");
 const array_codec_1 = require("./array-codec");
 const compact_int_codec_1 = require("./compact-int-codec");
-const signed_int_codec_1 = require("./signed-int-codec");
-const long_codec_1 = require("./long-codec");
+const int_as_4bytes_codec_1 = require("./int-as-4bytes-codec");
+const timestamp_codec_1 = require("./timestamp-codec");
 const bytestring_codec_1 = require("./bytestring-codec");
 const lockup_script_codec_1 = require("./lockup-script-codec");
 const hash_1 = require("./hash");
 const utils_1 = require("../utils");
+const codec_1 = require("./codec");
 const token_codec_1 = require("./token-codec");
-class AssetOutputCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .nest('amount', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .nest('lockupScript', {
-            type: lockup_script_codec_1.lockupScriptCodec.parser
-        })
-            .buffer('lockTime', {
-            length: 8
-        })
-            .nest('tokens', {
-            type: token_codec_1.tokensCodec.parser
-        })
-            .nest('additionalData', {
-            type: bytestring_codec_1.byteStringCodec.parser
-        });
-    }
-    encode(input) {
-        const amount = compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount);
-        const lockupScript = lockup_script_codec_1.lockupScriptCodec.encode(input.lockupScript);
-        const tokens = token_codec_1.tokensCodec.encode(input.tokens.value);
-        const additionalData = bytestring_codec_1.byteStringCodec.encode(input.additionalData);
-        return (0, utils_1.concatBytes)([amount, lockupScript, input.lockTime, tokens, additionalData]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
+class AssetOutputCodec extends codec_1.ObjectCodec {
     static toFixedAssetOutputs(txIdBytes, outputs) {
         return outputs.map((output, index) => AssetOutputCodec.toFixedAssetOutput(txIdBytes, output, index));
     }
     static toFixedAssetOutput(txIdBytes, output, index) {
-        const attoAlphAmount = compact_int_codec_1.compactUnsignedIntCodec.toU256(output.amount).toString();
-        const lockTime = Number(long_codec_1.longCodec.decode(output.lockTime));
-        const tokens = output.tokens.value.map((token) => {
+        const attoAlphAmount = output.amount.toString();
+        const lockTime = Number(output.lockTime);
+        const tokens = output.tokens.map((token) => {
             return {
                 id: (0, utils_1.binToHex)(token.tokenId),
-                amount: compact_int_codec_1.compactUnsignedIntCodec.toU256(token.amount).toString()
+                amount: token.amount.toString()
             };
         });
-        const message = (0, utils_1.binToHex)(output.additionalData.value);
-        const scriptType = output.lockupScript.scriptType;
-        const key = (0, utils_1.binToHex)((0, hash_1.blakeHash)((0, utils_1.concatBytes)([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
-        const outputLockupScript = output.lockupScript.script;
+        const message = (0, utils_1.binToHex)(output.additionalData);
+        const scriptType = output.lockupScript.kind;
+        const key = (0, utils_1.binToHex)((0, hash_1.blakeHash)((0, utils_1.concatBytes)([txIdBytes, int_as_4bytes_codec_1.intAs4BytesCodec.encode(index)])));
+        const outputLockupScript = output.lockupScript.value;
         const address = utils_1.bs58.encode(lockup_script_codec_1.lockupScriptCodec.encode(output.lockupScript));
         let hint = undefined;
-        if (scriptType === 0) {
-            // P2PKH
-            hint = (0, hash_1.createHint)(outputLockupScript.publicKeyHash);
+        if (scriptType === 'P2PKH') {
+            hint = (0, hash_1.createHint)(outputLockupScript);
         }
-        else if (scriptType === 1) {
-            // P2MPKH
-            hint = (0, hash_1.createHint)(outputLockupScript.publicKeyHashes.value[0].publicKeyHash);
+        else if (scriptType === 'P2MPKH') {
+            hint = (0, hash_1.createHint)(outputLockupScript.publicKeyHashes[0]);
         }
-        else if (scriptType === 2) {
-            // P2SH
-            hint = (0, hash_1.createHint)(outputLockupScript.scriptHash);
+        else if (scriptType === 'P2SH') {
+            hint = (0, hash_1.createHint)(outputLockupScript);
         }
-        else if (scriptType === 3) {
+        else if (scriptType === 'P2C') {
             throw new Error(`P2C script type not allowed for asset output`);
         }
         else {
@@ -101,33 +70,25 @@ class AssetOutputCodec {
         });
     }
     static fromFixedAssetOutput(fixedOutput) {
-        const amount = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(fixedOutput.attoAlphAmount));
-        const lockTime = long_codec_1.longCodec.encode(BigInt(fixedOutput.lockTime));
+        const amount = BigInt(fixedOutput.attoAlphAmount);
+        const lockTime = BigInt(fixedOutput.lockTime);
         const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(utils_1.bs58.decode(fixedOutput.address));
-        const tokensValue = fixedOutput.tokens.map((token) => {
+        const tokens = fixedOutput.tokens.map((token) => {
             return {
                 tokenId: (0, utils_1.hexToBinUnsafe)(token.id),
-                amount: compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(token.amount))
+                amount: BigInt(token.amount)
             };
         });
-        const tokens = {
-            length: compact_int_codec_1.compactSignedIntCodec.fromI32(tokensValue.length),
-            value: tokensValue
-        };
-        const additionalDataValue = (0, utils_1.hexToBinUnsafe)(fixedOutput.message);
-        const additionalData = {
-            length: compact_int_codec_1.compactSignedIntCodec.fromI32(additionalDataValue.length),
-            value: additionalDataValue
-        };
-        return {
-            amount,
-            lockupScript,
-            lockTime,
-            tokens,
-            additionalData
-        };
+        const additionalData = (0, utils_1.hexToBinUnsafe)(fixedOutput.message);
+        return { amount, lockupScript, lockTime, tokens, additionalData };
     }
 }
 exports.AssetOutputCodec = AssetOutputCodec;
-exports.assetOutputCodec = new AssetOutputCodec();
+exports.assetOutputCodec = new AssetOutputCodec({
+    amount: compact_int_codec_1.u256Codec,
+    lockupScript: lockup_script_codec_1.lockupScriptCodec,
+    lockTime: timestamp_codec_1.timestampCodec,
+    tokens: token_codec_1.tokensCodec,
+    additionalData: bytestring_codec_1.byteStringCodec
+});
 exports.assetOutputsCodec = new array_codec_1.ArrayCodec(exports.assetOutputCodec);

package/dist/src/codec/bigint-codec.d.ts

@@ -1,4 +1,5 @@
 export declare class BigIntCodec {
     static encode(value: bigint): Uint8Array;
-    static decode(encoded: Uint8Array, signed: boolean): bigint;
+    static decodeUnsigned(encoded: Uint8Array): bigint;
+    static decodeSigned(encoded: Uint8Array): bigint;
 }

package/dist/src/codec/bigint-codec.js

@@ -61,13 +61,25 @@ class BigIntCodec {
         // The byte array needs to be reversed since we've constructed it in little-endian order.
         return new Uint8Array(bytes.reverse());
     }
-    static decode(encoded, signed) {
+    static decodeUnsigned(encoded) {
+        // Special case for zero.
+        if (encoded.length === 1 && encoded[0] === 0) {
+            return 0n;
+        }
+        // Convert the byte array to a bigint
+        let value = 0n;
+        for (const byte of encoded) {
+            value = (value << 8n) | BigInt(byte);
+        }
+        return value;
+    }
+    static decodeSigned(encoded) {
         // Special case for zero.
         if (encoded.length === 1 && encoded[0] === 0) {
             return 0n;
         }
         // Determine if the number is negative by checking the most significant byte (MSB)
-        const isNegative = signed ? encoded[0] === 0xff : signed;
+        const isNegative = (encoded[0] & 0x80) !== 0;
         // Convert the byte array to a bigint
         let value = 0n;
         for (const byte of encoded) {

package/dist/src/codec/bytestring-codec.d.ts

@@ -1,15 +1,10 @@
-import { Parser } from 'binary-parser';
-import { DecodedCompactInt } from './compact-int-codec';
 import { Codec } from './codec';
-export interface ByteString {
-    length: DecodedCompactInt;
-    value: Uint8Array;
-}
-export declare class ByteStringCodec implements Codec<ByteString> {
-    parser: Parser;
+import { Reader } from './reader';
+import { ArrayCodec } from './array-codec';
+export type ByteString = Uint8Array;
+export declare class ByteStringCodec extends Codec<ByteString> {
     encode(input: ByteString): Uint8Array;
-    decode(input: Uint8Array): ByteString;
-    encodeBytes(input: Uint8Array): Uint8Array;
-    decodeBytes(input: Uint8Array): Uint8Array;
+    _decode(input: Reader): ByteString;
 }
 export declare const byteStringCodec: ByteStringCodec;
+export declare const byteStringsCodec: ArrayCodec<Uint8Array>;

package/dist/src/codec/bytestring-codec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.byteStringCodec = exports.ByteStringCodec = void 0;
+exports.byteStringsCodec = exports.byteStringCodec = exports.ByteStringCodec = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,33 +18,19 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-const binary_parser_1 = require("binary-parser");
 const compact_int_codec_1 = require("./compact-int-codec");
+const codec_1 = require("./codec");
 const utils_1 = require("../utils");
-class ByteStringCodec {
-    constructor() {
-        this.parser = new binary_parser_1.Parser()
-            .nest('length', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .buffer('value', {
-            length: function (ctx) {
-                return compact_int_codec_1.compactSignedIntCodec.toI32(this['length']);
-            }
-        });
-    }
+const array_codec_1 = require("./array-codec");
+class ByteStringCodec extends codec_1.Codec {
     encode(input) {
-        return (0, utils_1.concatBytes)([compact_int_codec_1.compactSignedIntCodec.encode(input.length), input.value]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-    encodeBytes(input) {
-        return (0, utils_1.concatBytes)([compact_int_codec_1.compactSignedIntCodec.encodeI32(input.length), input]);
+        return (0, utils_1.concatBytes)([compact_int_codec_1.i32Codec.encode(input.length), input]);
     }
-    decodeBytes(input) {
-        return this.decode(input).value;
+    _decode(input) {
+        const length = compact_int_codec_1.i32Codec._decode(input);
+        return input.consumeBytes(length);
     }
 }
 exports.ByteStringCodec = ByteStringCodec;
 exports.byteStringCodec = new ByteStringCodec();
+exports.byteStringsCodec = new array_codec_1.ArrayCodec(exports.byteStringCodec);

package/dist/src/codec/codec.d.ts

@@ -1,8 +1,57 @@
-import { Parser } from 'binary-parser';
-export interface Codec<T> {
-    parser: Parser;
-    encode(input: T): Uint8Array;
+import { Reader } from './reader';
+export declare abstract class Codec<T> {
+    abstract encode(input: T): Uint8Array;
     decode(input: Uint8Array): T;
+    abstract _decode(input: Reader): T;
+    bimap<R>(from: (v: T) => R, to: (v: R) => T): Codec<R>;
 }
 export declare function assert(value: boolean, message: string): void;
-export declare function fixedSizeBytes(name: string, length: number): Parser;
+export declare class FixedSizeCodec extends Codec<Uint8Array> {
+    private readonly size;
+    constructor(size: number);
+    encode(input: Uint8Array): Uint8Array;
+    _decode(input: Reader): Uint8Array;
+}
+export declare class ObjectCodec<T> extends Codec<T> {
+    private codecs;
+    private keys;
+    constructor(codecs: {
+        [K in keyof T]: Codec<T[K]>;
+    });
+    encode(value: T): Uint8Array;
+    _decode(input: Reader): T;
+}
+type ExtractKind<T> = T extends {
+    kind: infer U extends string;
+} ? U : never;
+type ExtractValue<T, K> = T extends {
+    kind: K;
+    value: infer V;
+} ? V : never;
+export declare class EnumCodec<T extends {
+    kind: ExtractKind<T>;
+    value: ExtractValue<T, ExtractKind<T>>;
+}> extends Codec<T> {
+    private name;
+    private codecs;
+    private kinds;
+    constructor(name: string, codecs: {
+        [K in ExtractKind<T>]: Codec<ExtractValue<T, K>>;
+    });
+    encode(value: T): Uint8Array;
+    _decode(input: Reader): T;
+}
+export declare const byte32Codec: FixedSizeCodec;
+export declare const byteCodec: {
+    encode(input: number): Uint8Array;
+    _decode(input: Reader): number;
+    decode(input: Uint8Array): number;
+    bimap<R>(from: (v: number) => R, to: (v: R) => number): Codec<R>;
+};
+export declare const boolCodec: {
+    encode(input: boolean): Uint8Array;
+    _decode(input: Reader): boolean;
+    decode(input: Uint8Array): boolean;
+    bimap<R>(from: (v: boolean) => R, to: (v: R) => boolean): Codec<R>;
+};
+export {};

package/dist/src/codec/codec.js

@@ -1,6 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixedSizeBytes = exports.assert = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,23 +16,123 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-const binary_parser_1 = require("binary-parser");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolCodec = exports.byteCodec = exports.byte32Codec = exports.EnumCodec = exports.ObjectCodec = exports.FixedSizeCodec = exports.assert = exports.Codec = void 0;
+const utils_1 = require("../utils");
+const reader_1 = require("./reader");
+class Codec {
+    decode(input) {
+        const reader = new reader_1.Reader(input);
+        return this._decode(reader);
+    }
+    bimap(from, to) {
+        return new (class extends Codec {
+            constructor(codecT) {
+                super();
+                this.codecT = codecT;
+            }
+            encode(input) {
+                return this.codecT.encode(to(input));
+            }
+            _decode(input) {
+                return from(this.codecT._decode(input));
+            }
+        })(this);
+    }
+}
+exports.Codec = Codec;
 function assert(value, message) {
     if (!value) {
         throw new Error(message);
     }
 }
 exports.assert = assert;
-function fixedSizeBytes(name, length) {
-    return binary_parser_1.Parser.start().wrapped({
-        length,
-        type: binary_parser_1.Parser.start().buffer(name, { length }),
-        wrapper: function (result) {
-            if (result.length === length) {
-                return result;
-            }
-            throw new Error(`Too few bytes when parsing ${name}, expected ${length}, got ${result.length}`);
+class FixedSizeCodec extends Codec {
+    constructor(size) {
+        super();
+        this.size = size;
+    }
+    encode(input) {
+        assert(input.length === this.size, `Invalid length, expected ${this.size}, got ${input.length}`);
+        return input;
+    }
+    _decode(input) {
+        return input.consumeBytes(this.size);
+    }
+}
+exports.FixedSizeCodec = FixedSizeCodec;
+class ObjectCodec extends Codec {
+    constructor(codecs) {
+        super();
+        this.codecs = codecs;
+        this.keys = Object.keys(codecs);
+    }
+    encode(value) {
+        const bytes = [];
+        for (const key of this.keys) {
+            bytes.push(this.codecs[key].encode(value[key]));
+        }
+        return (0, utils_1.concatBytes)(bytes);
+    }
+    _decode(input) {
+        const result = {};
+        for (const key of this.keys) {
+            result[key] = this.codecs[key]._decode(input);
+        }
+        return result;
+    }
+}
+exports.ObjectCodec = ObjectCodec;
+class EnumCodec extends Codec {
+    constructor(name, codecs) {
+        super();
+        this.name = name;
+        this.codecs = codecs;
+        this.kinds = Object.keys(codecs);
+    }
+    encode(value) {
+        const index = this.kinds.findIndex((t) => t === value.kind);
+        if (index === -1) {
+            throw new Error(`Invalid ${this.name} kind ${value.kind}, expected one of ${this.kinds}`);
+        }
+        const codec = this.codecs[value.kind];
+        return new Uint8Array([index, ...codec.encode(value.value)]);
+    }
+    _decode(input) {
+        const index = input.consumeByte();
+        if (index >= 0 && index < this.kinds.length) {
+            const kind = this.kinds[`${index}`];
+            const codec = this.codecs[kind];
+            return { kind, value: codec._decode(input) };
         }
-    });
+        throw new Error(`Invalid encoded ${this.name} kind: ${index}`);
+    }
 }
-exports.fixedSizeBytes = fixedSizeBytes;
+exports.EnumCodec = EnumCodec;
+exports.byte32Codec = new FixedSizeCodec(32);
+exports.byteCodec = new (class extends Codec {
+    encode(input) {
+        assert(input >= 0 && input < 256, `Invalid byte: ${input}`);
+        return new Uint8Array([input]);
+    }
+    _decode(input) {
+        return input.consumeByte();
+    }
+})();
+exports.boolCodec = new (class extends Codec {
+    encode(input) {
+        return new Uint8Array([input ? 1 : 0]);
+    }
+    _decode(input) {
+        const byte = input.consumeByte();
+        if (byte === 1) {
+            return true;
+        }
+        else if (byte === 0) {
+            return false;
+        }
+        else {
+            throw new Error(`Invalid encoded bool value ${byte}, expected 0 or 1`);
+        }
+    }
+})();