@alephium/web3 0.37.0 → 0.38.1

package/dist/src/codec/compact-int-codec.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactSignedIntCodec = exports.CompactSignedIntCodec = exports.compactUnsignedIntCodec = exports.CompactUnsignedIntCodec = exports.CompactInt = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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 buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const codec_1 = require("./codec");
+const bigint_codec_1 = require("./bigint-codec");
+class CompactInt {
+}
+exports.CompactInt = CompactInt;
+CompactInt.oneBytePrefix = 0x00;
+CompactInt.oneByteNegPrefix = 0xc0;
+CompactInt.twoBytePrefix = 0x40;
+CompactInt.twoByteNegPrefix = 0x80;
+CompactInt.fourBytePrefix = 0x80;
+CompactInt.fourByteNegPrefix = 0x40;
+CompactInt.multiBytePrefix = 0xc0;
+const maskRest = 0xc0;
+const maskMode = 0x3f;
+const maskModeNeg = 0xffffffc0;
+const signFlag = 0x20; // 0b00100000
+const compactIntParser = new binary_parser_1.Parser().uint8('mode').buffer('rest', {
+    length: function (ctx) {
+        const rawMode = this['mode'];
+        const mode = rawMode & maskRest;
+        switch (mode) {
+            case CompactInt.oneBytePrefix:
+                return 0;
+            case CompactInt.twoBytePrefix:
+                return 1;
+            case CompactInt.fourBytePrefix:
+                return 3;
+            default:
+                return (rawMode & maskMode) + 4;
+        }
+    }
+});
+class CompactUnsignedIntCodec {
+    constructor() {
+        this.oneByteBound = 0x40;
+        this.twoByteBound = this.oneByteBound << 8;
+        this.fourByteBound = this.oneByteBound << (8 * 3);
+        this.parser = compactIntParser;
+    }
+    encode(input) {
+        return buffer_1.Buffer.from([input.mode, ...input.rest]);
+    }
+    encodeU32(value) {
+        if (value < this.oneByteBound) {
+            return buffer_1.Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff]);
+        }
+        else if (value < this.twoByteBound) {
+            return buffer_1.Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
+        }
+        else if (value < this.fourByteBound) {
+            return buffer_1.Buffer.from([
+                (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
+                (value >> 16) & 0xff,
+                (value >> 8) & 0xff,
+                value & 0xff
+            ]);
+        }
+        else {
+            return buffer_1.Buffer.from([
+                CompactInt.multiBytePrefix,
+                (value >> 24) & 0xff,
+                (value >> 16) & 0xff,
+                (value >> 8) & 0xff,
+                value & 0xff
+            ]);
+        }
+    }
+    encodeU256(value) {
+        (0, codec_1.assert)(value >= 0n, 'Value should be positive');
+        if (value < this.fourByteBound) {
+            return this.encodeU32(Number(value));
+        }
+        else {
+            let bytes = bigint_codec_1.BigIntCodec.encode(value);
+            if (bytes[0] === 0) {
+                bytes = bytes.slice(1);
+            }
+            (0, codec_1.assert)(bytes.length <= 32, 'Expect <= 32 bytes for U256');
+            const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff;
+            return buffer_1.Buffer.concat([buffer_1.Buffer.from([header]), bytes]);
+        }
+    }
+    decodeU32(input) {
+        const decoded = this.decode(input);
+        return this.toU32(decoded);
+    }
+    decodeU256(input) {
+        const decoded = this.decode(input);
+        return this.toU256(decoded);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    toU32(value) {
+        const body = buffer_1.Buffer.from([value.mode, ...value.rest]);
+        return decodePositiveInt(value.mode, body);
+    }
+    fromU32(value) {
+        return this.decode(this.encodeU32(value));
+    }
+    toU256(value) {
+        const mode = value.mode & maskRest;
+        if (fixedSize(mode)) {
+            return BigInt(this.toU32(value));
+        }
+        else {
+            (0, codec_1.assert)(value.rest.length <= 32, 'Expect <= 32 bytes for U256');
+            return bigint_codec_1.BigIntCodec.decode(buffer_1.Buffer.from(value.rest), false);
+        }
+    }
+    fromU256(value) {
+        return this.decode(this.encodeU256(value));
+    }
+}
+exports.CompactUnsignedIntCodec = CompactUnsignedIntCodec;
+exports.compactUnsignedIntCodec = new CompactUnsignedIntCodec();
+class CompactSignedIntCodec {
+    constructor() {
+        this.signFlag = 0x20; // 0b00100000
+        this.oneByteBound = 0x20; // 0b00100000
+        this.twoByteBound = this.oneByteBound << 8;
+        this.fourByteBound = this.oneByteBound << (8 * 3);
+        this.parser = compactIntParser;
+    }
+    encode(input) {
+        return buffer_1.Buffer.from([input.mode, ...input.rest]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    decodeI32(input) {
+        const decoded = this.decode(input);
+        return this.toI32(decoded);
+    }
+    encodeI32(value) {
+        if (value >= 0) {
+            if (value < this.oneByteBound) {
+                return buffer_1.Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff]);
+            }
+            else if (value < this.twoByteBound) {
+                return buffer_1.Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
+            }
+            else if (value < this.fourByteBound) {
+                return buffer_1.Buffer.from([
+                    (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
+                    (value >> 16) & 0xff,
+                    (value >> 8) & 0xff,
+                    value & 0xff
+                ]);
+            }
+            else {
+                return buffer_1.Buffer.from([
+                    CompactInt.multiBytePrefix,
+                    (value >> 24) & 0xff,
+                    (value >> 16) & 0xff,
+                    (value >> 8) & 0xff,
+                    value & 0xff
+                ]);
+            }
+        }
+        else {
+            if (value >= -this.oneByteBound) {
+                return buffer_1.Buffer.from([(value ^ CompactInt.oneByteNegPrefix) & 0xff]);
+            }
+            else if (value >= -this.twoByteBound) {
+                return buffer_1.Buffer.from([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff]);
+            }
+            else if (value >= -this.fourByteBound) {
+                return buffer_1.Buffer.from([
+                    ((value >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
+                    (value >> 16) & 0xff,
+                    (value >> 8) & 0xff,
+                    value & 0xff
+                ]);
+            }
+            else {
+                return buffer_1.Buffer.from([
+                    CompactInt.multiBytePrefix,
+                    (value >> 24) & 0xff,
+                    (value >> 16) & 0xff,
+                    (value >> 8) & 0xff,
+                    value & 0xff
+                ]);
+            }
+        }
+    }
+    encodeI256(value) {
+        if (value >= -0x20000000 && value < 0x20000000) {
+            return this.encodeI32(Number(value));
+        }
+        else {
+            const bytes = bigint_codec_1.BigIntCodec.encode(value);
+            const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff;
+            return buffer_1.Buffer.concat([buffer_1.Buffer.from([header]), bytes]);
+        }
+    }
+    decodeI256(input) {
+        const decoded = this.decode(input);
+        return this.toI256(decoded);
+    }
+    toI32(value) {
+        const body = buffer_1.Buffer.from([value.mode, ...value.rest]);
+        const mode = value.mode & maskRest;
+        if (fixedSize(mode)) {
+            const isPositive = (value.mode & signFlag) == 0;
+            if (isPositive) {
+                return decodePositiveInt(value.mode, body);
+            }
+            else {
+                return decodeNegativeInt(value.mode, body);
+            }
+        }
+        else {
+            if (body.length === 5) {
+                return ((body[1] & 0xff) << 24) | ((body[2] & 0xff) << 16) | ((body[3] & 0xff) << 8) | (body[4] & 0xff);
+            }
+            else {
+                throw new Error(`Expect 4 bytes int, but get ${body.length - 1} bytes int`);
+            }
+        }
+    }
+    fromI32(value) {
+        return this.decode(this.encodeI32(value));
+    }
+    toI256(value) {
+        const mode = value.mode & maskRest;
+        if (fixedSize(mode)) {
+            return BigInt(this.toI32(value));
+        }
+        else {
+            (0, codec_1.assert)(value.rest.length <= 32, 'Expect <= 32 bytes for I256');
+            return bigint_codec_1.BigIntCodec.decode(buffer_1.Buffer.from(value.rest), true);
+        }
+    }
+    fromI256(value) {
+        return this.decode(this.encodeI256(value));
+    }
+}
+exports.CompactSignedIntCodec = CompactSignedIntCodec;
+exports.compactSignedIntCodec = new CompactSignedIntCodec();
+function decodePositiveInt(rawMode, body) {
+    const mode = rawMode & maskRest;
+    switch (mode) {
+        case CompactInt.oneBytePrefix:
+            return rawMode;
+        case CompactInt.twoBytePrefix:
+            (0, codec_1.assert)(body.length === 2, 'Length should be 2');
+            return ((body[0] & maskMode) << 8) | (body[1] & 0xff);
+        case CompactInt.fourBytePrefix:
+            (0, codec_1.assert)(body.length === 4, 'Length should be 4');
+            return ((body[0] & maskMode) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff);
+        default:
+            if (body.length === 5) {
+                return Number(BigInt('0x' + body.slice(1).toString('hex')));
+            }
+            else {
+                throw new Error(`decodePositiveInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`);
+            }
+    }
+}
+function decodeNegativeInt(rawMode, body) {
+    const mode = rawMode & maskRest;
+    switch (mode) {
+        case CompactInt.oneBytePrefix:
+            return rawMode | maskModeNeg;
+        case CompactInt.twoBytePrefix:
+            (0, codec_1.assert)(body.length === 2, 'Length should be 2');
+            return ((body[0] | maskModeNeg) << 8) | (body[1] & 0xff);
+        case CompactInt.fourBytePrefix:
+            (0, codec_1.assert)(body.length === 4, 'Length should be 4');
+            return ((body[0] | maskModeNeg) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff);
+        default:
+            throw new Error(`decodeNegativeInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`);
+    }
+}
+function fixedSize(mode) {
+    return mode === CompactInt.oneBytePrefix || mode === CompactInt.twoBytePrefix || mode === CompactInt.fourBytePrefix;
+}

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

@@ -0,0 +1,23 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { DecodedArray } from './array-codec';
+import { Codec } from './codec';
+import { DecodedCompactInt } from './compact-int-codec';
+import { Method } from './method-codec';
+export interface HalfDecodedContract {
+    fieldLength: DecodedCompactInt;
+    methodIndexes: DecodedArray<DecodedCompactInt>;
+    methods: Buffer;
+}
+export interface Contract {
+    fieldLength: number;
+    methods: Method[];
+}
+export declare function toHalfDecoded(contract: Contract): HalfDecodedContract;
+export declare class ContractCodec implements Codec<HalfDecodedContract> {
+    parser: Parser;
+    encode(input: HalfDecodedContract): Buffer;
+    decode(input: Buffer): HalfDecodedContract;
+    decodeContract(input: Buffer): Contract;
+}
+export declare const contractCodec: ContractCodec;

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

@@ -0,0 +1,81 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractCodec = exports.ContractCodec = exports.toHalfDecoded = void 0;
+const buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const array_codec_1 = require("./array-codec");
+const compact_int_codec_1 = require("./compact-int-codec");
+const method_codec_1 = require("./method-codec");
+const compactSignedIntsCodec = new array_codec_1.ArrayCodec(compact_int_codec_1.compactSignedIntCodec);
+function toHalfDecoded(contract) {
+    const fieldLength = compact_int_codec_1.compactSignedIntCodec.fromI32(contract.fieldLength);
+    const methods = contract.methods.map((m) => method_codec_1.methodCodec.encode(method_codec_1.MethodCodec.fromMethod(m)));
+    let count = 0;
+    const methodIndexes = Array.from(Array(methods.length).keys()).map((index) => {
+        count += methods[`${index}`].length;
+        return count;
+    });
+    return {
+        fieldLength,
+        methodIndexes: {
+            length: compact_int_codec_1.compactSignedIntCodec.fromI32(methodIndexes.length),
+            value: methodIndexes.map((value) => compact_int_codec_1.compactSignedIntCodec.fromI32(value))
+        },
+        methods: methods.reduce((acc, buffer) => buffer_1.Buffer.concat([acc, buffer]))
+    };
+}
+exports.toHalfDecoded = toHalfDecoded;
+class ContractCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .nest('fieldLength', {
+            type: compact_int_codec_1.compactSignedIntCodec.parser
+        })
+            .nest('methodIndexes', {
+            type: compactSignedIntsCodec.parser
+        })
+            .buffer('methods', { readUntil: 'eof' });
+    }
+    encode(input) {
+        return buffer_1.Buffer.from([
+            ...compact_int_codec_1.compactSignedIntCodec.encode(input.fieldLength),
+            ...compactSignedIntsCodec.encode(input.methodIndexes.value),
+            ...input.methods
+        ]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    decodeContract(input) {
+        const halfDecoded = this.decode(input);
+        const fieldLength = compact_int_codec_1.compactUnsignedIntCodec.toU32(halfDecoded.fieldLength);
+        const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compact_int_codec_1.compactUnsignedIntCodec.toU32(v));
+        const methods = [];
+        for (let i = 0, start = 0; i < methodIndexes.length; i++) {
+            const end = methodIndexes[i];
+            const method = method_codec_1.MethodCodec.toMethod(method_codec_1.methodCodec.decode(halfDecoded.methods.slice(start, end)));
+            methods.push(method);
+            start = end;
+        }
+        return { fieldLength, methods };
+    }
+}
+exports.ContractCodec = ContractCodec;
+exports.contractCodec = new ContractCodec();

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

@@ -0,0 +1,21 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { DecodedArray } from './array-codec';
+import { DecodedCompactInt } from './compact-int-codec';
+import { P2C } from './lockup-script-codec';
+import { Codec } from './codec';
+import { Token } from './token-codec';
+import { ContractOutput as ApiContractOutput } from '../api/api-alephium';
+export interface ContractOutput {
+    amount: DecodedCompactInt;
+    lockupScript: P2C;
+    tokens: DecodedArray<Token>;
+}
+export declare class ContractOutputCodec implements Codec<ContractOutput> {
+    parser: Parser;
+    encode(input: ContractOutput): Buffer;
+    decode(input: Buffer): ContractOutput;
+    static convertToApiContractOutput(txIdBytes: Uint8Array, output: ContractOutput, index: number): ApiContractOutput;
+    static convertToOutput(apiContractOutput: ApiContractOutput): ContractOutput;
+}
+export declare const contractOutputCodec: ContractOutputCodec;

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractOutputCodec = exports.ContractOutputCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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 buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const compact_int_codec_1 = require("./compact-int-codec");
+const token_codec_1 = require("./token-codec");
+const hash_1 = require("./hash");
+const __1 = require("..");
+const signed_int_codec_1 = require("./signed-int-codec");
+const lockup_script_codec_1 = require("./lockup-script-codec");
+class ContractOutputCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .nest('amount', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .nest('lockupScript', {
+            type: binary_parser_1.Parser.start().buffer('contractId', { length: 32 })
+        })
+            .nest('tokens', {
+            type: token_codec_1.tokensCodec.parser
+        });
+    }
+    encode(input) {
+        const amount = buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount));
+        const lockupScript = input.lockupScript.contractId;
+        const tokens = buffer_1.Buffer.from(token_codec_1.tokensCodec.encode(input.tokens.value));
+        return buffer_1.Buffer.concat([amount, lockupScript, tokens]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    static convertToApiContractOutput(txIdBytes, output, index) {
+        const hint = (0, hash_1.createHint)(output.lockupScript.contractId);
+        const key = (0, __1.binToHex)((0, hash_1.blakeHash)(buffer_1.Buffer.concat([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
+        const attoAlphAmount = compact_int_codec_1.compactUnsignedIntCodec.toU256(output.amount).toString();
+        const address = __1.bs58.encode(buffer_1.Buffer.concat([buffer_1.Buffer.from([0x03]), output.lockupScript.contractId]));
+        const tokens = output.tokens.value.map((token) => {
+            return {
+                id: token.tokenId.toString('hex'),
+                amount: compact_int_codec_1.compactUnsignedIntCodec.toU256(token.amount).toString()
+            };
+        });
+        return { hint, key, attoAlphAmount, address, tokens, type: 'ContractOutput' };
+    }
+    static convertToOutput(apiContractOutput) {
+        const amount = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(apiContractOutput.attoAlphAmount));
+        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(buffer_1.Buffer.from(__1.bs58.decode(apiContractOutput.address)))
+            .script;
+        const tokensValue = apiContractOutput.tokens.map((token) => {
+            return {
+                tokenId: buffer_1.Buffer.from(token.id, 'hex'),
+                amount: compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(token.amount))
+            };
+        });
+        const tokens = {
+            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(tokensValue.length),
+            value: tokensValue
+        };
+        return { amount, lockupScript, tokens };
+    }
+}
+exports.ContractOutputCodec = ContractOutputCodec;
+exports.contractOutputCodec = new ContractOutputCodec();

package/dist/src/codec/contract-output-ref-codec.d.ts

@@ -0,0 +1,15 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { ArrayCodec } from './array-codec';
+import { Codec } from './codec';
+export interface ContractOutputRef {
+    hint: number;
+    key: Buffer;
+}
+export declare class ContractOutputRefCodec implements Codec<ContractOutputRef> {
+    parser: Parser;
+    encode(input: ContractOutputRef): Buffer;
+    decode(input: Buffer): ContractOutputRef;
+}
+export declare const contractOutputRefCodec: ContractOutputRefCodec;
+export declare const contractOutputRefsCodec: ArrayCodec<ContractOutputRef>;

package/dist/src/codec/contract-output-ref-codec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractOutputRefsCodec = exports.contractOutputRefCodec = exports.ContractOutputRefCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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 buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const array_codec_1 = require("./array-codec");
+const signed_int_codec_1 = require("./signed-int-codec");
+class ContractOutputRefCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start().int32('hint').buffer('key', { length: 32 });
+    }
+    encode(input) {
+        return buffer_1.Buffer.concat([buffer_1.Buffer.from([...signed_int_codec_1.signedIntCodec.encode(input.hint), ...input.key])]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+exports.ContractOutputRefCodec = ContractOutputRefCodec;
+exports.contractOutputRefCodec = new ContractOutputRefCodec();
+exports.contractOutputRefsCodec = new array_codec_1.ArrayCodec(exports.contractOutputRefCodec);

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

@@ -0,0 +1,17 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { Codec } from './codec';
+export interface Either<L, R> {
+    either: number;
+    value: L | R;
+}
+export declare class EitherCodec<L, R> implements Codec<Either<L, R>> {
+    private leftCodec;
+    private rightCodec;
+    parser: Parser;
+    constructor(leftCodec: Codec<L>, rightCodec: Codec<R>, parser?: Parser);
+    encode(input: Either<L, R>): Buffer;
+    decode(input: Buffer): Either<L, R>;
+    fromLeft(left: L): Either<L, R>;
+    fromRight(right: R): Either<L, R>;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EitherCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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 buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+class EitherCodec {
+    constructor(leftCodec, rightCodec, parser = binary_parser_1.Parser.start()
+        .uint8('either')
+        .choice('value', {
+        tag: 'either',
+        choices: {
+            0: leftCodec.parser,
+            1: rightCodec.parser
+        }
+    })) {
+        this.leftCodec = leftCodec;
+        this.rightCodec = rightCodec;
+        this.parser = parser;
+    }
+    encode(input) {
+        const result = [input.either];
+        if (input.either === 0) {
+            result.push(...this.leftCodec.encode(input.value));
+        }
+        else {
+            result.push(...this.rightCodec.encode(input.value));
+        }
+        return buffer_1.Buffer.from(result);
+    }
+    decode(input) {
+        const result = this.parser.parse(input);
+        return {
+            ...result,
+            value: result.either === 0 ? this.leftCodec.decode(result.value.value) : this.rightCodec.decode(result.value.value)
+        };
+    }
+    fromLeft(left) {
+        return {
+            either: 0,
+            value: left
+        };
+    }
+    fromRight(right) {
+        return {
+            either: 1,
+            value: right
+        };
+    }
+}
+exports.EitherCodec = EitherCodec;

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

@@ -0,0 +1,4 @@
+import { Buffer } from 'buffer/';
+export declare function blakeHash(raw: Uint8Array): Uint8Array;
+export declare function djbIntHash(bytes: Buffer): number;
+export declare function createHint(input: Buffer): number;

package/dist/src/codec/hash.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHint = exports.djbIntHash = exports.blakeHash = void 0;
+const blakejs_1 = __importDefault(require("blakejs"));
+function blakeHash(raw) {
+    return blakejs_1.default.blake2b(raw, undefined, 32);
+}
+exports.blakeHash = blakeHash;
+function djbIntHash(bytes) {
+    let hash = 5381;
+    bytes.forEach((byte) => {
+        hash = (hash << 5) + hash + (byte & 0xff);
+    });
+    return hash;
+}
+exports.djbIntHash = djbIntHash;
+function createHint(input) {
+    return djbIntHash(input) | 1;
+}
+exports.createHint = createHint;