@alephium/web3 0.42.0 → 0.44.0

package/src/contract/contract.ts

@@ -16,7 +16,6 @@ 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 { promises as fsPromises } from 'fs'
 import {
   fromApiNumber256,
@@ -41,25 +40,23 @@ import {
   SignDeployContractTxResult,
   SignExecuteScriptTxParams,
   SignerProvider,
-  Address
+  Address,
+  SignExecuteScriptTxResult
 } from '../signer'
 import * as ralph from './ralph'
 import {
   bs58,
   binToHex,
-  contractIdFromAddress,
   Subscription,
   assertType,
   Eq,
   Optional,
-  groupOfAddress,
   WebCrypto,
   hexToBinUnsafe,
   isDevnet,
-  addressFromContractId,
-  subContractId,
   HexString
 } from '../utils'
+import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId } from '../address'
 import { getCurrentNodeProvider } from '../global'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
@@ -67,6 +64,8 @@ import * as blake from 'blakejs'
 import { isContractDebugMessageEnabled } from '../debug'
 import {
   contract,
+  compactUnsignedIntCodec,
+  compactSignedIntCodec,
   Method,
   LoadLocal,
   LoadImmFieldByIndex,
@@ -76,7 +75,19 @@ import {
   ByteVecEq,
   Assert,
   StoreMutFieldByIndex,
-  DestroySelf
+  DestroySelf,
+  Pop,
+  byteStringCodec,
+  StoreLocal,
+  instrCodec,
+  U256Const,
+  Instr,
+  ApproveToken,
+  ApproveAlph,
+  CallExternal,
+  Dup,
+  CallerAddress,
+  ByteConst
 } from '../codec'
 
 const crypto = new WebCrypto()
@@ -220,7 +231,7 @@ export class Contract extends Artifact {
     this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
     this.codeHashDebug = codeHashDebug
 
-    this.decodedMethods = contract.contractCodec.decodeContract(Buffer.from(bytecode, 'hex')).methods
+    this.decodedMethods = contract.contractCodec.decodeContract(hexToBinUnsafe(bytecode)).methods
   }
 
   publicFunctions(): FunctionSig[] {
@@ -1047,6 +1058,15 @@ export interface CallContractResult<R> {
   debugMessages: DebugMessage[]
 }
 
+export interface SignExecuteContractMethodParams<T extends Arguments = Arguments> {
+  args: T
+  signer: SignerProvider
+  attoAlphAmount?: Number256
+  tokens?: Token[]
+  gasAmount?: number
+  gasPrice?: Number256
+}
+
 function specialContractAddress(eventIndex: number, groupIndex: number): string {
   const bytes = new Uint8Array(32).fill(0)
   bytes[30] = eventIndex
@@ -1208,7 +1228,7 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
     fieldLength: immFields + mutFields + 1, // parentContractId
     methods: [loadImmFieldByIndex, loadMutFieldByIndex, storeMutFieldByIndex, destroy]
   }
-  const bytecode = contract.contractCodec.encode(contract.toHalfDecoded(c))
+  const bytecode = contract.contractCodec.encodeContract(c)
   const codeHash = blake.blake2b(bytecode, undefined, 32)
   return { bytecode: binToHex(bytecode), codeHash: binToHex(codeHash) }
 }
@@ -1610,6 +1630,251 @@ export async function callMethod<I extends ContractInstance, F extends Fields, A
   return callResult as CallContractResult<R>
 }
 
