@alephium/web3 0.30.1 → 0.31.0

package/src/utils/address.ts

@@ -16,24 +16,179 @@ 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 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 { KeyType } from '../signer'
 
-export function addressToGroup(address: string, totalNumberOfGroups: number): number {
-  const bytes = bs58.decode(address).slice(1)
-  const value = djb2(bytes) | 1
-  const hash = toPosInt(xorByte(value))
-  const group = hash % totalNumberOfGroups
+const ec = new EC('secp256k1')
+
+export enum AddressType {
+  P2PKH = 0x00,
+  P2MPKH = 0x01,
+  P2SH = 0x02,
+  P2C = 0x03
+}
+
+export function validateAddress(address: string) {
+  let decoded: Uint8Array
+  try {
+    decoded = bs58.decode(address)
+  } catch (_) {
+    throw new Error('Invalid base58 string')
+  }
+
+  if (decoded.length === 0) throw new Error('Address is empty')
+  const addressType = decoded[0]
+  if (addressType === AddressType.P2MPKH) {
+    // [1, n, ...hashes, m]
+    if ((decoded.length - 3) % 32 === 0) return
+  } else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {
+    // [type, ...hash]
+    if (decoded.length === 33) return
+  }
+
+  throw new Error(`Invalid address: ${address}`)
+}
+
+export function groupOfAddress(address: string): number {
+  validateAddress(address)
+
+  const decoded = bs58.decode(address)
+  const addressType = decoded[0]
+  const addressBody = decoded.slice(1)
+
+  if (addressType == AddressType.P2PKH) {
+    return groupOfP2pkhAddress(addressBody)
+  } else if (addressType == AddressType.P2MPKH) {
+    return groupOfP2mpkhAddress(addressBody)
+  } else if (addressType == AddressType.P2SH) {
+    return groupOfP2shAddress(addressBody)
+  } else {
+    // Contract Address
+    const id = contractIdFromAddress(address)
+    return id[`${id.length - 1}`]
+  }
+}
+
+function groupOfAddressBytes(bytes: Uint8Array): number {
+  const hint = djb2(bytes) | 1
+  const hash = xorByte(hint)
+  const group = hash % TOTAL_NUMBER_OF_GROUPS
   return group
 }
 
-function xorByte(value: number): number {
-  const byte0 = value >> 24
-  const byte1 = value >> 16
-  const byte2 = value >> 8
-  return byte0 ^ byte1 ^ byte2 ^ value
+// Pay to public key hash address
+function groupOfP2pkhAddress(address: Uint8Array): number {
+  return groupOfAddressBytes(address)
+}
+
+// Pay to multiple public key hash address
+function groupOfP2mpkhAddress(address: Uint8Array): number {
+  return groupOfAddressBytes(address.slice(1, 33))
+}
+
+// Pay to script hash address
+function groupOfP2shAddress(address: Uint8Array): number {
+  return groupOfAddressBytes(address)
+}
+
+export function contractIdFromAddress(address: string): Uint8Array {
+  return idFromAddress(address)
+}
+
+export function tokenIdFromAddress(address: string): Uint8Array {
+  return idFromAddress(address)
+}
+
+function idFromAddress(address: string): Uint8Array {
+  const decoded = bs58.decode(address)
+
+  if (decoded.length == 0) throw new Error('Address string is empty')
+  const addressType = decoded[0]
+  const addressBody = decoded.slice(1)
+
+  if (addressType == AddressType.P2C) {
+    return addressBody
+  } else {
+    throw new Error(`Invalid contract address type: ${addressType}`)
+  }
+}
+
+export function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number {
+  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey, keyType), keyType))
+}
+
+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, _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')
+    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]))
+}
+
+export function addressFromContractId(contractId: string): string {
+  const addressType = Buffer.from([AddressType.P2C])
+  const hash = Buffer.from(hexToBinUnsafe(contractId))
+  const bytes = Buffer.concat([addressType, hash])
+  return bs58.encode(bytes)
+}
+
+export function addressFromTokenId(tokenId: string): string {
+  const contractId = tokenId // contract ID is the same as token ID
+  return addressFromContractId(contractId)
+}
+
+export function contractIdFromTx(txId: string, outputIndex: number): string {
+  const txIdBin = hexToBinUnsafe(txId)
+  const data = Buffer.concat([txIdBin, Buffer.from([outputIndex])])
+  const hash = blake.blake2b(data, undefined, 32)
+  return binToHex(hash)
+}
+
+export function subContractId(parentContractId: string, pathInHex: string, group: number): string {
+  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])
+  ])
+  return binToHex(bytes)
 }
 
