@alephium/web3 1.8.1 → 1.8.2

package/src/contract/contract.ts

@@ -54,7 +54,9 @@ import {
   WebCrypto,
   hexToBinUnsafe,
   isDevnet,
-  HexString
+  HexString,
+  isHexString,
+  hexToString
 } from '../utils'
 import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId } from '../address'
 import { getCurrentNodeProvider } from '../global'
@@ -87,6 +89,7 @@ import {
   i32Codec,
   BytesConst
 } from '../codec'
+import { TraceableError } from '../error'
 
 const crypto = new WebCrypto()
 
@@ -405,7 +408,7 @@ export class Contract extends Artifact {
   printDebugMessages(funcName: string, messages: DebugMessage[]) {
     if (isContractDebugMessageEnabled() && messages.length != 0) {
       console.log(`Testing ${this.name}.${funcName}:`)
-      messages.forEach((m) => console.log(`> Contract @ ${m.contractAddress} - ${m.message}`))
+      messages.forEach((m) => printDebugMessage(m))
     }
   }
 
@@ -503,6 +506,7 @@ export class Contract extends Artifact {
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
+  static DebugEventIndex = -3
 
   static fromApiEvent(
     event: node.ContractEventByTxId,
@@ -602,7 +606,7 @@ export class Contract extends Artifact {
           : this.bytecode
       return ralph.buildContractByteCode(bytecode, initialFields, this.fieldsSig, this.structs)
     } catch (error) {
-      throw new Error(`Failed to build bytecode for contract ${this.name}, error: ${error}`)
+      throw new TraceableError(`Failed to build bytecode for contract ${this.name}`, error)
     }
   }
 
@@ -770,7 +774,7 @@ export class Script extends Artifact {
     try {
       return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig, this.structs)
     } catch (error) {
-      throw new Error(`Failed to build bytecode for script ${this.name}, error: ${error}`)
+      throw new TraceableError(`Failed to build bytecode for script ${this.name}`, error)
     }
   }
 }
@@ -1494,6 +1498,38 @@ export async function testMethod<
   } as TestContractResult<R, M>
 }
 
+function printDebugMessage(m: node.DebugMessage) {
+  console.log(`> Contract @ ${m.contractAddress} - ${m.message}`)
+}
+
+export async function getDebugMessagesFromTx(txId: HexString, provider?: NodeProvider) {
+  if (isHexString(txId) && txId.length === 64) {
+    const nodeProvider = provider ?? getCurrentNodeProvider()
+    const events = await nodeProvider.events.getEventsTxIdTxid(txId)
+    return events.events
+      .filter((e) => e.eventIndex === Contract.DebugEventIndex)
+      .map((e) => {
+        if (e.fields.length === 1 && e.fields[0].type === 'ByteVec') {
+          return {
+            contractAddress: e.contractAddress,
+            message: hexToString(e.fields[0].value as string)
+          }
+        } else {
+          throw new Error(`Invalid debug log: ${JSON.stringify(e.fields)}`)
+        }
+      })
+  } else {
+    throw new Error(`Invalid tx id: ${txId}`)
+  }
+}
+
+export async function printDebugMessagesFromTx(txId: HexString, provider?: NodeProvider) {
+  const messages = await getDebugMessagesFromTx(txId, provider)
+  if (messages.length > 0) {
+    messages.forEach((m) => printDebugMessage(m))
+  }
+}
+
 export class RalphMap<K extends Val, V extends Val> {
   private readonly groupIndex: number
   constructor(
@@ -1546,7 +1582,10 @@ export async function getMapItem<R extends Val>(
       // the map item contract does not exist
       return undefined
     }
-    throw error
+    throw new TraceableError(
+      `Failed to get value from map ${mapName}, key: ${key}, parent contract id: ${parentContractId}`,
+      error
+    )
   }
 }
 
@@ -1841,7 +1880,11 @@ export async function signExecuteMethod<I extends ContractInstance, F extends Fi
     gasPrice: params.gasPrice
   }
 
-  return await signer.signAndSubmitExecuteScriptTx(signerParams)
+  const result = await signer.signAndSubmitExecuteScriptTx(signerParams)
+  if (isContractDebugMessageEnabled() && (await contract.contract.isDevnet(signer))) {
+    await printDebugMessagesFromTx(result.txId, signer.nodeProvider)
+  }
+  return result
 }
 
 function getBytecodeTemplate(
@@ -2097,7 +2140,7 @@ export async function getContractEventsCurrentCount(contractAddress: Address): P
       if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
         return 0
       }
-      throw error
+      throw new TraceableError(`Failed to get the event count for the contract ${contractAddress}`, error)
     })
 }
 

package/src/contract/ralph.ts

@@ -46,6 +46,7 @@ import {
   U256Const5
 } from '../codec'
 import { boolCodec } from '../codec/codec'
