@alephium/web3 0.37.0 → 0.38.0

package/dist/src/contract/ralph.js

@@ -18,10 +18,11 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.flattenFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.encodeBool = void 0;
+exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.flattenFields = exports.primitiveToByteVec = exports.decodePrimitive = exports.tryDecodeMapDebugLog = exports.calcFieldSize = exports.encodeMapPrefix = exports.parseMapType = exports.splitFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.decodeBool = exports.encodeBool = void 0;
 const buffer_1 = require("buffer/");
 const api_1 = require("../api");
 const utils_1 = require("../utils");
+const codec_1 = require("../codec");
 const bigIntZero = BigInt(0);
 class UnSigned {
 }
@@ -50,6 +51,13 @@ function encodeBool(bool) {
     return bool ? Uint8Array.from([1]) : Uint8Array.from([0]);
 }
 exports.encodeBool = encodeBool;
+function decodeBool(bytes) {
+    if (bytes.length !== 1) {
+        throw new Error(`Expected one byte for encoded bool, got ${bytes.length}`);
+    }
+    return bytes[0] === 1 ? true : false;
+}
+exports.decodeBool = decodeBool;
 function encodeI256(i256) {
     if (i256 >= bigIntZero) {
         return encodeI256Positive(i256);
@@ -250,6 +258,124 @@ function encodeScriptField(tpe, value) {
     throw invalidScriptField(tpe, value);
 }
 exports.encodeScriptField = encodeScriptField;
+function splitFields(fieldsSig) {
+    return fieldsSig.types.reduce(([mapFields, fieldsExceptMaps], type, index) => {
+        const fieldSig = type.startsWith('Map[') ? mapFields : fieldsExceptMaps;
+        fieldSig.names.push(fieldsSig.names[`${index}`]);
+        fieldSig.types.push(type);
+        fieldSig.isMutable.push(fieldsSig.isMutable[`${index}`]);
+        return [mapFields, fieldsExceptMaps];
+    }, [
+        { names: [], types: [], isMutable: [] },
+        { names: [], types: [], isMutable: [] }
+    ]);
+}
+exports.splitFields = splitFields;
+function parseMapType(type) {
+    if (!type.startsWith('Map[')) {
+        throw new Error(`Expected map type, got ${type}`);
+    }
+    const keyStartIndex = type.indexOf('[');
+    const keyEndIndex = type.indexOf(',');
+    return [type.slice(keyStartIndex + 1, keyEndIndex), type.slice(keyEndIndex + 1, type.length - 1)];
+}
+exports.parseMapType = parseMapType;
+function encodeMapPrefix(mapIndex) {
+    const str = `__map__${mapIndex}__`;
+    const bytes = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i += 1) {
+        bytes[i] = str.charCodeAt(i);
+    }
+    return bytes;
+}
+exports.encodeMapPrefix = encodeMapPrefix;
+function fromAscii(str) {
+    let result = '';
+    for (let i = 0; i < str.length; i += 2) {
+        const ascii = parseInt(str.slice(i, i + 2), 16);
+        result += String.fromCharCode(ascii);
+    }
+    return result;
+}
+function calcFieldSize(type, isMutable, structs) {
+    const struct = structs.find((s) => s.name === type);
+    if (struct !== undefined) {
+        return struct.fieldTypes.reduce((acc, fieldType, index) => {
+            const isFieldMutable = isMutable && struct.isMutable[`${index}`];
+            const subFieldSize = calcFieldSize(fieldType, isFieldMutable, structs);
+            return {
+                immFields: acc.immFields + subFieldSize.immFields,
+                mutFields: acc.mutFields + subFieldSize.mutFields
+            };
+        }, { immFields: 0, mutFields: 0 });
+    }
+    if (type.startsWith('[')) {
+        const [baseType, size] = (0, api_1.decodeArrayType)(type);
+        const base = calcFieldSize(baseType, isMutable, structs);
+        return { immFields: base.immFields * size, mutFields: base.mutFields * size };
+    }
+    return isMutable ? { immFields: 0, mutFields: 1 } : { immFields: 1, mutFields: 0 };
+}
+exports.calcFieldSize = calcFieldSize;
+function tryDecodeMapDebugLog(message) {
+    const prefix = '5f5f6d61705f5f'; // __map__
+    const parts = message.split(',');
+    if (!message.startsWith(prefix) || parts.length !== 2)
+        return undefined;
+    if (parts[1] !== 'true' && parts[1] !== 'false')
+        return undefined;
+    if (!(0, utils_1.isHexString)(parts[0]))
+        return undefined;
+    const remain = parts[0].slice(prefix.length);
+    const suffixIndex = remain.indexOf('5f5f'); // __
+    if (suffixIndex === -1)
+        return undefined;
+    const encodedMapIndex = remain.slice(0, suffixIndex);
+    const mapIndex = parseInt(fromAscii(encodedMapIndex));
+    const encodedKey = (0, utils_1.hexToBinUnsafe)(remain.slice(suffixIndex + 4));
+    const isInsert = parts[1] === 'true' ? true : false;
+    return { path: parts[0], mapIndex, encodedKey, isInsert };
+}
+exports.tryDecodeMapDebugLog = tryDecodeMapDebugLog;
+function decodePrimitive(value, type) {
+    switch (type) {
+        case 'Bool':
+            return decodeBool(value);
+        case 'I256':
+            return codec_1.compactSignedIntCodec.decodeI256(buffer_1.Buffer.from(value));
+        case 'U256':
+            return codec_1.compactUnsignedIntCodec.decodeU256(buffer_1.Buffer.from(value));
+        case 'ByteVec':
+            return (0, utils_1.binToHex)(value);
+        case 'Address':
+            return utils_1.bs58.encode(value);
+        default:
+            throw Error(`Expected primitive type, got ${type}`);
+    }
+}
+exports.decodePrimitive = decodePrimitive;
+function primitiveToByteVec(value, type) {
+    switch (type) {
+        case 'Bool':
+            const byte = (0, api_1.toApiBoolean)(value) ? 1 : 0;
+            return new Uint8Array([byte]);
+        case 'I256':
+            const i256 = (0, api_1.toApiNumber256)(value);
+            return encodeI256(BigInt(i256));
+        case 'U256':
+            const u256 = (0, api_1.toApiNumber256)(value);
+            return encodeU256(BigInt(u256));
+        case 'ByteVec':
+            const hexStr = (0, api_1.toApiByteVec)(value);
+            return encodeByteVec(hexStr);
+        case 'Address':
+            const address = (0, api_1.toApiAddress)(value);
+            return encodeAddress(address);
+        default:
+            throw Error(`Expected primitive type, got ${type}`);
+    }
+}
+exports.primitiveToByteVec = primitiveToByteVec;
 function flattenFields(fields, names, types, isMutable, structs) {
     return names.flatMap((name, index) => {
         if (!(name in fields)) {

package/dist/src/index.d.ts

@@ -6,5 +6,6 @@ export * from './transaction';
 export * from './token';
 export * from './constants';
 export * as web3 from './global';
+export * as codec from './codec';
 export * as utils from './utils';
 export * from './debug';

package/dist/src/index.js

@@ -43,7 +43,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.utils = exports.web3 = void 0;
+exports.utils = exports.codec = exports.web3 = void 0;
 BigInt.prototype['toJSON'] = function () {
     return this.toString();
 };
@@ -55,5 +55,6 @@ __exportStar(require("./transaction"), exports);
 __exportStar(require("./token"), exports);
 __exportStar(require("./constants"), exports);
 exports.web3 = __importStar(require("./global"));
+exports.codec = __importStar(require("./codec"));
 exports.utils = __importStar(require("./utils"));
 __exportStar(require("./debug"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -43,7 +43,8 @@
     "elliptic": "6.5.4",
     "eventemitter3": "^4.0.7",
     "path-browserify": "^1.0.1",
-    "stream-browserify": "^3.0.0"
+    "stream-browserify": "^3.0.0",
+    "binary-parser": "2.2.1"
   },
   "devDependencies": {
     "@babel/eslint-parser": "^7.21.3",
@@ -89,7 +90,7 @@
     "build": "rm -rf dist/* && npx tsc --build . && webpack",
     "test": "jest -i --config ./jest-config.json",
     "update-schemas": "npm run update-schema:alephium && npm run update-schema:explorer",
-    "update-schema:alephium": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/v${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
+    "update-schema:alephium": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/rhone-upgrade/api/src/main/resources/openapi.json",
     "update-schema:explorer": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-explorer.ts -p https://raw.githubusercontent.com/alephium/explorer-backend/v${npm_package_config_explorer_backend_version}/app/src/main/resources/explorer-backend-openapi.json",
     "check-versions": "node scripts/check-versions.js ${npm_package_config_alephium_version} ${npm_package_config_explorer_backend_version}"
   }

package/src/api/api-alephium.ts

@@ -424,6 +424,7 @@ export interface CompileContractResult {
   enums: Enum[]
   events: EventSig[]
   warnings: string[]
+  maps?: MapsSig
   stdInterfaceId?: string
 }
 
@@ -658,6 +659,11 @@ export interface InternalServerError {
   detail: string
 }
 
+export interface MapsSig {
+  names: string[]
+  types: string[]
+}
+
 export interface MemPooled {
   type: string
 }

package/src/api/types.ts

@@ -22,7 +22,7 @@ import { assertType, bs58, Eq, isBase58, isHexString } from '../utils'
 import * as node from './api-alephium'
 
 export type Number256 = bigint | string
-export type Val = Number256 | boolean | string | Val[] | ValObject
+export type Val = Number256 | boolean | string | Val[] | ValObject | Map<Val, Val>
 // eslint-disable-next-line
 export interface ValObject extends Record<string, Val> {} // bypassing typescript recursive type limitations
 export type NamedVals = Record<string, Val>

package/src/codec/array-codec.ts

@@ -0,0 +1,63 @@
+/*
+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 { Buffer } from 'buffer/'
+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.fromU32(inputs.length),
+      value: inputs
+    }
+  }
+}

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

@@ -0,0 +1,149 @@
+/*
+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 { Buffer } from 'buffer/'
+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) {
+      throw new Error(`P2C script type not allowed for asset output`)
+    } else {
+      throw new Error(`Unexpected 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.fromU256(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.fromU256(BigInt(token.amount))
+      }
+    })
+    const tokens: DecodedArray<Token> = {
+      length: compactUnsignedIntCodec.fromU32(tokensValue.length),
+      value: tokensValue
+    }
+    const additionalDataValue = Buffer.from(fixedOutput.message, 'hex')
+    const additionalData: ByteString = {
+      length: compactUnsignedIntCodec.fromU32(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

@@ -0,0 +1,92 @@
+/*
+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 { Buffer } from 'buffer/'
+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

@@ -0,0 +1,56 @@
+/*
+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 { Buffer } from 'buffer/'
+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()

package/src/codec/codec.ts

@@ -0,0 +1,31 @@
+/*
+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 { Buffer } from 'buffer/'
+import { Parser } from 'binary-parser'
+
+export interface Codec<T> {
+  parser: Parser
+  encode(input: T): Buffer
+  decode(input: Buffer): T
+}
+
+export function assert(value: boolean, message: string) {
+  if (!value) {
+    throw new Error(message)
+  }
+}