@alephium/web3 0.42.0 → 0.43.0

package/dist/src/{utils → address}/address.js

@@ -25,11 +25,10 @@ const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("../constants");
 const blakejs_1 = __importDefault(require("blakejs"));
-const bs58_1 = __importDefault(require("./bs58"));
-const djb2_1 = __importDefault(require("./djb2"));
-const utils_1 = require("./utils");
+const bs58_1 = __importDefault(require("../utils/bs58"));
+const djb2_1 = __importDefault(require("../utils/djb2"));
+const utils_1 = require("../utils");
 const lockup_script_codec_1 = require("../codec/lockup-script-codec");
-const buffer_1 = require("buffer/");
 const codec_1 = require("../codec");
 const ec = new elliptic_1.ec('secp256k1');
 var AddressType;
@@ -57,7 +56,7 @@ function decodeAndValidateAddress(address) {
     if (addressType === AddressType.P2MPKH) {
         let multisig;
         try {
-            multisig = lockup_script_codec_1.lockupScriptCodec.decode(buffer_1.Buffer.from(decoded)).script;
+            multisig = lockup_script_codec_1.lockupScriptCodec.decode(decoded).script;
         }
         catch (_) {
             throw new Error(`Invalid multisig address: ${address}`);
@@ -163,27 +162,24 @@ exports.publicKeyFromPrivateKey = publicKeyFromPrivateKey;
 function addressFromPublicKey(publicKey, _keyType) {
     const keyType = _keyType ?? 'default';
     if (keyType === 'default') {
-        const addressType = buffer_1.Buffer.from([AddressType.P2PKH]);
-        const hash = buffer_1.Buffer.from(blakejs_1.default.blake2b(buffer_1.Buffer.from(publicKey, 'hex'), undefined, 32));
-        const bytes = buffer_1.Buffer.concat([addressType, hash]);
+        const hash = blakejs_1.default.blake2b((0, utils_1.hexToBinUnsafe)(publicKey), undefined, 32);
+        const bytes = new Uint8Array([AddressType.P2PKH, ...hash]);
         return bs58_1.default.encode(bytes);
     }
     else {
-        const lockupScript = buffer_1.Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex');
+        const lockupScript = (0, utils_1.hexToBinUnsafe)(`0101000000000458144020${publicKey}8685`);
         return addressFromScript(lockupScript);
     }
 }
 exports.addressFromPublicKey = addressFromPublicKey;
 function addressFromScript(script) {
     const scriptHash = blakejs_1.default.blake2b(script, undefined, 32);
-    const addressType = buffer_1.Buffer.from([AddressType.P2SH]);
-    return bs58_1.default.encode(buffer_1.Buffer.concat([addressType, scriptHash]));
+    return bs58_1.default.encode(new Uint8Array([AddressType.P2SH, ...scriptHash]));
 }
 exports.addressFromScript = addressFromScript;
 function addressFromContractId(contractId) {
-    const addressType = buffer_1.Buffer.from([AddressType.P2C]);
-    const hash = buffer_1.Buffer.from((0, utils_1.hexToBinUnsafe)(contractId));
-    const bytes = buffer_1.Buffer.concat([addressType, hash]);
+    const hash = (0, utils_1.hexToBinUnsafe)(contractId);
+    const bytes = new Uint8Array([AddressType.P2C, ...hash]);
     return bs58_1.default.encode(bytes);
 }
 exports.addressFromContractId = addressFromContractId;
@@ -194,7 +190,7 @@ function addressFromTokenId(tokenId) {
 exports.addressFromTokenId = addressFromTokenId;
 function contractIdFromTx(txId, outputIndex) {
     const txIdBin = (0, utils_1.hexToBinUnsafe)(txId);
-    const data = buffer_1.Buffer.concat([txIdBin, buffer_1.Buffer.from([outputIndex])]);
+    const data = new Uint8Array([...txIdBin, outputIndex]);
     const hash = blakejs_1.default.blake2b(data, undefined, 32);
     return (0, utils_1.binToHex)(hash);
 }
@@ -203,10 +199,10 @@ function subContractId(parentContractId, pathInHex, group) {
     if (group < 0 || group >= constants_1.TOTAL_NUMBER_OF_GROUPS) {
         throw new Error(`Invalid group ${group}`);
     }
-    const data = buffer_1.Buffer.concat([(0, utils_1.hexToBinUnsafe)(parentContractId), (0, utils_1.hexToBinUnsafe)(pathInHex)]);
-    const bytes = buffer_1.Buffer.concat([
-        blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
-        buffer_1.Buffer.from([group])
+    const data = (0, utils_1.concatBytes)([(0, utils_1.hexToBinUnsafe)(parentContractId), (0, utils_1.hexToBinUnsafe)(pathInHex)]);
+    const bytes = new Uint8Array([
+        ...blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
+        group
     ]);
     return (0, utils_1.binToHex)(bytes);
 }

package/dist/src/address/index.d.ts

@@ -0,0 +1 @@
+export * from './address';

package/dist/src/address/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./address"), exports);

package/dist/src/api/node-provider.js

@@ -21,6 +21,7 @@ exports.tryGetCallResult = exports.NodeProvider = void 0;
 const types_1 = require("./types");
 const api_alephium_1 = require("./api-alephium");
 const utils_1 = require("../utils");
+const address_1 = require("../address");
 function initializeNodeApi(baseUrl, apiKey, customFetch) {
     const nodeApi = new api_alephium_1.Api({
         baseUrl: baseUrl,
@@ -38,8 +39,8 @@ class NodeProvider {
         };
         // Only use this when the token follows the fungible token interface, check `guessTokenType` first
         this.fetchFungibleTokenMetaData = async (tokenId) => {
-            const address = (0, utils_1.addressFromTokenId)(tokenId);
-            const group = (0, utils_1.groupOfAddress)(address);
+            const address = (0, address_1.addressFromTokenId)(tokenId);
+            const group = (0, address_1.groupOfAddress)(address);
             const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }));
             const result = await this.contracts.postContractsMulticallContract({
                 calls: calls
@@ -54,8 +55,8 @@ class NodeProvider {
         };
         // Only use this when the token follows the non-fungile token interface, check `guessTokenType` first
         this.fetchNFTMetaData = async (tokenId) => {
-            const address = (0, utils_1.addressFromTokenId)(tokenId);
-            const group = (0, utils_1.groupOfAddress)(address);
+            const address = (0, address_1.addressFromTokenId)(tokenId);
+            const group = (0, address_1.groupOfAddress)(address);
             const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }));
             const result = await this.contracts.postContractsMulticallContract({
                 calls: calls
@@ -99,8 +100,8 @@ class NodeProvider {
         };
         // Only use this when the contract follows the NFT collection interface, check `guessFollowsNFTCollectionStd` first
         this.fetchNFTCollectionMetaData = async (collectionId) => {
-            const address = (0, utils_1.addressFromContractId)(collectionId);
-            const group = (0, utils_1.groupOfAddress)(address);
+            const address = (0, address_1.addressFromContractId)(collectionId);
+            const group = (0, address_1.groupOfAddress)(address);
             const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }));
             const result = await this.contracts.postContractsMulticallContract({ calls });
             const callResults = result.results.map((r) => tryGetCallResult(r));
@@ -111,8 +112,8 @@ class NodeProvider {
         };
         // Only use this when the contract follows the NFT collection with royalty interface, check `guessFollowsNFTCollectionWithRoyaltyStd` first
         this.fetchNFTRoyaltyAmount = async (collectionId, tokenId, salePrice) => {
-            const address = (0, utils_1.addressFromContractId)(collectionId);
-            const group = (0, utils_1.groupOfAddress)(address);
+            const address = (0, address_1.addressFromContractId)(collectionId);
+            const group = (0, address_1.groupOfAddress)(address);
             const apiResult = await this.contracts.postContractsCallContract({
                 address: address,
                 group: group,
@@ -132,7 +133,7 @@ class NodeProvider {
             return BigInt(result.returns[0].value);
         };
         this.guessStdInterfaceId = async (tokenId) => {
-            const address = (0, utils_1.addressFromTokenId)(tokenId);
+            const address = (0, address_1.addressFromTokenId)(tokenId);
             const rawState = await this.contracts.getContractsAddressState(address);
             const lastImmField = rawState.immFields.slice(-1).pop()?.value;
             const interfaceIdPrefix = '414c5048'; // the hex of 'ALPH'

package/dist/src/api/types.js

@@ -85,7 +85,7 @@ function toApiByteVec(v) {
         try {
             const address = utils_1.bs58.decode(v);
             if (address.length == 33 && address[0] == 3) {
-                return Buffer.from(address.slice(1)).toString('hex');
+                return (0, utils_1.binToHex)(address.slice(1));
             }
         }
         catch (_) {

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedCompactInt } from './compact-int-codec';
 import { Codec } from './codec';
@@ -10,8 +9,8 @@ export declare class ArrayCodec<T> implements Codec<T[]> {
     private childCodec;
     parser: Parser;
     constructor(childCodec: Codec<T>, parser?: Parser);
-    encode(input: T[]): Buffer;
-    decode(input: Buffer): T[];
+    encode(input: T[]): Uint8Array;
+    decode(input: Uint8Array): T[];
     static arrayParser(parser: Parser): Parser;
     fromArray(inputs: T[]): DecodedArray<T>;
 }

package/dist/src/codec/array-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");
 class ArrayCodec {
@@ -31,7 +30,7 @@ class ArrayCodec {
         for (const element of input) {
             result.push(...this.childCodec.encode(element));
         }
-        return buffer_1.Buffer.from(result);
+        return new Uint8Array(result);
     }
     decode(input) {
         const result = this.parser.parse(input);

package/dist/src/codec/asset-output-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';
@@ -10,14 +9,14 @@ import { Token } from './token-codec';
 export interface AssetOutput {
     amount: DecodedCompactInt;
     lockupScript: LockupScript;
-    lockTime: Buffer;
+    lockTime: Uint8Array;
     tokens: DecodedArray<Token>;
     additionalData: ByteString;
 }
 export declare class AssetOutputCodec implements Codec<AssetOutput> {
     parser: Parser;
-    encode(input: AssetOutput): Buffer;
-    decode(input: Buffer): AssetOutput;
+    encode(input: AssetOutput): Uint8Array;
+    decode(input: Uint8Array): AssetOutput;
     static toFixedAssetOutputs(txIdBytes: Uint8Array, outputs: AssetOutput[]): FixedAssetOutput[];
     static toFixedAssetOutput(txIdBytes: Uint8Array, output: AssetOutput, index: number): FixedAssetOutput;
     static fromFixedAssetOutputs(fixedOutputs: FixedAssetOutput[]): AssetOutput[];

package/dist/src/codec/asset-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 array_codec_1 = require("./array-codec");
 const compact_int_codec_1 = require("./compact-int-codec");
@@ -49,12 +48,11 @@ class AssetOutputCodec {
         });
     }
     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 = lockup_script_codec_1.lockupScriptCodec.encode(input.lockupScript);
-        const lockTime = buffer_1.Buffer.from(input.lockTime);
-        const tokens = buffer_1.Buffer.from(token_codec_1.tokensCodec.encode(input.tokens.value));
-        const additionalData = buffer_1.Buffer.from(bytestring_codec_1.byteStringCodec.encode(input.additionalData));
-        return buffer_1.Buffer.concat([amount, lockupScript, lockTime, tokens, additionalData]);
+        const tokens = token_codec_1.tokensCodec.encode(input.tokens.value);
+        const additionalData = bytestring_codec_1.byteStringCodec.encode(input.additionalData);
+        return (0, utils_1.concatBytes)([amount, lockupScript, input.lockTime, tokens, additionalData]);
     }
     decode(input) {
         return this.parser.parse(input);
@@ -67,13 +65,13 @@ class AssetOutputCodec {
         const lockTime = Number(long_codec_1.longCodec.decode(output.lockTime));
         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()
             };
         });
-        const message = output.additionalData.value.toString('hex');
+        const message = (0, utils_1.binToHex)(output.additionalData.value);
         const scriptType = output.lockupScript.scriptType;
-        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 outputLockupScript = output.lockupScript.script;
         const address = utils_1.bs58.encode(lockup_script_codec_1.lockupScriptCodec.encode(output.lockupScript));
         let hint = undefined;
@@ -105,10 +103,10 @@ class AssetOutputCodec {
     static fromFixedAssetOutput(fixedOutput) {
         const amount = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(fixedOutput.attoAlphAmount));
         const lockTime = long_codec_1.longCodec.encode(BigInt(fixedOutput.lockTime));
-        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(buffer_1.Buffer.from(utils_1.bs58.decode(fixedOutput.address)));
+        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(utils_1.bs58.decode(fixedOutput.address));
         const tokensValue = fixedOutput.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))
             };
         });
@@ -116,7 +114,7 @@ class AssetOutputCodec {
             length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(tokensValue.length),
             value: tokensValue
         };
-        const additionalDataValue = buffer_1.Buffer.from(fixedOutput.message, 'hex');
+        const additionalDataValue = (0, utils_1.hexToBinUnsafe)(fixedOutput.message);
         const additionalData = {
             length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(additionalDataValue.length),
             value: additionalDataValue

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

@@ -1,5 +1,4 @@
-import { Buffer } from 'buffer/';
 export declare class BigIntCodec {
-    static encode(value: bigint): Buffer;
-    static decode(encoded: Buffer, signed: boolean): bigint;
+    static encode(value: bigint): Uint8Array;
+    static decode(encoded: Uint8Array, signed: boolean): bigint;
 }

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

@@ -18,12 +18,11 @@ 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/");
 class BigIntCodec {
     static encode(value) {
         // Special case for zero.
         if (value === 0n) {
-            return buffer_1.Buffer.from([0]);
+            return new Uint8Array([0]);
         }
         const isNegative = value < 0n;
         let absValue = isNegative ? -value : value;
@@ -60,7 +59,7 @@ class BigIntCodec {
             }
         }
         // The byte array needs to be reversed since we've constructed it in little-endian order.
-        return buffer_1.Buffer.from(new Uint8Array(bytes.reverse()));
+        return new Uint8Array(bytes.reverse());
     }
     static decode(encoded, signed) {
         // Special case for zero.

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

@@ -1,16 +1,15 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedCompactInt } from './compact-int-codec';
 import { Codec } from './codec';
 export interface ByteString {
     length: DecodedCompactInt;
-    value: Buffer;
+    value: Uint8Array;
 }
 export declare class ByteStringCodec implements Codec<ByteString> {
     parser: Parser;
-    encode(input: ByteString): Buffer;
-    decode(input: Buffer): ByteString;
-    encodeBuffer(input: Buffer): Buffer;
-    decodeBuffer(input: Buffer): Buffer;
+    encode(input: ByteString): Uint8Array;
+    decode(input: Uint8Array): ByteString;
+    encodeBytes(input: Uint8Array): Uint8Array;
+    decodeBytes(input: Uint8Array): Uint8Array;
 }
 export declare const byteStringCodec: ByteStringCodec;

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

@@ -18,9 +18,9 @@ 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 utils_1 = require("../utils");
 class ByteStringCodec {
     constructor() {
         this.parser = new binary_parser_1.Parser()
@@ -34,15 +34,15 @@ class ByteStringCodec {
         });
     }
     encode(input) {
-        return buffer_1.Buffer.from([...compact_int_codec_1.compactUnsignedIntCodec.encode(input.length), ...input.value]);
+        return (0, utils_1.concatBytes)([compact_int_codec_1.compactUnsignedIntCodec.encode(input.length), input.value]);
     }
     decode(input) {
         return this.parser.parse(input);
     }
-    encodeBuffer(input) {
-        return buffer_1.Buffer.from([...compact_int_codec_1.compactUnsignedIntCodec.encodeU32(input.length), ...input]);
+    encodeBytes(input) {
+        return (0, utils_1.concatBytes)([compact_int_codec_1.compactUnsignedIntCodec.encodeU32(input.length), input]);
     }
-    decodeBuffer(input) {
+    decodeBytes(input) {
         return this.decode(input).value;
     }
 }

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

@@ -1,8 +1,7 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 export interface Codec<T> {
     parser: Parser;
-    encode(input: T): Buffer;
-    decode(input: Buffer): T;
+    encode(input: T): Uint8Array;
+    decode(input: Uint8Array): T;
 }
 export declare function assert(value: boolean, message: string): void;

package/dist/src/codec/compact-int-codec.d.ts

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { Codec } from './codec';
 export declare class CompactInt {
@@ -19,12 +18,12 @@ export declare class CompactUnsignedIntCodec implements Codec<DecodedCompactInt>
     private twoByteBound;
     private fourByteBound;
     parser: Parser;
-    encode(input: DecodedCompactInt): Buffer;
-    encodeU32(value: number): Buffer;
-    encodeU256(value: bigint): Buffer;
-    decodeU32(input: Buffer): number;
-    decodeU256(input: Buffer): bigint;
-    decode(input: Buffer): DecodedCompactInt;
+    encode(input: DecodedCompactInt): Uint8Array;
+    encodeU32(value: number): Uint8Array;
+    encodeU256(value: bigint): Uint8Array;
+    decodeU32(input: Uint8Array): number;
+    decodeU256(input: Uint8Array): bigint;
+    decode(input: Uint8Array): DecodedCompactInt;
     toU32(value: DecodedCompactInt): number;
     fromU32(value: number): DecodedCompactInt;
     toU256(value: DecodedCompactInt): bigint;
@@ -37,12 +36,12 @@ export declare class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
     private twoByteBound;
     private fourByteBound;
     parser: Parser;
-    encode(input: DecodedCompactInt): Buffer;
-    decode(input: Buffer): DecodedCompactInt;
-    decodeI32(input: Buffer): number;
-    encodeI32(value: number): Buffer;
-    encodeI256(value: bigint): Buffer;
-    decodeI256(input: Buffer): bigint;
+    encode(input: DecodedCompactInt): Uint8Array;
+    decode(input: Uint8Array): DecodedCompactInt;
+    decodeI32(input: Uint8Array): number;
+    encodeI32(value: number): Uint8Array;
+    encodeI256(value: bigint): Uint8Array;
+    decodeI256(input: Uint8Array): bigint;
     toI32(value: DecodedCompactInt): number;
     fromI32(value: number): DecodedCompactInt;
     toI256(value: DecodedCompactInt): bigint;

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,7 +99,7 @@ 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) {
@@ -114,7 +114,7 @@ class CompactUnsignedIntCodec {
         return this.parser.parse(input);
     }
     toU32(value) {
-        const body = buffer_1.Buffer.from([value.mode, ...value.rest]);
+        const body = new Uint8Array([value.mode, ...value.rest]);
         return decodePositiveInt(value.mode, body);
     }
     fromU32(value) {
@@ -127,7 +127,7 @@ class CompactUnsignedIntCodec {
         }
         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 +145,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 +157,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 +171,7 @@ class CompactSignedIntCodec {
                 ]);
             }
             else {
-                return buffer_1.Buffer.from([
+                return new Uint8Array([
                     CompactInt.multiBytePrefix,
                     (value >> 24) & 0xff,
                     (value >> 16) & 0xff,
@@ -182,13 +182,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 +196,7 @@ class CompactSignedIntCodec {
                 ]);
             }
             else {
-                return buffer_1.Buffer.from([
+                return new Uint8Array([
                     CompactInt.multiBytePrefix,
                     (value >> 24) & 0xff,
                     (value >> 16) & 0xff,
@@ -213,7 +213,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 +221,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 +251,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 +273,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;