@alephium/web3 0.5.0-rc.2 → 0.5.0-rc.20

package/src/utils/number.ts

@@ -0,0 +1,158 @@
+/*
+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/>.
+*/
+
+// Credits:
+// 1. https://github.com/argentlabs/argent-x/blob/e63affa7f28b27333dca4081a3dcd375bb2da40b/packages/extension/src/shared/utils/number.ts
+// 2. https://github.com/ethers-io/ethers.js/blob/724881f34d428406488a1c9f9dbebe54b6edecda/src.ts/utils/fixednumber.ts
+
+import BigNumber from 'bignumber.js'
+import { Number256 } from '..'
+
+export const isNumeric = (numToCheck: any): boolean => !isNaN(parseFloat(numToCheck)) && isFinite(numToCheck)
+
+export interface IPrettifyNumberConfig {
+  minDecimalPlaces: number
+  maxDecimalPlaces: number
+  /** significant digits to show in decimals while respecting decimal places */
+  minDecimalSignificantDigits: number
+  /** special case for zero, e.g. we may want to display $0.00 or 0.0 ALPH */
+  decimalPlacesWhenZero: number
+}
+
+export const prettifyNumberConfig: Record<string, IPrettifyNumberConfig> = {
+  ALPH: {
+    minDecimalPlaces: 2,
+    maxDecimalPlaces: 10,
+    minDecimalSignificantDigits: 2,
+    decimalPlacesWhenZero: 2
+  },
+  TOKEN: {
+    minDecimalPlaces: 4,
+    maxDecimalPlaces: 16,
+    minDecimalSignificantDigits: 2,
+    decimalPlacesWhenZero: 1
+  },
+  Exact: {
+    minDecimalPlaces: 18,
+    maxDecimalPlaces: 18,
+    minDecimalSignificantDigits: 0,
+    decimalPlacesWhenZero: 0
+  }
+}
+
+export function prettifyAttoAlphAmount(amount: Number256): string | undefined {
+  return prettifyNumber(amount, 18, prettifyNumberConfig.ALPH)
+}
+
+export function prettifyTokenAmount(amount: Number256, decimals: number): string | undefined {
+  return prettifyNumber(amount, decimals, prettifyNumberConfig.TOKEN)
+}
+
+export function prettifyExactAmount(amount: Number256, decimals: number): string | undefined {
+  return prettifyNumber(amount, decimals, prettifyNumberConfig.Exact)
+}
+
+export function prettifyNumber(amount: Number256, decimals: number, config: IPrettifyNumberConfig): string | undefined {
+  const number = typeof amount === 'string' ? amount : toFixedNumber(amount, decimals)
+
+  if (!isNumeric(number)) {
+    return undefined
+  }
+
+  const numberBN = new BigNumber(number)
+
+  let untrimmed: string
+  if (numberBN.gte(1)) {
+    /** simplest case, formatting to minDecimalPlaces will look good */
+    untrimmed = numberBN.toFormat(config.minDecimalPlaces)
+  } else {
+    /** now need to interrogate the appearance of decimal number < 1 */
+    /** longest case - max decimal places e.g. 0.0008923088123 -> 0.0008923088 */
+    const maxDecimalPlacesString = numberBN.toFormat(config.maxDecimalPlaces)
+    /** count the zeros, which will then allow us to know the final length with desired significant digits */
+    const decimalPart = maxDecimalPlacesString.split('.')[1]
+    const zeroMatches = decimalPart?.match(/^0+/)
+    const leadingZerosInDecimalPart = zeroMatches && zeroMatches.length ? zeroMatches[0].length : 0
+    /** now we can re-format with leadingZerosInDecimalPart + maxDecimalSignificanDigits to give us the pretty version */
+    /** e.g. 0.0008923088123 -> 0.00089 */
+    const prettyDecimalPlaces = Math.max(
+      leadingZerosInDecimalPart + config.minDecimalSignificantDigits,
+      config.minDecimalPlaces
+    )
+    untrimmed = numberBN.toFormat(prettyDecimalPlaces)
+  }
+  /** the untrimmed string may have trailing zeros, e.g. 0.0890 */
+  /** trim to a minimum specified by the config, e.g. we may want to display $0.00 or 0.0 ETH */
+  let trimmed = untrimmed.replace(/0+$/, '')
+  const minLength = 1 + untrimmed.indexOf('.') + config.decimalPlacesWhenZero
+  if (trimmed.length < minLength) {
+    trimmed = untrimmed.substring(0, minLength)
+  }
+  if (trimmed[trimmed.length - 1] === '.') {
+    trimmed = trimmed.slice(0, -1)
+  }
+  return trimmed
+}
+
+const BN_N1 = BigInt(-1)
+const BN_0 = BigInt(0)
+
+// Constant to pull zeros from for multipliers
+const Zeros = '0000'
+
+function toFixedNumber(val: bigint, decimals: number): string {
+  let negative = ''
+  if (val < BN_0) {
+    negative = '-'
+    val *= BN_N1
+  }
+  let str = val.toString()
+  // No decimal point for whole values
+  if (decimals === 0) {
+    return negative + str
+  }
+  // Pad out to the whole component (including a whole digit)
+  while (str.length <= decimals) {
+    str = Zeros + str
+  }
+  // Insert the decimal point
+  const index = str.length - decimals
+  str = str.substring(0, index) + '.' + str.substring(index)
+  // Trim the whole component (leaving at least one 0)
+  while (str[0] === '0' && str[1] !== '.') {
+    str = str.substring(1)
+  }
+  // Trim the decimal component (leaving at least one 0)
+  while (str[str.length - 1] === '0' && str[str.length - 2] !== '.') {
+    str = str.substring(0, str.length - 1)
+  }
+  return negative + str
+}
+
+export function convertAmountWithDecimals(amount: string | number, decimals: number): bigint | undefined {
+  try {
+    const result = new BigNumber(amount).multipliedBy(Math.pow(10, decimals))
+    return BigInt(result.toFormat(0, { groupSeparator: '' }))
+  } catch (e) {
+    return undefined
+  }
+}
+
+export function convertAlphAmount(amount: string | number): bigint | undefined {
+  return convertAmountWithDecimals(amount, 18)
+}