-function toPosInt(byte: number): number {
-  return byte & 0xff
+export function xorByte(intValue: number): number {
+  const byte0 = (intValue >> 24) & 0xff
+  const byte1 = (intValue >> 16) & 0xff
+  const byte2 = (intValue >> 8) & 0xff
+  const byte3 = intValue & 0xff
+  return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff
 }

package/src/utils/error.ts

@@ -0,0 +1,77 @@
+/*
+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
+  }
+}

package/src/utils/utils.ts

@@ -18,12 +18,10 @@ 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 blake from 'blakejs'
 import bs58 from './bs58'
 import { Buffer } from 'buffer/'
 
 import { TOTAL_NUMBER_OF_GROUPS, TOTAL_NUMBER_OF_CHAINS } from '../constants'
-import djb2 from './djb2'
 import { KeyType } from '../signer'
 import { HexString } from '../contract'
 
@@ -63,14 +61,6 @@ export function signatureDecode(ec: EC, signature: string): SignatureInput {
   }
 }
 
-export function xorByte(intValue: number): number {
-  const byte0 = (intValue >> 24) & 0xff
-  const byte1 = (intValue >> 16) & 0xff
-  const byte2 = (intValue >> 8) & 0xff
-  const byte3 = intValue & 0xff
-  return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff
-}
-
 export function isHexString(input: string): boolean {
   return input.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(input)
 }
@@ -84,85 +74,6 @@ export function toNonNegativeBigInt(input: string): bigint | undefined {
   }
 }
 
-export enum AddressType {
-  P2PKH = 0x00,
-  P2MPKH = 0x01,
-  P2SH = 0x02,
-  P2C = 0x03
-}
-
-export function groupOfAddress(address: string): number {
-  const decoded = bs58.decode(address)
-
-  if (decoded.length == 0) throw new Error('Address string is empty')
-  const addressType = decoded[0]
-  const addressBody = decoded.slice(1)
-
-  if (addressType == AddressType.P2PKH) {
-    return groupOfP2pkhAddress(addressBody)
-  } else if (addressType == AddressType.P2MPKH) {
-    return groupOfP2mpkhAddress(addressBody)
-  } else if (addressType == AddressType.P2SH) {
-    return groupOfP2shAddress(addressBody)
-  } else {
-    // Contract Address
-    const id = contractIdFromAddress(address)
-    return id[`${id.length - 1}`]
-  }
-}
-
-function groupOfAddressBytes(bytes: Uint8Array): number {
-  const hint = djb2(bytes) | 1
-  const hash = xorByte(hint)
-  const group = hash % TOTAL_NUMBER_OF_GROUPS
-  return group
-}
-
-// Pay to public key hash address
-function groupOfP2pkhAddress(address: Uint8Array): number {
-  if (address.length != 32) {
-    throw new Error(`Invalid p2pkh address length: ${address.length}`)
-  }
-
-  return groupOfAddressBytes(address)
-}
-
-// Pay to multiple public key hash address
-function groupOfP2mpkhAddress(address: Uint8Array): number {
-  if ((address.length - 2) % 32 != 0) {
-    throw new Error(`Invalid p2mpkh address length: ${address.length}`)
-  }
-
-  return groupOfAddressBytes(address.slice(1, 33))
-}
-
-// Pay to script hash address
-function groupOfP2shAddress(address: Uint8Array): number {
-  return groupOfAddressBytes(address)
-}
-
-export function contractIdFromAddress(address: string): Uint8Array {
-  return idFromAddress(address)
-}
-
-export function tokenIdFromAddress(address: string): Uint8Array {
-  return idFromAddress(address)
-}
-
-function idFromAddress(address: string): Uint8Array {
-  const decoded = bs58.decode(address)
-
-  if (decoded.length == 0) throw new Error('Address string is empty')
-  const addressType = decoded[0]
-  const addressBody = decoded.slice(1)
-
-  if (addressType == AddressType.P2C) {
-    return addressBody
-  } else {
-    throw new Error(`Invalid contract address type: ${addressType}`)
-  }
-}
-
 export function hexToBinUnsafe(hex: string): Uint8Array {
   return Buffer.from(hex, 'hex')
 }
@@ -171,72 +82,6 @@ export function binToHex(bin: Uint8Array): string {
   return Buffer.from(bin).toString('hex')
 }
 
-export function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number {
-  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey, keyType), keyType))
-}
-
-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, _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')
-    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]))
-}
-
-export function addressFromContractId(contractId: string): string {
-  const addressType = Buffer.from([AddressType.P2C])
-  const hash = Buffer.from(hexToBinUnsafe(contractId))
-  const bytes = Buffer.concat([addressType, hash])
-  return bs58.encode(bytes)
-}
-
-export function addressFromTokenId(tokenId: string): string {
-  const contractId = tokenId // contract ID is the same as token ID
-  return addressFromContractId(contractId)
-}
-
-export function contractIdFromTx(txId: string, outputIndex: number): string {
-  const txIdBin = hexToBinUnsafe(txId)
-  const data = Buffer.concat([txIdBin, Buffer.from([outputIndex])])
-  const hash = blake.blake2b(data, undefined, 32)
-  return binToHex(hash)
-}
-
-export function subContractId(parentContractId: string, pathInHex: string, group: number): string {
-  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])
-  ])
-  return binToHex(bytes)
-}
-
 export function blockChainIndex(blockHash: HexString): { fromGroup: number; toGroup: number } {
   if (blockHash.length != 64) {
     throw Error(`Invalid block hash: ${blockHash}`)