@alephium/web3 0.30.0-beta.1 → 0.30.1

package/dist/src/codec/unlock-script-codec.js

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unlockScriptCodec = exports.UnlockScriptCodec = exports.P2SHCodec = 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 binary_parser_1 = require("binary-parser");
-const array_codec_1 = require("./array-codec");
-const compact_int_codec_1 = require("./compact-int-codec");
-const script_codec_1 = require("./script-codec");
-const bytestring_codec_1 = require("./bytestring-codec");
-const lockup_script_codec_1 = require("./lockup-script-codec");
-class P2PKHCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start().buffer('publicKey', { length: 33 });
-    }
-    encode(input) {
-        return input.publicKey;
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-const p2pkhCodec = new P2PKHCodec();
-class P2MPKHCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start().nest('publicKeys', {
-            type: array_codec_1.ArrayCodec.arrayParser(binary_parser_1.Parser.start()
-                .nest('publicKey', { type: p2pkhCodec.parser })
-                .nest('index', { type: compact_int_codec_1.compactUnsignedIntCodec.parser }))
-        });
-    }
-    encode(input) {
-        return Buffer.concat([
-            Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length)),
-            ...input.publicKeys.value.map((v) => {
-                return Buffer.concat([v.publicKey.publicKey, Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(v.index))]);
-            })
-        ]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-const p2mpkhCodec = new P2MPKHCodec();
-class ValCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .int8('type')
-            .choice('val', {
-            tag: 'type',
-            choices: {
-                0x00: new binary_parser_1.Parser().uint8('value'),
-                0x01: compact_int_codec_1.compactSignedIntCodec.parser,
-                0x02: compact_int_codec_1.compactUnsignedIntCodec.parser,
-                0x03: bytestring_codec_1.byteStringCodec.parser,
-                0x04: lockup_script_codec_1.lockupScriptCodec.parser // Address
-            }
-        });
-    }
-    encode(input) {
-        const valType = input.type;
-        if (valType === 0x00) {
-            // Boolean
-            return Buffer.from([valType, input.val]);
-        }
-        else if (valType === 0x01) {
-            // I256
-            return Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
-        }
-        else if (valType === 0x02) {
-            // U256
-            return Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
-        }
-        else if (valType === 0x03) {
-            // ByteVec
-            return Buffer.from([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
-        }
-        else if (valType === 0x04) {
-            // Address
-            return Buffer.from([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
-        }
-        else {
-            throw new Error(`ValCodec: unsupported val type: ${valType}`);
-        }
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-const valCodec = new ValCodec();
-const valsCodec = new array_codec_1.ArrayCodec(valCodec);
-class P2SHCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .nest('script', {
-            type: script_codec_1.scriptCodec.parser
-        })
-            .nest('params', {
-            type: valsCodec.parser
-        });
-    }
-    encode(input) {
-        return Buffer.concat([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.P2SHCodec = P2SHCodec;
-const p2shCodec = new P2SHCodec();
-class UnlockScriptCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .uint8('scriptType')
-            .choice('script', {
-            tag: 'scriptType',
-            choices: {
-                0: p2pkhCodec.parser,
-                1: p2mpkhCodec.parser,
-                2: p2shCodec.parser,
-                3: binary_parser_1.Parser.start() // TODO: SameAsPrevious, FIXME
-            }
-        });
-    }
-    encode(input) {
-        const scriptType = input.scriptType;
-        const inputUnLockScript = input.script;
-        const inputUnLockScriptType = Buffer.from([scriptType]);
-        if (scriptType === 0) {
-            // P2PKH
-            return Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript)]);
-        }
-        else if (scriptType === 1) {
-            // P2MPKH
-            return Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript)]);
-        }
-        else if (scriptType === 2) {
-            // P2SH
-            return Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script)]);
-        }
-        else if (scriptType === 3) {
-            // SameAsPrevious
-            return inputUnLockScriptType;
-        }
-        else {
-            throw new Error(`TODO: encode unlock script: ${scriptType}`);
-        }
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.UnlockScriptCodec = UnlockScriptCodec;
-exports.unlockScriptCodec = new UnlockScriptCodec();