+export async function signExecuteMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(
+  contract: ContractFactory<I, F>,
+  instance: ContractInstance,
+  methodName: string,
+  params: Optional<SignExecuteContractMethodParams<A>, 'args'>
+): Promise<SignExecuteScriptTxResult> {
+  const methodIndex = contract.contract.getMethodIndex(methodName)
+  const functionSig = contract.contract.functions[methodIndex]
+  const usePreapprovedAssets = contract.contract.decodedMethods[methodIndex].usePreapprovedAssets
+  const bytecodeTemplate = getBytecodeTemplate(
+    methodIndex,
+    usePreapprovedAssets,
+    functionSig,
+    contract.contract.structs,
+    params.attoAlphAmount,
+    params.tokens
+  )
+
+  const fieldsSig = toFieldsSig(contract.contract.name, functionSig)
+  const bytecode = ralph.buildScriptByteCode(
+    bytecodeTemplate,
+    { __contract__: instance.contractId, ...params.args },
+    fieldsSig,
+    contract.contract.structs
+  )
+
+  const signer = params.signer
+  const selectedAccount = await signer.getSelectedAccount()
+  const signerParams: SignExecuteScriptTxParams = {
+    signerAddress: selectedAccount.address,
+    signerKeyType: selectedAccount.keyType,
+    bytecode: bytecode,
+    attoAlphAmount: params.attoAlphAmount,
+    tokens: params.tokens,
+    gasAmount: params.gasAmount,
+    gasPrice: params.gasPrice
+  }
+
+  return await signer.signAndSubmitExecuteScriptTx(signerParams)
+}
+
+function getBytecodeTemplate(
+  methodIndex: number,
+  usePreapprovedAssets: boolean,
+  functionSig: FunctionSig,
+  structs: Struct[],
+  attoAlphAmount?: Number256,
+  tokens?: Token[]
+): string {
+  // For the default TxScript main function
+  const numberOfMethods = '01'
+  const isPublic = '01'
+  const modifier = usePreapprovedAssets ? '03' : '00'
+  const argsLength = '00'
+  const returnsLength = '00'
+
+  const [templateVarStoreLocalInstrs, templateVarsLength] = getTemplateVarStoreLocalInstrs(functionSig, structs)
+
+  const approveAlphInstrs: string[] = getApproveAlphInstrs(usePreapprovedAssets ? attoAlphAmount : undefined)
+  const approveTokensInstrs: string[] = getApproveTokensInstrs(usePreapprovedAssets ? tokens : undefined)
+  const callerInstrs: string[] = getCallAddressInstrs(approveAlphInstrs.length / 2 + approveTokensInstrs.length / 3)
+
+  // First template var is the contract
+  const functionArgsNum = encodeU256Const(BigInt(templateVarsLength - 1))
+  const localsLength = encodeI32(templateVarStoreLocalInstrs.length / 2)
+
+  const templateVarLoadLocalInstrs = getTemplateVarLoadLocalInstrs(functionSig, structs)
+
+  const functionReturnTypesLength: number = functionSig.returnTypes.reduce(
+    (acc, returnType) => acc + ralph.typeLength(returnType, structs),
+    0
+  )
+  const functionReturnPopInstrs = encodeInstr(Pop).repeat(functionReturnTypesLength)
+  const functionReturnNum = encodeU256Const(BigInt(functionReturnTypesLength))
+
+  const contractTemplateVar = '{0}' // always the 1st argument
+  const externalCallInstr = encodeInstr(CallExternal(methodIndex))
+  const numberOfInstrs = encodeI32(
+    callerInstrs.length +
+      approveAlphInstrs.length +
+      approveTokensInstrs.length +
+      templateVarStoreLocalInstrs.length +
+      templateVarLoadLocalInstrs.length +
+      functionReturnTypesLength +
+      4 // functionArgsNum, functionReturnNum, contractTemplate, externalCallInstr
+  )
+
+  return (
+    numberOfMethods +
+    isPublic +
+    modifier +
+    argsLength +
+    localsLength +
+    returnsLength +
+    numberOfInstrs +
+    callerInstrs.join('') +
+    approveAlphInstrs.join('') +
+    approveTokensInstrs.join('') +
+    templateVarStoreLocalInstrs.join('') +
+    templateVarLoadLocalInstrs.join('') +
+    functionArgsNum +
+    functionReturnNum +
+    contractTemplateVar +
+    externalCallInstr +
+    functionReturnPopInstrs
+  )
+}
+
+function getApproveAlphInstrs(attoAlphAmount?: Number256): string[] {
+  const approveAlphInstrs: string[] = []
+  if (attoAlphAmount) {
+    const approvedAttoAlphAmount = encodeU256Const(BigInt(attoAlphAmount))
+    approveAlphInstrs.push(approvedAttoAlphAmount)
+    approveAlphInstrs.push(encodeInstr(ApproveAlph))
+  }
+
+  return approveAlphInstrs
+}
+
+function getApproveTokensInstrs(tokens?: Token[]): string[] {
+  const approveTokensInstrs: string[] = []
+  if (tokens) {
+    tokens.forEach((token) => {
+      const tokenIdBin = hexToBinUnsafe(token.id)
+      approveTokensInstrs.push(
+        encodeInstr(
+          ByteConst({
+            length: compactSignedIntCodec.fromI32(tokenIdBin.length),
+            value: tokenIdBin
+          })
+        )
+      )
+      approveTokensInstrs.push(encodeU256Const(BigInt(token.amount)))
+      approveTokensInstrs.push(encodeInstr(ApproveToken))
+    })
+  }
+
+  return approveTokensInstrs
+}
+
+function getCallAddressInstrs(approveAssetsNum: number): string[] {
+  const callerInstrs: string[] = []
+  if (approveAssetsNum > 0) {
+    callerInstrs.push(encodeInstr(CallerAddress))
+
+    const dup = encodeInstr(Dup)
+    if (approveAssetsNum > 1) {
+      callerInstrs.push(...new Array(approveAssetsNum - 1).fill(dup))
+    }
+  }
+
+  return callerInstrs
+}
+
+function getTemplateVarStoreLocalInstrs(functionSig: FunctionSig, structs: Struct[]): [string[], number] {
+  let templateVarIndex = 1 // Start from 1 since first one is always the contract id
+  let localsLength = 0
+  const templateVarStoreInstrs: string[] = []
+  functionSig.paramTypes.forEach((paramType) => {
+    const fieldsLength = ralph.typeLength(paramType, structs)
+    if (fieldsLength > 1) {
+      for (let i = 0; i < fieldsLength; i++) {
+        templateVarStoreInstrs.push(`{${templateVarIndex + i}}`)
+      }
+      for (let i = 0; i < fieldsLength; i++) {
+        templateVarStoreInstrs.push(encodeStoreLocalInstr(localsLength + (fieldsLength - i - 1)))
+      }
+
+      localsLength = localsLength + fieldsLength
+    }
+
+    templateVarIndex = templateVarIndex + fieldsLength
+  })
+
+  return [templateVarStoreInstrs, templateVarIndex]
+}
+
+function getTemplateVarLoadLocalInstrs(functionSig: FunctionSig, structs: Struct[]): string[] {
+  let templateVarIndex = 1
+  let loadIndex = 0
+  const templateVarLoadInstrs: string[] = []
+  functionSig.paramTypes.forEach((paramType) => {
+    const fieldsLength = ralph.typeLength(paramType, structs)
+
+    if (fieldsLength === 1) {
+      templateVarLoadInstrs.push(`{${templateVarIndex}}`)
+    }
+
+    if (fieldsLength > 1) {
+      for (let i = 0; i < fieldsLength; i++) {
+        templateVarLoadInstrs.push(encodeLoadLocalInstr(loadIndex + i))
+      }
+
+      loadIndex = loadIndex + fieldsLength
+    }
+
+    templateVarIndex = templateVarIndex + fieldsLength
+  })
+
+  return templateVarLoadInstrs
+}
+
+function encodeStoreLocalInstr(index: number): string {
+  if (index < 0 || index > 0xff) {
+    throw new Error(`StoreLocal index ${index} must be between 0 and 255 inclusive`)
+  }
+  return encodeInstr(StoreLocal(index))
+}
+
+function encodeLoadLocalInstr(index: number): string {
+  if (index < 0 || index > 0xff) {
+    throw new Error(`LoadLocal index ${index} must be between 0 and 255 inclusive`)
+  }
+
+  return encodeInstr(LoadLocal(index))
+}
+
+function encodeI32(value: number): string {
+  return binToHex(compactSignedIntCodec.encodeI32(value))
+}
+
+function encodeU256Const(value: bigint): string {
+  if (value < 0) {
+    throw new Error(`value ${value} must be non-negative`)
+  }
+
+  if (value < 6) {
+    return (BigInt(0x0c) + value).toString(16).padStart(2, '0')
+  } else {
+    return encodeInstr(U256Const(compactUnsignedIntCodec.fromU256(BigInt(value))))
+  }
+}
+
+function encodeInstr(instr: Instr): string {
+  return binToHex(instrCodec.encode(instr))
+}
+
+function toFieldsSig(contractName: string, functionSig: FunctionSig): FieldsSig {
+  return {
+    names: ['__contract__'].concat(functionSig.paramNames),
+    types: [contractName].concat(functionSig.paramTypes),
+    isMutable: [false].concat(functionSig.paramIsMutable)
+  }
+}
+
 export async function multicallMethods<I extends ContractInstance, F extends Fields>(
   contract: ContractFactory<I, F>,
   instance: ContractInstance,

package/src/contract/ralph.ts

@@ -16,9 +16,8 @@ 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 { Val, decodeArrayType, toApiAddress, toApiBoolean, toApiByteVec, toApiNumber256 } from '../api'
-import { HexString, binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
+import { Val, decodeArrayType, toApiAddress, toApiBoolean, toApiByteVec, toApiNumber256, PrimitiveTypes } from '../api'
+import { HexString, binToHex, bs58, concatBytes, hexToBinUnsafe, isHexString } from '../utils'
 import { Fields, FieldsSig, Struct } from './contract'
 import { compactSignedIntCodec, compactUnsignedIntCodec } from '../codec'
 
@@ -151,14 +150,14 @@ export function encodeU256(u256: bigint): Uint8Array {
   }
 }
 
-export function encodeByteVec(bytes: string): Uint8Array {
-  if (!isHexString(bytes)) {
-    throw Error(`Given value ${bytes} is not a valid hex string`)
+export function encodeByteVec(hex: string): Uint8Array {
+  if (!isHexString(hex)) {
+    throw Error(`Given value ${hex} is not a valid hex string`)
   }
 
-  const buffer0 = Buffer.from(bytes, 'hex')
-  const buffer1 = Buffer.from(encodeI256(BigInt(buffer0.length)))
-  return Buffer.concat([buffer1, buffer0])
+  const bytes0 = hexToBinUnsafe(hex)
+  const bytes1 = encodeI256(BigInt(bytes0.length))
+  return concatBytes([bytes1, bytes0])
 }
 
 export function encodeAddress(address: string): Uint8Array {
@@ -254,7 +253,7 @@ function encodeScriptFieldU256(value: bigint): Uint8Array {
 }
 
 export function encodeScriptFieldAsString(tpe: string, value: Val): string {
-  return Buffer.from(encodeScriptField(tpe, value)).toString('hex')
+  return binToHex(encodeScriptField(tpe, value))
 }
 
 export function encodeScriptField(tpe: string, value: Val): Uint8Array {
@@ -378,9 +377,9 @@ export function decodePrimitive(value: Uint8Array, type: string): Val {
     case 'Bool':
       return decodeBool(value)
     case 'I256':
-      return compactSignedIntCodec.decodeI256(Buffer.from(value))
+      return compactSignedIntCodec.decodeI256(value)
     case 'U256':
-      return compactUnsignedIntCodec.decodeU256(Buffer.from(value))
+      return compactUnsignedIntCodec.decodeU256(value)
     case 'ByteVec':
       return binToHex(value)
     case 'Address':
@@ -412,6 +411,24 @@ export function primitiveToByteVec(value: Val, type: string): Uint8Array {
   }
 }
 
+export function typeLength(typ: string, structs: Struct[]): number {
+  if (PrimitiveTypes.includes(typ)) {
+    return 1
+  }
+
+  if (typ.startsWith('[')) {
+    const [baseType, size] = decodeArrayType(typ)
+    return size * typeLength(baseType, structs)
+  }
+
+  const struct = structs.find((s) => s.name === typ)
+  if (struct !== undefined) {
+    return struct.fieldTypes.reduce((acc, fieldType) => acc + typeLength(fieldType, structs), 0)
+  }
+
+  return 1
+}
+
 export function flattenFields(
   fields: Fields,
   names: string[],

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

@@ -16,19 +16,11 @@ 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 {
-  AddressType,
-  addressFromPublicKey,
-  addressFromScript,
-  binToHex,
-  bs58,
-  hexToBinUnsafe,
-  isHexString
-} from '../utils'
+import { AddressType, addressFromPublicKey, addressFromScript } from '../address'
+import { binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
 import { Transaction } from '../api/api-alephium'
 import { Address } from '../signer'
 import { P2SH, unlockScriptCodec } from '../codec/unlock-script-codec'
-import { Buffer } from 'buffer/'
 import { scriptCodec } from '../codec/script-codec'
 
 export function validateExchangeAddress(address: string) {
@@ -113,7 +105,7 @@ export function getAddressFromUnlockScript(unlockScript: string): Address {
   if (unlockScriptType === UnlockScriptType.P2SH) {
     let p2sh: P2SH
     try {
-      p2sh = unlockScriptCodec.decode(Buffer.from(decoded)).script as P2SH
+      p2sh = unlockScriptCodec.decode(decoded).script as P2SH
     } catch (_) {
       throw new Error(`Invalid p2sh unlock script: ${unlockScript}`)
     }

package/src/exchange/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 { validateExchangeAddress, isALPHTransferTx, getSenderAddress, getALPHDepositInfo } from './exchange'

package/src/index.ts

@@ -33,3 +33,5 @@ export * as codec from './codec'
 export * as utils from './utils'
 export * from './debug'
 export * from './block'
+export * from './address'
+export * from './exchange'

package/src/signer/signer.ts

@@ -16,7 +16,6 @@ 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 { createHash } from 'crypto'
 import { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, toApiTokens } from '../api'
 import { node } from '../api'
@@ -44,7 +43,7 @@ import {
   MessageHasher
 } from './types'
 import { TransactionBuilder } from './tx-builder'
-import { addressFromPublicKey, groupOfAddress } from '../utils'
+import { addressFromPublicKey, groupOfAddress } from '../address'
 
 export abstract class SignerProvider {
   abstract get nodeProvider(): NodeProvider | undefined
@@ -254,7 +253,7 @@ export function hashMessage(message: string, hasher: MessageHasher): string {
       return utils.binToHex(blake.blake2b(extendMessage(message), undefined, 32))
     case 'sha256':
       const sha256 = createHash('sha256')
-      sha256.update(Buffer.from(message))
+      sha256.update(new TextEncoder().encode(message))
       return utils.binToHex(sha256.digest())
     case 'blake2b':
       return utils.binToHex(blake.blake2b(message, undefined, 32))

package/src/signer/tx-builder.ts

@@ -16,9 +16,9 @@ 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 { binToHex, contractIdFromAddress } from '../utils'
+import { binToHex } from '../utils'
 import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiTokens } from '../api'
-import { addressFromPublicKey } from '../utils'
+import { addressFromPublicKey, contractIdFromAddress } from '../address'
 import { toApiDestinations } from './signer'
 import {
   KeyType,

package/src/utils/index.ts

@@ -17,11 +17,9 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 export * from './webcrypto'
-export * from './address'
 export * from './bs58'
 export * from './djb2'
 export * from './utils'
 export * from './subscription'
 export * from './sign'
 export * from './number'
-export { validateExchangeAddress, isALPHTransferTx, getSenderAddress, getALPHDepositInfo } from './exchange'

package/src/utils/sign.ts

@@ -31,7 +31,7 @@ necc.utils.sha256Sync = (...messages: Uint8Array[]): Uint8Array => {
 }
 
 necc.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8Array => {
-  const hash = createHmac('sha256', Buffer.from(key))
+  const hash = createHmac('sha256', key)
   messages.forEach((m) => hash.update(m))
   return Uint8Array.from(hash.digest())
 }

package/src/utils/utils.ts

@@ -18,8 +18,6 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { ec as EC, SignatureInput } from 'elliptic'
 import BN from 'bn.js'
-import { Buffer } from 'buffer/'
-
 import { TOTAL_NUMBER_OF_GROUPS, TOTAL_NUMBER_OF_CHAINS } from '../constants'
 
 export const networkIds = ['mainnet', 'testnet', 'devnet'] as const
@@ -73,11 +71,17 @@ export function toNonNegativeBigInt(input: string): bigint | undefined {
 }
 
 export function hexToBinUnsafe(hex: string): Uint8Array {
-  return Buffer.from(hex, 'hex')
+  const bytes: number[] = []
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes.push(parseInt(hex.slice(i, i + 2), 16))
+  }
+  return new Uint8Array(bytes)
 }
 
 export function binToHex(bin: Uint8Array): string {
-  return Buffer.from(bin).toString('hex')
+  return Array.from(bin)
+    .map((byte) => byte.toString(16).padStart(2, '0'))
+    .join('')
 }
 
 export function blockChainIndex(blockHash: HexString): { fromGroup: number; toGroup: number } {
@@ -101,7 +105,8 @@ export function hexToString(str: string): string {
   if (!isHexString(str)) {
     throw new Error(`Invalid hex string: ${str}`)
   }
-  return Buffer.from(str, 'hex').toString()
+  const bytes = hexToBinUnsafe(str)
+  return new TextDecoder().decode(bytes)
 }
 
 export function sleep(ms: number): Promise<void> {
@@ -127,14 +132,28 @@ export function difficultyToTarget(diff: bigint): HexString {
   const maxBigInt = 1n << 256n
   const target = diff === 1n ? maxBigInt - 1n : maxBigInt / diff
   const size = Math.floor((target.toString(2).length + 7) / 8)
-  const mantissa =
+  const mantissa = Number(
     size <= 3
       ? BigInt.asIntN(32, target) << BigInt(8 * (3 - size))
       : BigInt.asIntN(32, target >> BigInt(8 * (size - 3)))
-  const mantissaBytes = Buffer.alloc(4)
-  mantissaBytes.writeInt32BE(Number(mantissa), 0)
-  const bytes = new Uint8Array([size, ...mantissaBytes.slice(1)])
-  return binToHex(bytes)
+  )
+  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)
+}
+
+export function concatBytes(arrays: Uint8Array[]): Uint8Array {
+  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
 }
 
 type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false

package/src/utils/webcrypto.ts

@@ -16,7 +16,6 @@ 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 { webcrypto, randomFillSync } from 'crypto'
 
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined'
@@ -30,12 +29,12 @@ export class WebCrypto {
         "Failed to execute 'getRandomValues' on 'Crypto': parameter 1 is not of type 'ArrayBufferView'"
       )
     }
-    const buffer = 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 {
-      randomFillSync(buffer)
+      randomFillSync(bytes)
     }
     return array
   }

package/webpack.config.js

@@ -25,9 +25,6 @@ module.exports = {
   },
   plugins: [
     new webpack.SourceMapDevToolPlugin({ filename: '[file].map' }),
-    new webpack.ProvidePlugin({
-      Buffer: ['buffer', 'Buffer']
-    }),
     new webpack.IgnorePlugin({
       checkResource(resource) {
         // The "bip39/src/wordlists" node module consists of json files for multiple languages. We only need English.
@@ -40,8 +37,7 @@ module.exports = {
     fallback: {
       fs: false,
       stream: require.resolve('stream-browserify'),
-      crypto: require.resolve('crypto-browserify'),
-      buffer: require.resolve('buffer/')
+      crypto: require.resolve('crypto-browserify')
     }
   },
   output: {