+import { TraceableError } from '../error'
 
 export function encodeByteVec(hex: string): Uint8Array {
   if (!isHexString(hex)) {
@@ -423,10 +424,7 @@ function _encodeField<T>(fieldName: string, encodeFunc: () => T): T {
   try {
     return encodeFunc()
   } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`Invalid ${fieldName}, error: ${error.message}`)
-    }
-    throw error
+    throw new TraceableError(`Failed to encode the field ${fieldName}`, error)
   }
 }
 

package/src/error.ts

@@ -0,0 +1,37 @@
+/*
+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 class TraceableError extends Error {
+  trace: any | undefined
+
+  constructor(message?: string, innerError?: any) {
+    const innerErrorMessage =
+      innerError === undefined ? undefined : innerError instanceof Error ? innerError.message : `${innerError}`
+    super(innerErrorMessage ? `${message}, error: ${innerErrorMessage}` : message)
+    this.trace = innerError
+
+    const actualProto = new.target.prototype
+
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto)
+    } else {
+      const object = this as any
+      object.__proto__ = actualProto
+    }
+  }
+}

package/src/exchange/exchange.ts

@@ -17,19 +17,15 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { AddressType, addressFromPublicKey, addressFromScript } from '../address'
-import { binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
+import { base58ToBytes, binToHex, hexToBinUnsafe, isHexString } from '../utils'
 import { Transaction } from '../api/api-alephium'
 import { Address } from '../signer'
 import { P2SH, unlockScriptCodec } from '../codec/unlock-script-codec'
 import { scriptCodec } from '../codec/script-codec'
+import { TraceableError } from '../error'
 
 export function validateExchangeAddress(address: string) {
-  let decoded: Uint8Array
-  try {
-    decoded = bs58.decode(address)
-  } catch (_) {
-    throw new Error('Invalid base58 string')
-  }
+  const decoded = base58ToBytes(address)
   if (decoded.length === 0) throw new Error('Address is empty')
   const addressType = decoded[0]
   if (addressType !== AddressType.P2PKH && addressType !== AddressType.P2SH) {
@@ -106,8 +102,8 @@ export function getAddressFromUnlockScript(unlockScript: string): Address {
     let p2sh: P2SH
     try {
       p2sh = unlockScriptCodec.decode(decoded).value as P2SH
-    } catch (_) {
-      throw new Error(`Invalid p2sh unlock script: ${unlockScript}`)
+    } catch (e) {
+      throw new TraceableError(`Invalid p2sh unlock script: ${unlockScript}`, e)
     }
     return addressFromScript(scriptCodec.encode(p2sh.script))
   }

package/src/index.ts

@@ -35,3 +35,4 @@ export * from './debug'
 export * from './block'
 export * from './address'
 export * from './exchange'
+export * from './error'

package/src/signer/tx-builder.ts

@@ -31,7 +31,6 @@ import {
   SignExecuteScriptChainedTxResult,
   SignExecuteScriptTxParams,
   SignExecuteScriptTxResult,
-  SignTransferChainedTxResult,
   SignTransferTxParams,
   SignTransferTxResult,
   SignUnsignedTxParams,
@@ -40,7 +39,7 @@ import {
 import { unsignedTxCodec } from '../codec'
 import { groupIndexOfTransaction } from '../transaction'
 import { blakeHash } from '../codec/hash'
-import { BuildDeployContractTxResult, BuildChainedTx, BuildChainedTxResult } from '../api/api-alephium'
+import { BuildDeployContractTxResult, BuildChainedTx } from '../api/api-alephium'
 
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider

package/src/token/nft.ts

@@ -21,6 +21,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import 'cross-fetch/polyfill'
 import { NFTCollectionUriMetaData, NFTTokenUriMetaData } from '../api'
+import { TraceableError } from '../error'
 
 export const validNFTTokenUriMetaDataFields = ['name', 'description', 'image', 'attributes']
 export const validNFTTokenUriMetaDataAttributesFields = ['trait_type', 'value']
@@ -130,7 +131,7 @@ async function fetchNFTMetadata(nftBaseUri: string, index: number) {
   try {
     return await (await fetch(`${nftBaseUri}${index}`)).json()
   } catch (e) {
-    throw new Error(`Error fetching NFT metadata from ${nftBaseUri}${index}: ${e}`)
+    throw new TraceableError(`Error fetching NFT metadata from ${nftBaseUri}${index}`, e)
   }
 }
 

package/src/utils/bs58.ts

@@ -18,6 +18,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 /** This source is under MIT License and come originally from https://github.com/cryptocoinjs/bs58 **/
 import basex from 'base-x'
+import { TraceableError } from '../error'
 
 const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
@@ -34,4 +35,12 @@ export function isBase58(s: string): boolean {
   }
 }
 
+export function base58ToBytes(s: string): Uint8Array {
+  try {
+    return bs58.decode(s)
+  } catch (e) {
+    throw new TraceableError(`Invalid base58 string ${s}`, e)
+  }
+}
+
 export default bs58