package/dist/src/codec/unsigned-tx-codec.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="node" />
-import { Parser } from 'binary-parser';
-import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium';
-import { Script } from './script-codec';
-import { Option } from './option-codec';
-import { DecodedCompactInt } from './compact-int-codec';
-import { Input } from './input-codec';
-import { AssetOutput } from './asset-output-codec';
-import { DecodedArray } from './array-codec';
-import { Codec } from './codec';
-export interface UnsignedTx {
-    version: number;
-    networkId: number;
-    statefulScript: Option<Script>;
-    gasAmount: DecodedCompactInt;
-    gasPrice: DecodedCompactInt;
-    inputs: DecodedArray<Input>;
-    fixedOutputs: DecodedArray<AssetOutput>;
-}
-export declare class UnsignedTxCodec implements Codec<UnsignedTx> {
-    parser: Parser;
-    encode(decodedUnsignedTx: UnsignedTx): Buffer;
-    decode(input: Buffer): UnsignedTx;
-    encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer;
-    decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx;
-    static txId(unsignedTx: UnsignedTx): string;
-    static toApiUnsignedTx(unsigned: UnsignedTx): ApiUnsignedTx;
-    static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx;
-}
-export declare const unsignedTxCodec: UnsignedTxCodec;

package/dist/src/codec/unsigned-tx-codec.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unsignedTxCodec = exports.UnsignedTxCodec = 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 binary_parser_1 = require("binary-parser");
-const utils_1 = require("../utils");
-const script_codec_1 = require("./script-codec");
-const compact_int_codec_1 = require("./compact-int-codec");
-const input_codec_1 = require("./input-codec");
-const asset_output_codec_1 = require("./asset-output-codec");
-const hash_1 = require("./hash");
-class UnsignedTxCodec {
-    constructor() {
-        this.parser = new binary_parser_1.Parser()
-            .uint8('version')
-            .uint8('networkId')
-            .nest('statefulScript', {
-            type: script_codec_1.statefulScriptCodecOpt.parser
-        })
-            .nest('gasAmount', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .nest('gasPrice', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
-        })
-            .nest('inputs', {
-            type: input_codec_1.inputsCodec.parser
-        })
-            .nest('fixedOutputs', {
-            type: asset_output_codec_1.assetOutputsCodec.parser
-        });
-    }
-    encode(decodedUnsignedTx) {
-        return Buffer.concat([
-            Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
-            script_codec_1.statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
-            compact_int_codec_1.compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
-            compact_int_codec_1.compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
-            input_codec_1.inputsCodec.encode(decodedUnsignedTx.inputs.value),
-            asset_output_codec_1.assetOutputsCodec.encode(decodedUnsignedTx.fixedOutputs.value)
-        ]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-    encodeApiUnsignedTx(input) {
-        const decoded = UnsignedTxCodec.fromApiUnsignedTx(input);
-        return this.encode(decoded);
-    }
-    decodeApiUnsignedTx(input) {
-        const decoded = this.parser.parse(input);
-        return UnsignedTxCodec.toApiUnsignedTx(decoded);
-    }
-    static txId(unsignedTx) {
-        return (0, utils_1.binToHex)((0, hash_1.blakeHash)(exports.unsignedTxCodec.encode(unsignedTx)));
-    }
-    static toApiUnsignedTx(unsigned) {
-        const txId = UnsignedTxCodec.txId(unsigned);
-        const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
-        const version = unsigned.version;
-        const networkId = unsigned.networkId;
-        const gasAmount = compact_int_codec_1.compactSignedIntCodec.toI32(unsigned.gasAmount);
-        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.toU256(unsigned.gasPrice).toString();
-        const inputs = input_codec_1.InputCodec.toAssetInputs(unsigned.inputs.value);
-        const fixedOutputs = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value);
-        let scriptOpt = undefined;
-        if (unsigned.statefulScript.option === 1) {
-            scriptOpt = script_codec_1.scriptCodec.encode(unsigned.statefulScript.value).toString('hex');
-        }
-        return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs };
-    }
-    static fromApiUnsignedTx(unsignedTx) {
-        const version = unsignedTx.version;
-        const networkId = unsignedTx.networkId;
-        const gasAmount = compact_int_codec_1.compactSignedIntCodec.decode(compact_int_codec_1.compactSignedIntCodec.encodeI32(unsignedTx.gasAmount));
-        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.decode(compact_int_codec_1.compactUnsignedIntCodec.encodeU256(BigInt(unsignedTx.gasPrice)));
-        const inputsValue = input_codec_1.InputCodec.fromAssetInputs(unsignedTx.inputs);
-        const inputs = input_codec_1.inputsCodec.fromArray(inputsValue);
-        const fixedOutputsValue = asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs);
-        const fixedOutputs = asset_output_codec_1.assetOutputsCodec.fromArray(fixedOutputsValue);
-        const statefulScript = script_codec_1.statefulScriptCodecOpt.fromBuffer(unsignedTx.scriptOpt ? Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined);
-        return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript };
-    }
-}
-exports.UnsignedTxCodec = UnsignedTxCodec;
-exports.unsignedTxCodec = new UnsignedTxCodec();

