@alephium/web3 0.41.0 → 0.43.0

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 { 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':

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/transaction/index.ts

@@ -18,3 +18,4 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 export * from './status'
 export * from './sign-verify'
+export * from './utils'

package/src/transaction/utils.ts

@@ -0,0 +1,38 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { node } from '../api'
+import { getCurrentNodeProvider } from '../global'
+
+function isConfirmed(txStatus: node.TxStatus): txStatus is node.Confirmed {
+  return txStatus.type === 'Confirmed'
+}
+
+export async function waitForTxConfirmation(
+  txId: string,
+  confirmations: number,
+  requestInterval: number
+): Promise<node.Confirmed> {
+  const provider = getCurrentNodeProvider()
+  const status = await provider.transactions.getTransactionsStatus({ txId: txId })
+  if (isConfirmed(status) && status.chainConfirmations >= confirmations) {
+    return status
+  }
+  await new Promise((r) => setTimeout(r, requestInterval))
+  return waitForTxConfirmation(txId, confirmations, requestInterval)
+}

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,9 +37,7 @@ module.exports = {
     fallback: {
       fs: false,
       stream: require.resolve('stream-browserify'),
-      crypto: require.resolve('crypto-browserify'),
-      path: require.resolve('path-browserify'),
-      buffer: require.resolve('buffer/')
+      crypto: require.resolve('crypto-browserify')
     }
   },
   output: {

package/dist/src/utils/error.d.ts

@@ -1,15 +0,0 @@
-declare class CompilationError {
-    lineStart: number;
-    column: number;
-    errorType: string;
-    line: number;
-    codeLine: string;
-    errorIndicator: string;
-    message: string;
-    additionalLine1?: string | undefined;
-    additionalLine2?: string | undefined;
-    constructor(lineStart: number, column: number, errorType: string, line: number, codeLine: string, errorIndicator: string, message: string, additionalLine1?: string | undefined, additionalLine2?: string | undefined);
-    reformat(line: number, file: string): string;
-}
-export declare function parseError(error: string): CompilationError | undefined;
-export {};

package/dist/src/utils/error.js

@@ -1,66 +0,0 @@
-"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/>.
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseError = void 0;
-class CompilationError {
-    constructor(lineStart, column, errorType, line, codeLine, errorIndicator, message, additionalLine1, additionalLine2) {
-        this.lineStart = lineStart;
-        this.column = column;
-        this.errorType = errorType;
-        this.line = line;
-        this.codeLine = codeLine;
-        this.errorIndicator = errorIndicator;
-        this.message = message;
-        this.additionalLine1 = additionalLine1;
-        this.additionalLine2 = additionalLine2;
-    }
-    reformat(line, file) {
-        const spaces = `${line}`.replace(/\d/g, ' ');
-        const newError = `${file} (${line}:${this.column}): ${this.errorType}
-${line} |${this.codeLine}
-${spaces} |${this.errorIndicator}
-${spaces} |${this.message}`;
-        if (this.additionalLine1 && this.additionalLine2) {
-            return `${newError}\n${spaces} |${this.additionalLine1}\n${spaces} |${this.additionalLine2}`;
-        }
-        else {
-            return newError;
-        }
-    }
-}
-const errorRegex = /error \((\d+):(\d+)\):\s*(.*)\n\s*(\d+)\s*\|(.*)\n.*\|(.*)\n\s*\|(.*)(?:\n\s*\|(.*)\n\s*\|(.*))?/;
-function parseError(error) {
-    const match = error.match(errorRegex);
-    if (match) {
-        const lineStart = parseInt(match[1]);
-        const column = parseInt(match[2]);
-        const errorType = match[3];
-        const line = parseInt(match[4]);
-        const codeLine = match[5];
-        const errorIndicator = match[6];
-        const message = match[7];
-        const additionalLine1 = match[8];
-        const additionalLine2 = match[9];
-        return new CompilationError(lineStart, column, errorType, line, codeLine, errorIndicator, message, additionalLine1, additionalLine2);
-    }
-    else {
-        undefined;
-    }
-}
-exports.parseError = parseError;

package/src/utils/error.ts

@@ -1,77 +0,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/>.
-*/
-
-class CompilationError {
-  constructor(
-    public lineStart: number,
-    public column: number,
-    public errorType: string,
-    public line: number,
-    public codeLine: string,
-    public errorIndicator: string,
-    public message: string,
-    public additionalLine1?: string,
-    public additionalLine2?: string
-  ) {}
-
-  reformat(line: number, file: string): string {
-    const spaces = `${line}`.replace(/\d/g, ' ')
-    const newError = `${file} (${line}:${this.column}): ${this.errorType}
-${line} |${this.codeLine}
-${spaces} |${this.errorIndicator}
-${spaces} |${this.message}`
-
-    if (this.additionalLine1 && this.additionalLine2) {
-      return `${newError}\n${spaces} |${this.additionalLine1}\n${spaces} |${this.additionalLine2}`
-    } else {
-      return newError
-    }
-  }
-}
-
-const errorRegex = /error \((\d+):(\d+)\):\s*(.*)\n\s*(\d+)\s*\|(.*)\n.*\|(.*)\n\s*\|(.*)(?:\n\s*\|(.*)\n\s*\|(.*))?/
-
-export function parseError(error: string): CompilationError | undefined {
-  const match = error.match(errorRegex)
-
-  if (match) {
-    const lineStart = parseInt(match[1])
-    const column = parseInt(match[2])
-    const errorType = match[3]
-    const line = parseInt(match[4])
-    const codeLine = match[5]
-    const errorIndicator = match[6]
-    const message = match[7]
-    const additionalLine1 = match[8]
-    const additionalLine2 = match[9]
-
-    return new CompilationError(
-      lineStart,
-      column,
-      errorType,
-      line,
-      codeLine,
-      errorIndicator,
-      message,
-      additionalLine1,
-      additionalLine2
-    )
-  } else {
-    undefined
-  }
-}