@alephium/web3 0.42.0 → 0.44.0

package/dist/src/utils/utils.js

@@ -20,10 +20,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertType = exports.difficultyToTarget = exports.targetToDifficulty = exports.isDevnet = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.binToHex = exports.hexToBinUnsafe = exports.toNonNegativeBigInt = exports.isHexString = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = void 0;
+exports.assertType = exports.concatBytes = exports.difficultyToTarget = exports.targetToDifficulty = exports.isDevnet = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.binToHex = exports.hexToBinUnsafe = exports.toNonNegativeBigInt = exports.isHexString = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = void 0;
 const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
-const buffer_1 = require("buffer/");
 const constants_1 = require("../constants");
 exports.networkIds = ['mainnet', 'testnet', 'devnet'];
 const ec = new elliptic_1.ec('secp256k1');
@@ -72,11 +71,17 @@ function toNonNegativeBigInt(input) {
 }
 exports.toNonNegativeBigInt = toNonNegativeBigInt;
 function hexToBinUnsafe(hex) {
-    return buffer_1.Buffer.from(hex, 'hex');
+    const bytes = [];
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes.push(parseInt(hex.slice(i, i + 2), 16));
+    }
+    return new Uint8Array(bytes);
 }
 exports.hexToBinUnsafe = hexToBinUnsafe;
 function binToHex(bin) {
-    return buffer_1.Buffer.from(bin).toString('hex');
+    return Array.from(bin)
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
 }
 exports.binToHex = binToHex;
 function blockChainIndex(blockHash) {
@@ -99,7 +104,8 @@ function hexToString(str) {
     if (!isHexString(str)) {
         throw new Error(`Invalid hex string: ${str}`);
     }
-    return buffer_1.Buffer.from(str, 'hex').toString();
+    const bytes = hexToBinUnsafe(str);
+    return new TextDecoder().decode(bytes);
 }
 exports.hexToString = hexToString;
 function sleep(ms) {
@@ -125,15 +131,28 @@ function difficultyToTarget(diff) {
     const maxBigInt = 1n << 256n;
     const target = diff === 1n ? maxBigInt - 1n : maxBigInt / diff;
     const size = Math.floor((target.toString(2).length + 7) / 8);
-    const mantissa = size <= 3
+    const mantissa = Number(size <= 3
         ? BigInt.asIntN(32, target) << BigInt(8 * (3 - size))
-        : BigInt.asIntN(32, target >> BigInt(8 * (size - 3)));
-    const mantissaBytes = buffer_1.Buffer.alloc(4);
-    mantissaBytes.writeInt32BE(Number(mantissa), 0);
-    const bytes = new Uint8Array([size, ...mantissaBytes.slice(1)]);
-    return binToHex(bytes);
+        : BigInt.asIntN(32, target >> BigInt(8 * (size - 3))));
+    const mantissaBytes = new Uint8Array(4);
+    mantissaBytes[0] = size;
+    mantissaBytes[1] = (mantissa >> 16) & 0xff;
+    mantissaBytes[2] = (mantissa >> 8) & 0xff;
+    mantissaBytes[3] = mantissa & 0xff;
+    return binToHex(mantissaBytes);
 }
 exports.difficultyToTarget = difficultyToTarget;
+function concatBytes(arrays) {
+    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+}
+exports.concatBytes = concatBytes;
 // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
 function assertType() { }
 exports.assertType = assertType;

package/dist/src/utils/webcrypto.js

@@ -18,7 +18,6 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebCrypto = void 0;
-const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 class WebCrypto {
@@ -29,12 +28,12 @@ class WebCrypto {
         if (!ArrayBuffer.isView(array)) {
             throw new TypeError("Failed to execute 'getRandomValues' on 'Crypto': parameter 1 is not of type 'ArrayBufferView'");
         }
-        const buffer = buffer_1.Buffer.from(array.buffer, array.byteOffset, array.byteLength);
+        const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
         if (isBrowser) {
-            globalThis.crypto.getRandomValues(buffer);
+            globalThis.crypto.getRandomValues(bytes);
         }
         else {
-            (0, crypto_1.randomFillSync)(buffer);
+            (0, crypto_1.randomFillSync)(bytes);
         }
         return array;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -37,7 +37,6 @@
     "bignumber.js": "^9.1.1",
     "blakejs": "1.2.1",
     "bn.js": "5.2.1",
-    "buffer": "^6.0.3",
     "cross-fetch": "^3.1.5",
     "crypto-browserify": "^3.12.0",
     "elliptic": "6.5.4",

package/src/{utils → address}/address.ts

@@ -20,12 +20,11 @@ import { ec as EC } from 'elliptic'
 import BN from 'bn.js'
 import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import blake from 'blakejs'
-import bs58 from './bs58'
-import djb2 from './djb2'
-import { binToHex, hexToBinUnsafe } from './utils'
+import bs58 from '../utils/bs58'
+import djb2 from '../utils/djb2'
+import { binToHex, concatBytes, hexToBinUnsafe } from '../utils'
 import { KeyType } from '../signer'
 import { MultiSig, lockupScriptCodec } from '../codec/lockup-script-codec'
-import { Buffer } from 'buffer/'
 import { compactSignedIntCodec } from '../codec'
 
 const ec = new EC('secp256k1')
@@ -54,7 +53,7 @@ function decodeAndValidateAddress(address: string): Uint8Array {
   if (addressType === AddressType.P2MPKH) {
     let multisig: MultiSig
     try {
-      multisig = lockupScriptCodec.decode(Buffer.from(decoded)).script as MultiSig
+      multisig = lockupScriptCodec.decode(decoded).script as MultiSig
     } catch (_) {
       throw new Error(`Invalid multisig address: ${address}`)
     }
@@ -163,26 +162,23 @@ export function addressFromPublicKey(publicKey: string, _keyType?: KeyType): str
   const keyType = _keyType ?? 'default'
 
   if (keyType === 'default') {
-    const addressType = Buffer.from([AddressType.P2PKH])
-    const hash = Buffer.from(blake.blake2b(Buffer.from(publicKey, 'hex'), undefined, 32))
-    const bytes = Buffer.concat([addressType, hash])
+    const hash = blake.blake2b(hexToBinUnsafe(publicKey), undefined, 32)
+    const bytes = new Uint8Array([AddressType.P2PKH, ...hash])
     return bs58.encode(bytes)
   } else {
-    const lockupScript = Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex')
+    const lockupScript = hexToBinUnsafe(`0101000000000458144020${publicKey}8685`)
     return addressFromScript(lockupScript)
   }
 }
 
 export function addressFromScript(script: Uint8Array): string {
   const scriptHash = blake.blake2b(script, undefined, 32)
-  const addressType = Buffer.from([AddressType.P2SH])
-  return bs58.encode(Buffer.concat([addressType, scriptHash]))
+  return bs58.encode(new Uint8Array([AddressType.P2SH, ...scriptHash]))
 }
 
 export function addressFromContractId(contractId: string): string {
-  const addressType = Buffer.from([AddressType.P2C])
-  const hash = Buffer.from(hexToBinUnsafe(contractId))
-  const bytes = Buffer.concat([addressType, hash])
+  const hash = hexToBinUnsafe(contractId)
+  const bytes = new Uint8Array([AddressType.P2C, ...hash])
   return bs58.encode(bytes)
 }
 
@@ -193,7 +189,7 @@ export function addressFromTokenId(tokenId: string): string {
 
 export function contractIdFromTx(txId: string, outputIndex: number): string {
   const txIdBin = hexToBinUnsafe(txId)
-  const data = Buffer.concat([txIdBin, Buffer.from([outputIndex])])
+  const data = new Uint8Array([...txIdBin, outputIndex])
   const hash = blake.blake2b(data, undefined, 32)
   return binToHex(hash)
 }
@@ -202,10 +198,10 @@ export function subContractId(parentContractId: string, pathInHex: string, group
   if (group < 0 || group >= TOTAL_NUMBER_OF_GROUPS) {
     throw new Error(`Invalid group ${group}`)
   }
-  const data = Buffer.concat([hexToBinUnsafe(parentContractId), hexToBinUnsafe(pathInHex)])
-  const bytes = Buffer.concat([
-    blake.blake2b(blake.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
-    Buffer.from([group])
+  const data = concatBytes([hexToBinUnsafe(parentContractId), hexToBinUnsafe(pathInHex)])
+  const bytes = new Uint8Array([
+    ...blake.blake2b(blake.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
+    group
   ])
   return binToHex(bytes)
 }

package/src/address/index.ts

@@ -0,0 +1,19 @@
+/*
+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 * from './address'

package/src/api/node-provider.ts

@@ -28,15 +28,8 @@ import {
   requestWithLog
 } from './types'
 import { Api as NodeApi, CallContractFailed, CallContractSucceeded } from './api-alephium'
-import {
-  HexString,
-  addressFromContractId,
-  addressFromTokenId,
-  groupOfAddress,
-  hexToString,
-  isHexString,
-  toNonNegativeBigInt
-} from '../utils'
+import { HexString, hexToString, isHexString, toNonNegativeBigInt } from '../utils'
+import { addressFromContractId, addressFromTokenId, groupOfAddress } from '../address'
 import * as node from '../api/api-alephium'
 
 function initializeNodeApi(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): NodeApi<string> {

package/src/api/types.ts

@@ -18,7 +18,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { ZERO_ADDRESS } from '../constants'
 import { isDebugModeEnabled } from '../debug'
-import { assertType, bs58, Eq, isBase58, isHexString } from '../utils'
+import { assertType, binToHex, bs58, Eq, isBase58, isHexString } from '../utils'
 import * as node from './api-alephium'
 
 export type Number256 = bigint | string
@@ -93,7 +93,7 @@ export function toApiByteVec(v: Val): string {
     try {
       const address = bs58.decode(v)
       if (address.length == 33 && address[0] == 3) {
-        return Buffer.from(address.slice(1)).toString('hex')
+        return binToHex(address.slice(1))
       }
     } catch (_) {
       throw new Error(`Invalid hex-string: ${v}`)

package/src/codec/array-codec.ts

@@ -15,9 +15,8 @@ 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 { compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
 import { Codec } from './codec'
 
 export interface DecodedArray<T> {
@@ -28,15 +27,15 @@ export interface DecodedArray<T> {
 export class ArrayCodec<T> implements Codec<T[]> {
   constructor(private childCodec: Codec<T>, public parser = ArrayCodec.arrayParser(childCodec.parser)) {}
 
-  encode(input: T[]): Buffer {
+  encode(input: T[]): Uint8Array {
     const result = [...compactSignedIntCodec.encodeI256(BigInt(input.length))]
     for (const element of input) {
       result.push(...this.childCodec.encode(element))
     }
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): T[] {
+  decode(input: Uint8Array): T[] {
     const result = this.parser.parse(input)
     return result.value.map((v) => this.childCodec.decode(v.value))
   }
@@ -56,7 +55,7 @@ export class ArrayCodec<T> implements Codec<T[]> {
 
   fromArray(inputs: T[]): DecodedArray<T> {
     return {
-      length: compactUnsignedIntCodec.fromU32(inputs.length),
+      length: compactSignedIntCodec.fromI32(inputs.length),
       value: inputs
     }
   }

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

@@ -15,17 +15,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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { DecodedCompactInt, compactSignedIntCodec, 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 { LockupScript, MultiSig, P2SH, lockupScriptCodec } from './lockup-script-codec'
 import { FixedAssetOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
-import { bs58, binToHex } from '../utils'
+import { bs58, binToHex, hexToBinUnsafe, concatBytes } from '../utils'
 import { Codec } from './codec'
 import { PublicKeyHash } from './lockup-script-codec'
 import { Token, tokensCodec } from './token-codec'
@@ -33,7 +32,7 @@ import { Token, tokensCodec } from './token-codec'
 export interface AssetOutput {
   amount: DecodedCompactInt
   lockupScript: LockupScript
-  lockTime: Buffer
+  lockTime: Uint8Array
   tokens: DecodedArray<Token>
   additionalData: ByteString
 }
@@ -41,7 +40,7 @@ export interface AssetOutput {
 export class AssetOutputCodec implements Codec<AssetOutput> {
   parser = Parser.start()
     .nest('amount', {
-      type: compactUnsignedIntCodec.parser
+      type: compactSignedIntCodec.parser
     })
     .nest('lockupScript', {
       type: lockupScriptCodec.parser
@@ -56,17 +55,16 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
       type: byteStringCodec.parser
     })
 
-  encode(input: AssetOutput): Buffer {
-    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
+  encode(input: AssetOutput): Uint8Array {
+    const amount = 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))
+    const tokens = tokensCodec.encode(input.tokens.value)
+    const additionalData = byteStringCodec.encode(input.additionalData)
 
-    return Buffer.concat([amount, lockupScript, lockTime, tokens, additionalData])
+    return concatBytes([amount, lockupScript, input.lockTime, tokens, additionalData])
   }
 
-  decode(input: Buffer): AssetOutput {
+  decode(input: Uint8Array): AssetOutput {
     return this.parser.parse(input)
   }
 
@@ -79,13 +77,13 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
     const lockTime = Number(longCodec.decode(output.lockTime))
     const tokens = output.tokens.value.map((token) => {
       return {
-        id: token.tokenId.toString('hex'),
+        id: binToHex(token.tokenId),
         amount: compactUnsignedIntCodec.toU256(token.amount).toString()
       }
     })
-    const message = output.additionalData.value.toString('hex')
+    const message = binToHex(output.additionalData.value)
     const scriptType = output.lockupScript.scriptType
-    const key = binToHex(blakeHash(Buffer.concat([txIdBytes, signedIntCodec.encode(index)])))
+    const key = binToHex(blakeHash(concatBytes([txIdBytes, signedIntCodec.encode(index)])))
     const outputLockupScript = output.lockupScript.script
     const address = bs58.encode(lockupScriptCodec.encode(output.lockupScript))
 
@@ -117,21 +115,21 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
   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 lockTime = longCodec.encode(BigInt(fixedOutput.lockTime))
+    const lockupScript: LockupScript = lockupScriptCodec.decode(bs58.decode(fixedOutput.address))
     const tokensValue = fixedOutput.tokens.map((token) => {
       return {
-        tokenId: Buffer.from(token.id, 'hex'),
+        tokenId: hexToBinUnsafe(token.id),
         amount: compactUnsignedIntCodec.fromU256(BigInt(token.amount))
       }
     })
     const tokens: DecodedArray<Token> = {
-      length: compactUnsignedIntCodec.fromU32(tokensValue.length),
+      length: compactSignedIntCodec.fromI32(tokensValue.length),
       value: tokensValue
     }
-    const additionalDataValue = Buffer.from(fixedOutput.message, 'hex')
+    const additionalDataValue = hexToBinUnsafe(fixedOutput.message)
     const additionalData: ByteString = {
-      length: compactUnsignedIntCodec.fromU32(additionalDataValue.length),
+      length: compactSignedIntCodec.fromI32(additionalDataValue.length),
       value: additionalDataValue
     }
 

package/src/codec/bigint-codec.ts

@@ -15,12 +15,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/>.
 */
-import { Buffer } from 'buffer/'
 export class BigIntCodec {
-  static encode(value: bigint): Buffer {
+  static encode(value: bigint): Uint8Array {
     // Special case for zero.
     if (value === 0n) {
-      return Buffer.from([0])
+      return new Uint8Array([0])
     }
 
     const isNegative = value < 0n
@@ -62,10 +61,10 @@ export class BigIntCodec {
     }
 
     // The byte array needs to be reversed since we've constructed it in little-endian order.
-    return Buffer.from(new Uint8Array(bytes.reverse()))
+    return new Uint8Array(bytes.reverse())
   }
 
-  static decode(encoded: Buffer, signed: boolean): bigint {
+  static decode(encoded: Uint8Array, signed: boolean): bigint {
     // Special case for zero.
     if (encoded.length === 1 && encoded[0] === 0) {
       return 0n

package/src/codec/bytestring-codec.ts

@@ -15,40 +15,40 @@ 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 { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
+import { concatBytes } from '../utils'
 
 export interface ByteString {
   length: DecodedCompactInt
-  value: Buffer
+  value: Uint8Array
 }
 
 export class ByteStringCodec implements Codec<ByteString> {
   parser = new Parser()
     .nest('length', {
-      type: compactUnsignedIntCodec.parser
+      type: compactSignedIntCodec.parser
     })
     .buffer('value', {
       length: function (ctx) {
-        return compactUnsignedIntCodec.toU32(this['length']! as any as DecodedCompactInt)
+        return compactSignedIntCodec.toI32(this['length']! as any as DecodedCompactInt)
       }
     })
 
-  encode(input: ByteString): Buffer {
-    return Buffer.from([...compactUnsignedIntCodec.encode(input.length), ...input.value])
+  encode(input: ByteString): Uint8Array {
+    return concatBytes([compactSignedIntCodec.encode(input.length), input.value])
   }
 
-  decode(input: Buffer): ByteString {
+  decode(input: Uint8Array): ByteString {
     return this.parser.parse(input)
   }
 
-  encodeBuffer(input: Buffer): Buffer {
-    return Buffer.from([...compactUnsignedIntCodec.encodeU32(input.length), ...input])
+  encodeBytes(input: Uint8Array): Uint8Array {
+    return concatBytes([compactSignedIntCodec.encodeI32(input.length), input])
   }
 
-  decodeBuffer(input: Buffer): Buffer {
+  decodeBytes(input: Uint8Array): Uint8Array {
     return this.decode(input).value
   }
 }

package/src/codec/codec.ts

@@ -15,13 +15,12 @@ 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
+  encode(input: T): Uint8Array
+  decode(input: Uint8Array): T
 }
 
 export function assert(value: boolean, message: string) {