package/src/codec/array-codec.ts

@@ -1,62 +0,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/>.
-*/
-import { Parser } from 'binary-parser'
-import { compactSignedIntCodec, compactUnsignedIntCodec, DecodedCompactInt } from './compact-int-codec'
-import { Codec } from './codec'
-
-export interface DecodedArray<T> {
-  length: DecodedCompactInt
-  value: T[]
-}
-
-export class ArrayCodec<T> implements Codec<T[]> {
-  constructor(private childCodec: Codec<T>, public parser = ArrayCodec.arrayParser(childCodec.parser)) {}
-
-  encode(input: T[]): Buffer {
-    const result = [...compactSignedIntCodec.encodeI256(BigInt(input.length))]
-    for (const element of input) {
-      result.push(...this.childCodec.encode(element))
-    }
-    return Buffer.from(result)
-  }
-
-  decode(input: Buffer): T[] {
-    const result = this.parser.parse(input)
-    return result.value.map((v) => this.childCodec.decode(v.value))
-  }
-
-  static arrayParser(parser: Parser) {
-    return new Parser()
-      .nest('length', {
-        type: compactSignedIntCodec.parser
-      })
-      .array('value', {
-        length: function (ctx) {
-          return compactSignedIntCodec.toI32(this['length']! as any as DecodedCompactInt)
-        },
-        type: parser
-      })
-  }
-
-  fromArray(inputs: T[]): DecodedArray<T> {
-    return {
-      length: compactUnsignedIntCodec.decode(compactUnsignedIntCodec.encodeU32(inputs.length)),
-      value: inputs
-    }
-  }
-}

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

