@alephium/web3 0.42.0 → 0.44.0

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

@@ -18,10 +18,10 @@ 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");
+const utils_1 = require("../utils");
 class CompactInt {
 }
 exports.CompactInt = CompactInt;
@@ -60,17 +60,17 @@ class CompactUnsignedIntCodec {
         this.parser = compactIntParser;
     }
     encode(input) {
-        return buffer_1.Buffer.from([input.mode, ...input.rest]);
+        return new Uint8Array([input.mode, ...input.rest]);
     }
     encodeU32(value) {
         if (value < this.oneByteBound) {
-            return buffer_1.Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff]);
+            return new Uint8Array([(CompactInt.oneBytePrefix + value) & 0xff]);
         }
         else if (value < this.twoByteBound) {
-            return buffer_1.Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
+            return new Uint8Array([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
         }
         else if (value < this.fourByteBound) {
-            return buffer_1.Buffer.from([
+            return new Uint8Array([
                 (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
                 (value >> 16) & 0xff,
                 (value >> 8) & 0xff,
@@ -78,7 +78,7 @@ class CompactUnsignedIntCodec {
             ]);
         }
         else {
-            return buffer_1.Buffer.from([
+            return new Uint8Array([
                 CompactInt.multiBytePrefix,
                 (value >> 24) & 0xff,
                 (value >> 16) & 0xff,
@@ -99,13 +99,9 @@ class CompactUnsignedIntCodec {
             }
             (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]);
+            return new Uint8Array([header, ...bytes]);
         }
     }
-    decodeU32(input) {
-        const decoded = this.decode(input);
-        return this.toU32(decoded);
-    }
     decodeU256(input) {
         const decoded = this.decode(input);
         return this.toU256(decoded);
@@ -113,21 +109,15 @@ class CompactUnsignedIntCodec {
     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));
+            const body = new Uint8Array([value.mode, ...value.rest]);
+            return BigInt(decodePositiveInt(value.mode, body));
         }
         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);
+            return bigint_codec_1.BigIntCodec.decode(value.rest, false);
         }
     }
     fromU256(value) {
@@ -145,7 +135,7 @@ class CompactSignedIntCodec {
         this.parser = compactIntParser;
     }
     encode(input) {
-        return buffer_1.Buffer.from([input.mode, ...input.rest]);
+        return new Uint8Array([input.mode, ...input.rest]);
     }
     decode(input) {
         return this.parser.parse(input);
@@ -157,13 +147,13 @@ class CompactSignedIntCodec {
     encodeI32(value) {
         if (value >= 0) {
             if (value < this.oneByteBound) {
-                return buffer_1.Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff]);
+                return new Uint8Array([(CompactInt.oneBytePrefix + value) & 0xff]);
             }
             else if (value < this.twoByteBound) {
-                return buffer_1.Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
+                return new Uint8Array([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
             }
             else if (value < this.fourByteBound) {
-                return buffer_1.Buffer.from([
+                return new Uint8Array([
                     (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
                     (value >> 16) & 0xff,
                     (value >> 8) & 0xff,
@@ -171,7 +161,7 @@ class CompactSignedIntCodec {
                 ]);
             }
             else {
-                return buffer_1.Buffer.from([
+                return new Uint8Array([
                     CompactInt.multiBytePrefix,
                     (value >> 24) & 0xff,
                     (value >> 16) & 0xff,
@@ -182,13 +172,13 @@ class CompactSignedIntCodec {
         }
         else {
             if (value >= -this.oneByteBound) {
-                return buffer_1.Buffer.from([(value ^ CompactInt.oneByteNegPrefix) & 0xff]);
+                return new Uint8Array([(value ^ CompactInt.oneByteNegPrefix) & 0xff]);
             }
             else if (value >= -this.twoByteBound) {
-                return buffer_1.Buffer.from([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff]);
+                return new Uint8Array([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff]);
             }
             else if (value >= -this.fourByteBound) {
-                return buffer_1.Buffer.from([
+                return new Uint8Array([
                     ((value >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
                     (value >> 16) & 0xff,
                     (value >> 8) & 0xff,
@@ -196,7 +186,7 @@ class CompactSignedIntCodec {
                 ]);
             }
             else {
-                return buffer_1.Buffer.from([
+                return new Uint8Array([
                     CompactInt.multiBytePrefix,
                     (value >> 24) & 0xff,
                     (value >> 16) & 0xff,
@@ -213,7 +203,7 @@ class CompactSignedIntCodec {
         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]);
+            return new Uint8Array([header, ...bytes]);
         }
     }
     decodeI256(input) {
@@ -221,7 +211,7 @@ class CompactSignedIntCodec {
         return this.toI256(decoded);
     }
     toI32(value) {
-        const body = buffer_1.Buffer.from([value.mode, ...value.rest]);
+        const body = new Uint8Array([value.mode, ...value.rest]);
         const mode = value.mode & maskRest;
         if (fixedSize(mode)) {
             const isPositive = (value.mode & signFlag) == 0;
@@ -251,7 +241,7 @@ class CompactSignedIntCodec {
         }
         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);
+            return bigint_codec_1.BigIntCodec.decode(value.rest, true);
         }
     }
     fromI256(value) {
@@ -273,7 +263,7 @@ function decodePositiveInt(rawMode, body) {
             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')));
+                return Number(BigInt('0x' + (0, utils_1.binToHex)(body.slice(1))));
             }
             else {
                 throw new Error(`decodePositiveInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`);

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { Codec } from './codec';
@@ -7,17 +6,17 @@ import { Method } from './method-codec';
 export interface HalfDecodedContract {
     fieldLength: DecodedCompactInt;
     methodIndexes: DecodedArray<DecodedCompactInt>;
-    methods: Buffer;
+    methods: Uint8Array;
 }
 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;
+    encode(input: HalfDecodedContract): Uint8Array;
+    decode(input: Uint8Array): HalfDecodedContract;
+    decodeContract(input: Uint8Array): Contract;
+    encodeContract(contract: Contract): Uint8Array;
 }
 export declare const contractCodec: ContractCodec;

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

@@ -17,31 +17,13 @@ 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/");
+exports.contractCodec = exports.ContractCodec = void 0;
 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 utils_1 = require("../utils");
 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()
@@ -54,10 +36,10 @@ class ContractCodec {
             .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
+        return (0, utils_1.concatBytes)([
+            compact_int_codec_1.compactSignedIntCodec.encode(input.fieldLength),
+            compactSignedIntsCodec.encode(input.methodIndexes.value),
+            input.methods
         ]);
     }
     decode(input) {
@@ -65,8 +47,8 @@ class ContractCodec {
     }
     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 fieldLength = compact_int_codec_1.compactSignedIntCodec.toI32(halfDecoded.fieldLength);
+        const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compact_int_codec_1.compactSignedIntCodec.toI32(v));
         const methods = [];
         for (let i = 0, start = 0; i < methodIndexes.length; i++) {
             const end = methodIndexes[i];
@@ -76,6 +58,24 @@ class ContractCodec {
         }
         return { fieldLength, methods };
     }
+    encodeContract(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;
+        });
+        const halfDecoded = {
+            fieldLength,
+            methodIndexes: {
+                length: compact_int_codec_1.compactSignedIntCodec.fromI32(methodIndexes.length),
+                value: methodIndexes.map((value) => compact_int_codec_1.compactSignedIntCodec.fromI32(value))
+            },
+            methods: (0, utils_1.concatBytes)(methods)
+        };
+        return this.encode(halfDecoded);
+    }
 }
 exports.ContractCodec = ContractCodec;
 exports.contractCodec = new ContractCodec();

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { DecodedCompactInt } from './compact-int-codec';
@@ -13,8 +12,8 @@ export interface ContractOutput {
 }
 export declare class ContractOutputCodec implements Codec<ContractOutput> {
     parser: Parser;
-    encode(input: ContractOutput): Buffer;
-    decode(input: Buffer): ContractOutput;
+    encode(input: ContractOutput): Uint8Array;
+    decode(input: Uint8Array): ContractOutput;
     static convertToApiContractOutput(txIdBytes: Uint8Array, output: ContractOutput, index: number): ApiContractOutput;
     static convertToOutput(apiContractOutput: ApiContractOutput): ContractOutput;
 }

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

@@ -18,7 +18,6 @@ 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");
@@ -40,22 +39,22 @@ class ContractOutputCodec {
         });
     }
     encode(input) {
-        const amount = buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount));
+        const amount = 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]);
+        const tokens = token_codec_1.tokensCodec.encode(input.tokens.value);
+        return (0, utils_1.concatBytes)([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, utils_1.binToHex)((0, hash_1.blakeHash)(buffer_1.Buffer.concat([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
+        const key = (0, utils_1.binToHex)((0, hash_1.blakeHash)((0, utils_1.concatBytes)([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
         const attoAlphAmount = compact_int_codec_1.compactUnsignedIntCodec.toU256(output.amount).toString();
-        const address = utils_1.bs58.encode(buffer_1.Buffer.concat([buffer_1.Buffer.from([0x03]), output.lockupScript.contractId]));
+        const address = utils_1.bs58.encode(new Uint8Array([0x03, ...output.lockupScript.contractId]));
         const tokens = output.tokens.value.map((token) => {
             return {
-                id: token.tokenId.toString('hex'),
+                id: (0, utils_1.binToHex)(token.tokenId),
                 amount: compact_int_codec_1.compactUnsignedIntCodec.toU256(token.amount).toString()
             };
         });
@@ -63,16 +62,15 @@ class ContractOutputCodec {
     }
     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(utils_1.bs58.decode(apiContractOutput.address)))
-            .script;
+        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(utils_1.bs58.decode(apiContractOutput.address)).script;
         const tokensValue = apiContractOutput.tokens.map((token) => {
             return {
-                tokenId: buffer_1.Buffer.from(token.id, 'hex'),
+                tokenId: (0, utils_1.hexToBinUnsafe)(token.id),
                 amount: compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(token.amount))
             };
         });
         const tokens = {
-            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(tokensValue.length),
+            length: compact_int_codec_1.compactSignedIntCodec.fromI32(tokensValue.length),
             value: tokensValue
         };
         return { amount, lockupScript, tokens };

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

@@ -1,15 +1,14 @@
-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;
+    key: Uint8Array;
 }
 export declare class ContractOutputRefCodec implements Codec<ContractOutputRef> {
     parser: Parser;
-    encode(input: ContractOutputRef): Buffer;
-    decode(input: Buffer): ContractOutputRef;
+    encode(input: ContractOutputRef): Uint8Array;
+    decode(input: Uint8Array): ContractOutputRef;
 }
 export declare const contractOutputRefCodec: ContractOutputRefCodec;
 export declare const contractOutputRefsCodec: ArrayCodec<ContractOutputRef>;

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

@@ -18,16 +18,16 @@ 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");
+const utils_1 = require("../utils");
 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])]);
+        return (0, utils_1.concatBytes)([signed_int_codec_1.signedIntCodec.encode(input.hint), input.key]);
     }
     decode(input) {
         return this.parser.parse(input);

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { Codec } from './codec';
 export interface Either<L, R> {
@@ -10,8 +9,8 @@ export declare class EitherCodec<L, R> implements Codec<Either<L, R>> {
     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>;
+    encode(input: Either<L, R>): Uint8Array;
+    decode(input: Uint8Array): Either<L, R>;
     fromLeft(left: L): Either<L, R>;
     fromRight(right: R): Either<L, R>;
 }

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

@@ -18,7 +18,6 @@ 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()
@@ -42,7 +41,7 @@ class EitherCodec {
         else {
             result.push(...this.rightCodec.encode(input.value));
         }
-        return buffer_1.Buffer.from(result);
+        return new Uint8Array(result);
     }
     decode(input) {
         const result = this.parser.parse(input);

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

@@ -1,4 +1,3 @@
-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;
+export declare function djbIntHash(bytes: Uint8Array): number;
+export declare function createHint(input: Uint8Array): number;

package/dist/src/codec/hash.js

@@ -4,6 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHint = exports.djbIntHash = exports.blakeHash = 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 blakejs_1 = __importDefault(require("blakejs"));
 function blakeHash(raw) {
     return blakejs_1.default.blake2b(raw, undefined, 32);

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { AssetInput } from '../api/api-alephium';
 import { UnlockScript } from './unlock-script-codec';
@@ -7,14 +6,14 @@ import { ArrayCodec } from './array-codec';
 export interface Input {
     outputRef: {
         hint: number;
-        key: Buffer;
+        key: Uint8Array;
     };
     unlockScript: UnlockScript;
 }
 export declare class InputCodec implements Codec<Input> {
     parser: Parser;
-    encode(input: Input): Buffer;
-    decode(input: Buffer): Input;
+    encode(input: Input): Uint8Array;
+    decode(input: Uint8Array): Input;
     static toAssetInputs(inputs: Input[]): AssetInput[];
     static fromAssetInputs(inputs: AssetInput[]): Input[];
 }

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

@@ -18,7 +18,6 @@ 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 utils_1 = require("../utils");
 const unlock_script_codec_1 = require("./unlock-script-codec");
@@ -35,8 +34,9 @@ class InputCodec {
         });
     }
     encode(input) {
-        return buffer_1.Buffer.concat([
-            buffer_1.Buffer.from([...signed_int_codec_1.signedIntCodec.encode(input.outputRef.hint), ...input.outputRef.key]),
+        return (0, utils_1.concatBytes)([
+            signed_int_codec_1.signedIntCodec.encode(input.outputRef.hint),
+            input.outputRef.key,
             unlock_script_codec_1.unlockScriptCodec.encode(input.unlockScript)
         ]);
     }
@@ -50,15 +50,15 @@ class InputCodec {
             const unlockScript = unlock_script_codec_1.unlockScriptCodec.encode(input.unlockScript);
             return {
                 outputRef: { hint, key },
-                unlockScript: unlockScript.toString('hex')
+                unlockScript: (0, utils_1.binToHex)(unlockScript)
             };
         });
     }
     static fromAssetInputs(inputs) {
         return inputs.map((input) => {
             const hint = input.outputRef.hint;
-            const key = buffer_1.Buffer.from(input.outputRef.key, 'hex');
-            const unlockScript = unlock_script_codec_1.unlockScriptCodec.decode(buffer_1.Buffer.from(input.unlockScript, 'hex'));
+            const key = (0, utils_1.hexToBinUnsafe)(input.outputRef.key);
+            const unlockScript = unlock_script_codec_1.unlockScriptCodec.decode((0, utils_1.hexToBinUnsafe)(input.unlockScript));
             return {
                 outputRef: { hint, key },
                 unlockScript

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { ArrayCodec, DecodedArray } from './array-codec';
 import { DecodedCompactInt } from './compact-int-codec';
@@ -226,8 +225,8 @@ export declare const MethodSelector: (selector: number) => Instr;
 export declare const CallExternalBySelector: (selector: number) => Instr;
 export declare class InstrCodec implements Codec<Instr> {
     parser: Parser;
-    encode(instr: Instr): Buffer;
-    decode(input: Buffer): Instr;
+    encode(instr: Instr): Uint8Array;
+    decode(input: Uint8Array): Instr;
 }
 export declare const instrCodec: InstrCodec;
 export declare const instrsCodec: ArrayCodec<Instr>;

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

@@ -21,7 +21,6 @@ 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 compact_int_codec_1 = require("./compact-int-codec");
@@ -476,7 +475,7 @@ class InstrCodec {
         else if (instr.code === 0xd3 || instr.code === 0xd4) {
             result.push(...signed_int_codec_1.signedIntCodec.encode(instrValue.index));
         }
-        return buffer_1.Buffer.from(result);
+        return new Uint8Array(result);
     }
     decode(input) {
         return this.parser.parse(input);

package/dist/src/codec/lockup-script-codec.d.ts

@@ -1,20 +1,19 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedCompactInt } from './compact-int-codec';
 import { Codec } from './codec';
 import { DecodedArray } from './array-codec';
 export interface PublicKeyHash {
-    publicKeyHash: Buffer;
+    publicKeyHash: Uint8Array;
 }
 export interface MultiSig {
     publicKeyHashes: DecodedArray<PublicKeyHash>;
     m: DecodedCompactInt;
 }
 export interface P2SH {
-    scriptHash: Buffer;
+    scriptHash: Uint8Array;
 }
 export interface P2C {
-    contractId: Buffer;
+    contractId: Uint8Array;
 }
 export interface LockupScript {
     scriptType: number;
@@ -22,7 +21,7 @@ export interface LockupScript {
 }
 export declare class LockupScriptCodec implements Codec<LockupScript> {
     parser: Parser;
-    encode(input: LockupScript): Buffer;
-    decode(input: Buffer): LockupScript;
+    encode(input: LockupScript): Uint8Array;
+    decode(input: Uint8Array): LockupScript;
 }
 export declare const lockupScriptCodec: LockupScriptCodec;

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

@@ -18,7 +18,6 @@ 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 array_codec_1 = require("./array-codec");
@@ -70,7 +69,7 @@ class LockupScriptCodec {
         else {
             throw new Error(`Unsupported script type: ${input.scriptType}`);
         }
-        return buffer_1.Buffer.from(result);
+        return new Uint8Array(result);
     }
     decode(input) {
         return this.parser.parse(input);

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

@@ -1,9 +1,8 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { Codec } from './codec';
 export declare class LongCodec implements Codec<bigint> {
     parser: Parser;
-    encode(input: bigint): Buffer;
-    decode(bytes: Buffer): bigint;
+    encode(input: bigint): Uint8Array;
+    decode(bytes: Uint8Array): bigint;
 }
 export declare const longCodec: LongCodec;

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

@@ -18,7 +18,6 @@ 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");
 class LongCodec {
@@ -35,7 +34,7 @@ class LongCodec {
             byteArray[byteArray.length - index - 1] = Number(byte);
             input >>= BigInt(8);
         }
-        return buffer_1.Buffer.from(byteArray);
+        return byteArray;
     }
     decode(bytes) {
         (0, codec_1.assert)(bytes.length == 8, 'Length should be 8');