@alephium/web3 0.3.0-rc.5 → 0.3.0-rc.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.3.0-rc.5",
+  "version": "0.3.0-rc.7",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,8 +27,8 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.6.1",
-    "explorer_backend_version": "1.11.2"
+    "alephium_version": "1.6.2",
+    "explorer_backend_version": "1.12.0-rc2"
   },
   "scripts": {
     "build": "rm -rf dist/* && npx tsc --build . && webpack",

package/src/api/api-alephium.ts

@@ -1332,7 +1332,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 1.6.1
+ * @version 1.6.2
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/api/api-explorer.ts

@@ -96,6 +96,7 @@ export interface ConfirmedTransaction {
 
   /** @format uint256 */
   gasPrice: string
+  coinbase: boolean
   type: string
 }
 
@@ -116,6 +117,20 @@ export interface ContractOutput {
   type: string
 }
 
+export interface Event {
+  /** @format block-hash */
+  blockHash: string
+
+  /** @format 32-byte-hash */
+  txHash: string
+  contractAddress: string
+  inputAddress?: string
+
+  /** @format int32 */
+  eventIndex: number
+  fields?: Val[]
+}
+
 export interface ExplorerInfo {
   releaseVersion: string
   commit: string
@@ -147,6 +162,11 @@ export interface InternalServerError {
   detail: string
 }
 
+export enum IntervalType {
+  Daily = 'daily',
+  Hourly = 'hourly'
+}
+
 export interface ListBlocks {
   /** @format int32 */
   total: number
@@ -275,6 +295,7 @@ export interface Transaction {
 
   /** @format uint256 */
   gasPrice: string
+  coinbase: boolean
 }
 
 export type TransactionLike = ConfirmedTransaction | UnconfirmedTransaction
@@ -306,6 +327,42 @@ export interface UnconfirmedTransaction {
   type: string
 }
 
+export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256
+
+export interface ValAddress {
+  /** @format address */
+  value: string
+  type: string
+}
+
+export interface ValArray {
+  value: Val[]
+  type: string
+}
+
+export interface ValBool {
+  value: boolean
+  type: string
+}
+
+export interface ValByteVec {
+  /** @format hex-string */
+  value: string
+  type: string
+}
+
+export interface ValI256 {
+  /** @format bigint */
+  value: string
+  type: string
+}
+
+export interface ValU256 {
+  /** @format uint256 */
+  value: string
+  type: string
+}
+
 import 'cross-fetch/polyfill'
 import { convertHttpResponse } from './utils'
 
@@ -587,21 +644,6 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         method: 'GET',
         format: 'json',
         ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * @description Get a transaction from a output reference key
-     *
-     * @tags Transactions
-     * @name GetTransactionsByOutputRefKeyOutputRefKey
-     * @request GET:/transactions/by/output-ref-key/{output_ref_key}
-     */
-    getTransactionsByOutputRefKeyOutputRefKey: (outputRefKey: string, params: RequestParams = {}) =>
-      this.request<Transaction, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/transactions/by/output-ref-key/${outputRefKey}`,
-        method: 'GET',
-        format: 'json',
-        ...params
       }).then(convertHttpResponse)
   }
   addresses = {
@@ -778,6 +820,23 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description Are the addresses used (at least 1 transaction)
+     *
+     * @tags Addresses, Addresses
+     * @name PostAddressesUsed
+     * @request POST:/addresses/used
+     */
+    postAddressesUsed: (data?: string[], params: RequestParams = {}) =>
+      this.request<boolean[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/used`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * No description
      *
@@ -797,24 +856,6 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
-  addressesActive = {
-    /**
-     * @description Are the addresses active (at least 1 transaction)
-     *
-     * @tags Addresses
-     * @name PostAddressesActive
-     * @request POST:/addresses-active
-     */
-    postAddressesActive: (data?: string[], params: RequestParams = {}) =>
-      this.request<boolean[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses-active`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse)
-  }
   infos = {
     /**
      * @description Get explorer informations
@@ -1016,7 +1057,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request GET:/charts/hashrates
      */
     getChartsHashrates: (
-      query: { fromTs: number; toTs: number; 'interval-type': string },
+      query: { fromTs: number; toTs: number; 'interval-type': IntervalType },
       params: RequestParams = {}
     ) =>
       this.request<Hashrate[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
@@ -1036,7 +1077,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request GET:/charts/transactions-count
      */
     getChartsTransactionsCount: (
-      query: { fromTs: number; toTs: number; 'interval-type': string },
+      query: { fromTs: number; toTs: number; 'interval-type': IntervalType },
       params: RequestParams = {}
     ) =>
       this.request<TimedCount[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
@@ -1056,7 +1097,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request GET:/charts/transactions-count-per-chain
      */
     getChartsTransactionsCountPerChain: (
-      query: { fromTs: number; toTs: number; 'interval-type': string },
+      query: { fromTs: number; toTs: number; 'interval-type': IntervalType },
       params: RequestParams = {}
     ) =>
       this.request<
@@ -1070,6 +1111,63 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
+  contractEvents = {
+    /**
+     * @description Get contract events by transaction id
+     *
+     * @tags Contract events
+     * @name GetContractEventsTransactionIdTransactionId
+     * @request GET:/contract-events/transaction-id/{transaction_id}
+     */
+    getContractEventsTransactionIdTransactionId: (transactionId: string, params: RequestParams = {}) =>
+      this.request<Event[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/contract-events/transaction-id/${transactionId}`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get contract events by contract address
+     *
+     * @tags Contract events
+     * @name GetContractEventsContractAddressContractAddress
+     * @request GET:/contract-events/contract-address/{contract_address}
+     */
+    getContractEventsContractAddressContractAddress: (
+      contractAddress: string,
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<Event[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/contract-events/contract-address/${contractAddress}`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get contract events by contract and input addresses
+     *
+     * @tags Contract events
+     * @name GetContractEventsContractAddressContractAddressInputAddressInputAddress
+     * @request GET:/contract-events/contract-address/{contract_address}/input-address/{input_address}
+     */
+    getContractEventsContractAddressContractAddressInputAddressInputAddress: (
+      contractAddress: string,
+      inputAddress: string,
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<Event[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/contract-events/contract-address/${contractAddress}/input-address/${inputAddress}`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
   utils = {
     /**
      * @description Perform a sanity check

package/src/api/index.ts

@@ -118,7 +118,6 @@ export class ExplorerProvider {
   readonly blocks = ExplorerApi['blocks']
   readonly transactions = ExplorerApi['transactions']
   readonly addresses = ExplorerApi['addresses']
-  readonly addressesActive = ExplorerApi['addressesActive']
   readonly infos = ExplorerApi['infos']
   readonly unconfirmedTransactions = ExplorerApi['unconfirmedTransactions']
   readonly tokens = ExplorerApi['tokens']
@@ -142,7 +141,6 @@ export class ExplorerProvider {
     this.blocks = { ...explorerApi.blocks }
     this.transactions = { ...explorerApi.transactions }
     this.addresses = { ...explorerApi.addresses }
-    this.addressesActive = { ...explorerApi.addressesActive }
     this.infos = { ...explorerApi.infos }
     this.unconfirmedTransactions = { ...explorerApi.unconfirmedTransactions }
     this.tokens = { ...explorerApi.tokens }

package/src/signer/index.ts

@@ -18,3 +18,4 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 export * from './signer'
 export * from './types'
+export * from './tx-builder'

package/src/signer/signer.ts

@@ -17,15 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ec as EC } from 'elliptic'
-import {
-  ExplorerProvider,
-  fromApiNumber256,
-  fromApiTokens,
-  NodeProvider,
-  toApiNumber256,
-  toApiNumber256Optional,
-  toApiTokens
-} from '../api'
+import { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, toApiTokens } from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
 import blake from 'blakejs'
@@ -46,8 +38,14 @@ import {
   SignUnsignedTxParams,
   SignUnsignedTxResult,
   SubmissionResult,
-  SubmitTransactionParams
+  SubmitTransactionParams,
+  ExtSignTransferTxParams,
+  ExtSignDeployContractTxParams,
+  ExtSignExecuteScriptTxParams,
+  ExtSignUnsignedTxParams,
+  ExtSignMessageParams
 } from './types'
+import { TransactionBuilder } from './tx-builder'
 
 const ec = new EC('secp256k1')
 
@@ -71,12 +69,19 @@ export interface SignerProvider {
 // Abstraction for interactive signer (e.g. WalletConnect instance, Extension wallet object)
 export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase>
   extends SignerProvider {
-  enable(opt?: EnableOptions): Promise<void>
+  enable(opt?: EnableOptions): Promise<Address>
   disconnect(): Promise<void>
+
+  // Methods inherited from SignerProvider, but require networkId in the params
+  signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>
+  signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>
+  signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>
 }
 
-export abstract class SignerProviderSimple implements SignerProvider {
-  abstract get nodeProvider(): NodeProvider | undefined
+export abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
   abstract get explorerProvider(): ExplorerProvider | undefined
 
   abstract getSelectedAccount(): Promise<Account>
@@ -86,16 +91,9 @@ export abstract class SignerProviderSimple implements SignerProvider {
     return account.address
   }
 
-  private getNodeProvider(): NodeProvider {
-    if (this.nodeProvider === undefined) {
-      throw Error('The signer does not contain a node provider')
-    }
-    return this.nodeProvider
-  }
-
   async submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult> {
     const data: node.SubmitTransaction = { unsignedTx: params.unsignedTx, signature: params.signature }
-    return this.getNodeProvider().transactions.postTransactionsSubmit(data)
+    return this.nodeProvider.transactions.postTransactionsSubmit(data)
   }
 
   async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
@@ -132,67 +130,43 @@ export abstract class SignerProviderSimple implements SignerProvider {
   async signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
     const response = await this.buildTransferTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
-    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
+    return { signature, ...response }
   }
 
-  async buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult> {
-    const data: node.BuildTransaction = {
-      ...(await this.usePublicKey(params)),
-      destinations: toApiDestinations(params.destinations),
-      gasPrice: toApiNumber256Optional(params.gasPrice)
-    }
-    return this.getNodeProvider().transactions.postTransactionsBuild(data)
+  override async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    return super.buildTransferTx(params, await this.getPublicKey(params.signerAddress))
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
-    const response = await this.buildContractCreationTx(params)
+    const response = await this.buildDeployContractTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
-    const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress))
-    return { ...response, contractId, signature, gasPrice: fromApiNumber256(response.gasPrice) }
+    return { signature, ...response }
   }
 
-  async buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult> {
-    const data: node.BuildDeployContractTx = {
-      ...(await this.usePublicKey(params)),
-      initialAttoAlphAmount: toApiNumber256Optional(params.initialAttoAlphAmount),
-      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
-      issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
-      gasPrice: toApiNumber256Optional(params.gasPrice)
-    }
-    return this.getNodeProvider().contracts.postContractsUnsignedTxDeployContract(data)
+  override async buildDeployContractTx(
+    params: SignDeployContractTxParams
+  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+    return super.buildDeployContractTx(params, await this.getPublicKey(params.signerAddress))
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
-    const response = await this.buildScriptTx(params)
+    const response = await this.buildExecuteScriptTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
-    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
+    return { signature, ...response }
   }
 
-  async buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult> {
-    const data: node.BuildExecuteScriptTx = {
-      ...(await this.usePublicKey(params)),
-      attoAlphAmount: toApiNumber256Optional(params.attoAlphAmount),
-      tokens: toApiTokens(params.tokens),
-      gasPrice: toApiNumber256Optional(params.gasPrice)
-    }
-    return this.getNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data)
+  override async buildExecuteScriptTx(
+    params: SignExecuteScriptTxParams
+  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    return super.buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress))
   }
 
   // in general, wallet should show the decoded information to user for confirmation
   // please overwrite this function for real wallet
   async signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
-    const data = { unsignedTx: params.unsignedTx }
-    const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data)
-    const signature = await this.signRaw(params.signerAddress, decoded.unsignedTx.txId)
-    return {
-      fromGroup: decoded.fromGroup,
-      toGroup: decoded.toGroup,
-      unsignedTx: params.unsignedTx,
-      txId: decoded.unsignedTx.txId,
-      signature,
-      gasAmount: decoded.unsignedTx.gasAmount,
-      gasPrice: fromApiNumber256(decoded.unsignedTx.gasPrice)
-    }
+    const response = await this.buildUnsignedTx(params)
+    const signature = await this.signRaw(params.signerAddress, response.txId)
+    return { signature, ...response }
   }
 
   async signMessage(params: SignMessageParams): Promise<SignMessageResult> {

package/src/signer/tx-builder.ts

@@ -0,0 +1,121 @@
+/*
+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 { utils } from '..'
+import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiTokens } from '../api'
+import { addressFromPublicKey } from '../utils'
+import { toApiDestinations } from './signer'
+import {
+  SignDeployContractTxParams,
+  SignDeployContractTxResult,
+  SignerAddress,
+  SignExecuteScriptTxParams,
+  SignExecuteScriptTxResult,
+  SignTransferTxParams,
+  SignTransferTxResult,
+  SignUnsignedTxParams,
+  SignUnsignedTxResult
+} from './types'
+
+export abstract class TransactionBuilder {
+  abstract get nodeProvider(): NodeProvider
+
+  static create(baseUrl: string, apiKey?: string) {
+    const nodeProvider = new NodeProvider(baseUrl, apiKey)
+    return new (class extends TransactionBuilder {
+      get nodeProvider(): NodeProvider {
+        return nodeProvider
+      }
+    })()
+  }
+
+  private static validatePublicKey(params: SignerAddress, publicKey: string) {
+    const address = addressFromPublicKey(publicKey)
+    if (address !== params.signerAddress) {
+      throw new Error('Unmatched public key')
+    }
+  }
+
+  async buildTransferTx(
+    params: SignTransferTxParams,
+    publicKey: string
+  ): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    TransactionBuilder.validatePublicKey(params, publicKey)
+
+    const { destinations, gasPrice, ...rest } = params
+    const data: node.BuildTransaction = {
+      fromPublicKey: publicKey,
+      destinations: toApiDestinations(destinations),
+      gasPrice: toApiNumber256Optional(gasPrice),
+      ...rest
+    }
+    const response = await this.nodeProvider.transactions.postTransactionsBuild(data)
+    return { ...response, gasPrice: fromApiNumber256(response.gasPrice) }
+  }
+
+  async buildDeployContractTx(
+    params: SignDeployContractTxParams,
+    publicKey: string
+  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+    TransactionBuilder.validatePublicKey(params, publicKey)
+
+    const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params
+    const data: node.BuildDeployContractTx = {
+      fromPublicKey: publicKey,
+      initialAttoAlphAmount: toApiNumber256Optional(initialAttoAlphAmount),
+      initialTokenAmounts: toApiTokens(initialTokenAmounts),
+      issueTokenAmount: toApiNumber256Optional(issueTokenAmount),
+      gasPrice: toApiNumber256Optional(gasPrice),
+      ...rest
+    }
+    const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
+    const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress))
+    return { ...response, contractId, gasPrice: fromApiNumber256(response.gasPrice) }
+  }
+
+  async buildExecuteScriptTx(
+    params: SignExecuteScriptTxParams,
+    publicKey: string
+  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    TransactionBuilder.validatePublicKey(params, publicKey)
+
+    const { attoAlphAmount, tokens, gasPrice, ...rest } = params
+    const data: node.BuildExecuteScriptTx = {
+      fromPublicKey: publicKey,
+      attoAlphAmount: toApiNumber256Optional(attoAlphAmount),
+      tokens: toApiTokens(tokens),
+      gasPrice: toApiNumber256Optional(gasPrice),
+      ...rest
+    }
+    const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data)
+    return { ...response, gasPrice: fromApiNumber256(response.gasPrice) }
+  }
+
+  async buildUnsignedTx(params: SignUnsignedTxParams): Promise<Omit<SignUnsignedTxResult, 'signature'>> {
+    const data = { unsignedTx: params.unsignedTx }
+    const decoded = await this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data)
+    return {
+      fromGroup: decoded.fromGroup,
+      toGroup: decoded.toGroup,
+      unsignedTx: params.unsignedTx,
+      txId: decoded.unsignedTx.txId,
+      gasAmount: decoded.unsignedTx.gasAmount,
+      gasPrice: fromApiNumber256(decoded.unsignedTx.gasPrice)
+    }
+  }
+}

package/src/signer/types.ts

@@ -143,6 +143,13 @@ export interface SubmissionResult {
 export interface EnableOptionsBase {
   // chainGroup - specify whether to use addresses from a specific group
   chainGroup?: number
+  networkId: string
   onDisconnected: () => Promise<void>
-  onNetworkChanged: (network: { networkName: string; networkId: number }) => Promise<void>
 }
+
+// Transaction Params for InteractiveSignerProvider
+export type ExtSignTransferTxParams = SignTransferTxParams & { networkId: string }
+export type ExtSignDeployContractTxParams = SignDeployContractTxParams & { networkId: string }
+export type ExtSignExecuteScriptTxParams = SignExecuteScriptTxParams & { networkId: string }
+export type ExtSignUnsignedTxParams = SignUnsignedTxParams & { networkId: string }
+export type ExtSignMessageParams = SignMessageParams & { networkId: string }