@@ -1,150 +0,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/>.
-*/
-import { Parser } from 'binary-parser'
-import { ArrayCodec, DecodedArray } from './array-codec'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
-import { signedIntCodec } from './signed-int-codec'
-import { longCodec } from './long-codec'
-import { ByteString, byteStringCodec } from './bytestring-codec'
-import { LockupScript, MultiSig, P2C, P2SH, lockupScriptCodec } from './lockup-script-codec'
-import { FixedAssetOutput } from '../api/api-alephium'
-import { blakeHash, createHint } from './hash'
-import { bs58, binToHex } from '../utils'
-import { Codec } from './codec'
-import { PublicKeyHash } from './lockup-script-codec'
-import { Token, tokensCodec } from './token-codec'
-
-export interface AssetOutput {
-  amount: DecodedCompactInt
-  lockupScript: LockupScript
-  lockTime: Buffer
-  tokens: DecodedArray<Token>
-  additionalData: ByteString
-}
-
-export class AssetOutputCodec implements Codec<AssetOutput> {
-  parser = Parser.start()
-    .nest('amount', {
-      type: compactUnsignedIntCodec.parser
-    })
-    .nest('lockupScript', {
-      type: lockupScriptCodec.parser
-    })
-    .buffer('lockTime', {
-      length: 8
-    })
-    .nest('tokens', {
-      type: tokensCodec.parser
-    })
-    .nest('additionalData', {
-      type: byteStringCodec.parser
-    })
-
-  encode(input: AssetOutput): Buffer {
-    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
-    const lockupScript = lockupScriptCodec.encode(input.lockupScript)
-    const lockTime = Buffer.from(input.lockTime)
-    const tokens = Buffer.from(tokensCodec.encode(input.tokens.value))
-    const additionalData = Buffer.from(byteStringCodec.encode(input.additionalData))
-
-    return Buffer.concat([amount, lockupScript, lockTime, tokens, additionalData])
-  }
-
-  decode(input: Buffer): AssetOutput {
-    return this.parser.parse(input)
-  }
-
-  static toFixedAssetOutputs(txIdBytes: Uint8Array, outputs: AssetOutput[]): FixedAssetOutput[] {
-    return outputs.map((output, index) => AssetOutputCodec.toFixedAssetOutput(txIdBytes, output, index))
-  }
-
-  static toFixedAssetOutput(txIdBytes: Uint8Array, output: AssetOutput, index: number): FixedAssetOutput {
-    const attoAlphAmount = compactUnsignedIntCodec.toU256(output.amount).toString()
-    const lockTime = Number(longCodec.decode(output.lockTime))
-    const tokens = output.tokens.value.map((token) => {
-      return {
-        id: token.tokenId.toString('hex'),
-        amount: compactUnsignedIntCodec.toU256(token.amount).toString()
-      }
-    })
-    const message = output.additionalData.value.toString('hex')
-    const scriptType = output.lockupScript.scriptType
-    const key = binToHex(blakeHash(Buffer.concat([txIdBytes, signedIntCodec.encode(index)])))
-    const outputLockupScript = output.lockupScript.script
-    const address = bs58.encode(lockupScriptCodec.encode(output.lockupScript))
-
-    let hint: number | undefined = undefined
-    if (scriptType === 0) {
-      // P2PKH
-      hint = createHint((outputLockupScript as PublicKeyHash).publicKeyHash)
-    } else if (scriptType === 1) {
-      // P2MPKH
-      hint = createHint((outputLockupScript as MultiSig).publicKeyHashes.value[0].publicKeyHash)
-    } else if (scriptType === 2) {
-      // P2SH
-      hint = createHint((outputLockupScript as P2SH).scriptHash)
-    } else if (scriptType === 3) {
-      // P2C
-      hint = createHint((outputLockupScript as P2C).contractId)
-    } else {
-      throw new Error(`TODO: decode output script type: ${scriptType}`)
-    }
-
-    return { hint, key, attoAlphAmount, lockTime, tokens, address, message }
-  }
-
-  static fromFixedAssetOutputs(fixedOutputs: FixedAssetOutput[]): AssetOutput[] {
-    return fixedOutputs.map((output) => {
-      return AssetOutputCodec.fromFixedAssetOutput(output)
-    })
-  }
-
-  static fromFixedAssetOutput(fixedOutput: FixedAssetOutput): AssetOutput {
-    const amount: DecodedCompactInt = compactUnsignedIntCodec.decode(
-      compactUnsignedIntCodec.encodeU256(BigInt(fixedOutput.attoAlphAmount))
-    )
-    const lockTime: Buffer = longCodec.encode(BigInt(fixedOutput.lockTime))
-    const lockupScript: LockupScript = lockupScriptCodec.decode(Buffer.from(bs58.decode(fixedOutput.address)))
-    const tokensValue = fixedOutput.tokens.map((token) => {
-      return {
-        tokenId: Buffer.from(token.id, 'hex'),
-        amount: compactUnsignedIntCodec.decode(compactUnsignedIntCodec.encodeU256(BigInt(token.amount)))
-      }
-    })
-    const tokens: DecodedArray<Token> = {
-      length: compactUnsignedIntCodec.decode(compactUnsignedIntCodec.encodeU32(tokensValue.length)),
-      value: tokensValue
-    }
-    const additionalDataValue = Buffer.from(fixedOutput.message, 'hex')
-    const additionalData: ByteString = {
-      length: compactUnsignedIntCodec.decode(compactUnsignedIntCodec.encodeU32(additionalDataValue.length)),
-      value: additionalDataValue
-    }
-
-    return {
-      amount,
-      lockupScript,
-      lockTime,
-      tokens,
-      additionalData
-    }
-  }
-}
-
-export const assetOutputCodec = new AssetOutputCodec()
-export const assetOutputsCodec = new ArrayCodec(assetOutputCodec)