package/src/utils/sign.ts

@@ -0,0 +1,66 @@
+/*
+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 { ec as EC } from 'elliptic'
+import { binToHex, encodeSignature, hexToBinUnsafe, signatureDecode } from '..'
+import { KeyType } from '../signer'
+import * as necc from '@noble/secp256k1'
+import { createHash, createHmac } from 'crypto'
+
+const ec = new EC('secp256k1')
+
+necc.utils.sha256Sync = (...messages: Uint8Array[]): Uint8Array => {
+  const sha256 = createHash('sha256')
+  for (const message of messages) sha256.update(message)
+  return sha256.digest()
+}
+
+necc.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8Array => {
+  const hash = createHmac('sha256', Buffer.from(key))
+  messages.forEach((m) => hash.update(m))
+  return Uint8Array.from(hash.digest())
+}
+
+// hash has to be 32 bytes
+export function sign(hash: string, privateKey: string, _keyType?: KeyType): string {
+  const keyType = _keyType ?? 'default'
+
+  if (keyType === 'default') {
+    const key = ec.keyFromPrivate(privateKey)
+    const signature = key.sign(hash)
+    return encodeSignature(signature)
+  } else {
+    const signature = necc.schnorr.signSync(hexToBinUnsafe(hash), hexToBinUnsafe(privateKey))
+    return binToHex(signature)
+  }
+}
+
+export function verifySignature(hash: string, publicKey: string, signature: string, _keyType?: KeyType): boolean {
+  const keyType = _keyType ?? 'default'
+
+  try {
+    if (keyType === 'default') {
+      const key = ec.keyFromPublic(publicKey, 'hex')
+      return key.verify(hash, signatureDecode(ec, signature))
+    } else {
+      return necc.schnorr.verifySync(hexToBinUnsafe(signature), hexToBinUnsafe(hash), hexToBinUnsafe(publicKey))
+    }
+  } catch (error) {
+    return false
+  }
+}

package/src/utils/utils.ts

@@ -24,6 +24,7 @@ import { Buffer } from 'buffer/'
 
 import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import djb2 from './djb2'
+import { KeyType } from '../signer'
 
 const ec = new EC('secp256k1')
 
@@ -157,20 +158,35 @@ export function binToHex(bin: Uint8Array): string {
   return Buffer.from(bin).toString('hex')
 }
 
-export function groupOfPrivateKey(privateKey: string): number {
-  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey)))
+export function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number {
+  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey, keyType), keyType))
 }
 
-export function publicKeyFromPrivateKey(privateKey: string): string {
-  const key = ec.keyFromPrivate(privateKey)
-  return key.getPublic(true, 'hex')
+export function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string {
+  const keyType = _keyType ?? 'default'
+
+  if (keyType === 'default') {
+    const key = ec.keyFromPrivate(privateKey)
+    return key.getPublic(true, 'hex')
+  } else {
+    return ec.g.mul(new BN(privateKey, 16)).encode('hex', true).slice(2)
+  }
 }
 
-export function addressFromPublicKey(publicKey: string): string {
-  const addressType = Buffer.from([AddressType.P2PKH])
-  const hash = Buffer.from(blake.blake2b(Buffer.from(publicKey, 'hex'), undefined, 32))
-  const bytes = Buffer.concat([addressType, hash])
-  return bs58.encode(bytes)
+export function addressFromPublicKey(publicKey: string, _keyType?: KeyType): string {
+  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])
+    return bs58.encode(bytes)
+  } else {
+    const lockupScript = Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex')
+    const lockupScriptHash = blake.blake2b(lockupScript, undefined, 32)
+    const addressType = Buffer.from([AddressType.P2SH])
+    return bs58.encode(Buffer.concat([addressType, lockupScriptHash]))
+  }
 }
 
 export function addressFromContractId(contractId: string): string {