@alephium/web3 0.29.2 → 0.30.0-beta.1

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

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

@@ -0,0 +1,30 @@
+/// <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

@@ -0,0 +1,102 @@
+"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/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.29.2",
+  "version": "0.30.0-beta.1",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "2.8.2",
+    "alephium_version": "2.8.3",
     "explorer_backend_version": "1.16.1"
   },
   "type": "commonjs",
@@ -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",

package/src/api/api-alephium.ts

@@ -1278,7 +1278,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 2.8.2
+ * @version 2.8.3
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/codec/array-codec.ts

@@ -0,0 +1,62 @@
+/*
+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

@@ -0,0 +1,150 @@
+/*
+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

@@ -0,0 +1,91 @@
+/*
+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
+  }
+}