package/src/codec/bigint-codec.ts

@@ -1,91 +0,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/>.
-*/
-export class BigIntCodec {
-  static encode(value: bigint): Buffer {
-    // Special case for zero.
-    if (value === 0n) {
-      return Buffer.from([0])
-    }
-
-    const isNegative = value < 0n
-    let absValue = isNegative ? -value : value
-    const bytes: number[] = []
-
-    // Extract bytes from absolute value.
-    while (absValue > 0n) {
-      bytes.push(Number(absValue & 0xffn))
-      absValue >>= 8n
-    }
-
-    // If the bigint is positive and the most significant byte has its high bit set,
-    // prefix the byte array with a zero byte to signify positive value.
-    if (!isNegative && (bytes[bytes.length - 1] & 0x80) !== 0) {
-      bytes.push(0)
-    }
-
-    // If the bigint is negative, compute the two's complement of the byte array.
-    if (isNegative) {
-      let carry = true
-      for (let i = 0; i < bytes.length; i++) {
-        bytes[i] = ~bytes[i] & 0xff // Invert the bits of the byte.
-        if (carry) {
-          if (bytes[i] === 0xff) {
-            bytes[i] = 0
-          } else {
-            bytes[i] += 1
-            carry = false
-          }
-        }
-      }
-
-      // If there's still a carry, and the most significant byte is not 0xFF (to store the negative sign bit),
-      // or if no bytes were set (which means the value was -1), append a 0xFF byte to hold the carry.
-      if (carry || bytes.length === 0 || (bytes[bytes.length - 1] & 0x80) === 0) {
-        bytes.push(0xff)
-      }
-    }
-
-    // The byte array needs to be reversed since we've constructed it in little-endian order.
-    return Buffer.from(new Uint8Array(bytes.reverse()))
-  }
-
-  static decode(encoded: Buffer, signed: boolean): bigint {
-    // 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
-
-    // Convert the byte array to a bigint
-    let value = 0n
-    for (const byte of encoded) {
-      value = (value << 8n) | BigInt(byte)
-    }
-
-    // If the number is negative, convert from two's complement
-    if (isNegative) {
-      // Create a mask for the value's bit length
-      const mask = (1n << (8n * BigInt(encoded.length))) - 1n
-      value = -(~value & mask) - 1n
-    }
-
-    return value
-  }
-}

package/src/codec/bytestring-codec.ts

@@ -1,55 +0,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/>.
-*/
-import { Parser } from 'binary-parser'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
-import { Codec } from './codec'
-
-export interface ByteString {
-  length: DecodedCompactInt
-  value: Buffer
-}
-
-export class ByteStringCodec implements Codec<ByteString> {
-  parser = new Parser()
-    .nest('length', {
-      type: compactUnsignedIntCodec.parser
-    })
-    .buffer('value', {
-      length: function (ctx) {
-        return compactUnsignedIntCodec.toU32(this['length']! as any as DecodedCompactInt)
-      }
-    })
-
-  encode(input: ByteString): Buffer {
-    return Buffer.from([...compactUnsignedIntCodec.encode(input.length), ...input.value])
-  }
-
-  decode(input: Buffer): ByteString {
-    return this.parser.parse(input)
-  }
-
-  encodeBuffer(input: Buffer): Buffer {
-    return Buffer.from([...compactUnsignedIntCodec.encodeU32(input.length), ...input])
-  }
-
-  decodeBuffer(input: Buffer): Buffer {
-    return this.decode(input).value
-  }
-}
-
-export const byteStringCodec = new ByteStringCodec()