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

package/src/signer/signer.ts

@@ -22,133 +22,40 @@ import {
   fromApiNumber256,
   fromApiTokens,
   NodeProvider,
-  Number256,
   toApiNumber256,
   toApiNumber256Optional,
-  toApiTokens,
-  Token
+  toApiTokens
 } from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
-import { Eq, assertType } from '../utils'
 import blake from 'blakejs'
-
-export type OutputRef = node.OutputRef
+import {
+  Account,
+  Address,
+  EnableOptionsBase,
+  Destination,
+  SignDeployContractTxParams,
+  SignDeployContractTxResult,
+  SignerAddress,
+  SignExecuteScriptTxParams,
+  SignExecuteScriptTxResult,
+  SignMessageParams,
+  SignMessageResult,
+  SignTransferTxParams,
+  SignTransferTxResult,
+  SignUnsignedTxParams,
+  SignUnsignedTxResult,
+  SubmissionResult,
+  SubmitTransactionParams
+} from './types'
 
 const ec = new EC('secp256k1')
 
-export interface Account {
-  address: string
-  group: number
-  publicKey: string
-}
-
-export type SignerAddress = { signerAddress: string }
-type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'targetBlockHash'> & SignerAddress
-type SignResult<T> = Omit<T, 'gasPrice'> & { signature: string; gasPrice: Number256 }
-
-export interface SignTransferTxParams {
-  signerAddress: string
-  destinations: Destination[]
-  utxos?: OutputRef[]
-  gasAmount?: number
-  gasPrice?: Number256
-}
-assertType<Eq<keyof SignTransferTxParams, keyof TxBuildParams<node.BuildTransaction>>>()
-export interface SignTransferTxResult {
-  fromGroup: number
-  toGroup: number
-  unsignedTx: string
-  txId: string
-  signature: string
-  gasAmount: number
-  gasPrice: Number256
-}
-assertType<Eq<SignTransferTxResult, SignResult<node.BuildTransactionResult>>>()
-
-export interface SignDeployContractTxParams {
-  signerAddress: string
-  bytecode: string
-  initialAttoAlphAmount?: Number256
-  initialTokenAmounts?: Token[]
-  issueTokenAmount?: Number256
-  gasAmount?: number
-  gasPrice?: Number256
-}
-assertType<Eq<keyof SignDeployContractTxParams, keyof TxBuildParams<node.BuildDeployContractTx>>>()
-export interface SignDeployContractTxResult {
-  fromGroup: number
-  toGroup: number
-  unsignedTx: string
-  txId: string
-  signature: string
-  contractId: string
-  contractAddress: string
-  gasAmount: number
-  gasPrice: Number256
-}
-assertType<Eq<SignDeployContractTxResult, SignResult<node.BuildDeployContractTxResult> & { contractId: string }>>()
-
-export interface SignExecuteScriptTxParams {
-  signerAddress: string
-  bytecode: string
-  attoAlphAmount?: Number256
-  tokens?: Token[]
-  gasAmount?: number
-  gasPrice?: Number256
-}
-assertType<Eq<keyof SignExecuteScriptTxParams, keyof TxBuildParams<node.BuildExecuteScriptTx>>>()
-export interface SignExecuteScriptTxResult {
-  fromGroup: number
-  toGroup: number
-  unsignedTx: string
-  txId: string
-  signature: string
-  gasAmount: number
-  gasPrice: Number256
-}
-assertType<Eq<SignExecuteScriptTxResult, SignResult<node.BuildExecuteScriptTxResult>>>()
-
-export interface SignUnsignedTxParams {
-  signerAddress: string
-  unsignedTx: string
-}
-assertType<Eq<SignUnsignedTxParams, { unsignedTx: string } & SignerAddress>>()
-export interface SignUnsignedTxResult {
-  fromGroup: number
-  toGroup: number
-  unsignedTx: string
-  txId: string
-  signature: string
-  gasAmount: number
-  gasPrice: Number256
-}
-assertType<Eq<SignUnsignedTxResult, SignTransferTxResult>>
-
-export interface SignMessageParams {
-  signerAddress: string
-  message: string
-}
-assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
-export interface SignMessageResult {
-  signature: string
-}
-
-export interface SubmitTransactionParams {
-  unsignedTx: string
-  signature: string
-}
-export interface SubmissionResult {
-  txId: string
-  fromGroup: number
-  toGroup: number
-}
-
 export interface SignerProvider {
   get nodeProvider(): NodeProvider | undefined
   get explorerProvider(): ExplorerProvider | undefined
 
-  getSelectedAccount(): Promise<Account>
+  getSelectedAddress(): Promise<Address>
 
   signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
   signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
@@ -161,11 +68,24 @@ export interface SignerProvider {
   signMessage(params: SignMessageParams): Promise<SignMessageResult>
 }
 
+// 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>
+  disconnect(): Promise<void>
+}
+
 export abstract class SignerProviderSimple implements SignerProvider {
   abstract get nodeProvider(): NodeProvider | undefined
   abstract get explorerProvider(): ExplorerProvider | undefined
+
   abstract getSelectedAccount(): Promise<Account>
 
+  async getSelectedAddress(): Promise<Address> {
+    const account = await this.getSelectedAccount()
+    return account.address
+  }
+
   private getNodeProvider(): NodeProvider {
     if (this.nodeProvider === undefined) {
       throw Error('The signer does not contain a node provider')
@@ -199,16 +119,14 @@ export abstract class SignerProviderSimple implements SignerProvider {
     return signResult
   }
 
+  protected abstract getPublicKey(address: string): Promise<string>
+
   private async usePublicKey<T extends SignerAddress>(
     params: T
   ): Promise<Omit<T, 'signerAddress'> & { fromPublicKey: string }> {
     const { signerAddress, ...restParams } = params
-    const selectedAccount = await this.getSelectedAccount()
-    if (signerAddress !== selectedAccount.address) {
-      throw new Error('The signer address is not the selected address')
-    } else {
-      return { fromPublicKey: selectedAccount.publicKey, ...restParams }
-    }
+    const publicKey = await this.getPublicKey(signerAddress)
+    return { fromPublicKey: publicKey, ...restParams }
   }
 
   async signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
@@ -288,6 +206,8 @@ export abstract class SignerProviderSimple implements SignerProvider {
 }
 
 export abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
+  abstract setSelectedAddress(address: string): Promise<void>
+
   abstract getAccounts(): Promise<Account[]>
 
   async getAccount(signerAddress: string): Promise<Account> {
@@ -300,7 +220,46 @@ export abstract class SignerProviderWithMultipleAccounts extends SignerProviderS
     }
   }
 
-  abstract setSelectedAccount(address: string): Promise<void>
+  async getPublicKey(signerAddress: string): Promise<string> {
+    const account = await this.getAccount(signerAddress)
+    return account.publicKey
+  }
+}
+
+export abstract class SignerProviderWithCachedAccounts<T extends Account> extends SignerProviderWithMultipleAccounts {
+  private _selectedAccount: T | undefined = undefined
+  protected readonly _accounts = new Map<Address, T>()
+
+  getSelectedAccount(): Promise<T> {
+    if (this._selectedAccount === undefined) {
+      throw Error('No account is selected yet')
+    } else {
+      return Promise.resolve(this._selectedAccount)
+    }
+  }
+
+  setSelectedAddress(address: string): Promise<void> {
+    const accountOpt = this._accounts.get(address)
+    if (accountOpt === undefined) {
+      throw Error('The address is not in the accounts')
+    } else {
+      this._selectedAccount = accountOpt
+      return Promise.resolve()
+    }
+  }
+
+  getAccounts(): Promise<T[]> {
+    return Promise.resolve(Array.from(this._accounts.values()))
+  }
+
+  override async getAccount(address: string): Promise<T> {
+    const account = this._accounts.get(address)
+    if (account === undefined) {
+      throw Error('The address is not in the accounts')
+    }
+
+    return Promise.resolve(account)
+  }
 }
 
 export function verifyHexString(hexString: string, publicKey: string, signature: string): boolean {
@@ -322,15 +281,6 @@ export function verifySignedMessage(message: string, publicKey: string, signatur
   return verifyHexString(utils.binToHex(messageHash), publicKey, signature)
 }
 
-export interface Destination {
-  address: string
-  attoAlphAmount: Number256
-  tokens?: Token[]
-  lockTime?: number
-  message?: string
-}
-assertType<Eq<keyof Destination, keyof node.Destination>>
-
 export function toApiDestination(data: Destination): node.Destination {
   return { ...data, attoAlphAmount: toApiNumber256(data.attoAlphAmount), tokens: toApiTokens(data.tokens) }
 }

package/src/signer/types.ts

@@ -0,0 +1,148 @@
+/*
+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 { Number256, Token } from '../api'
+import { node } from '../api'
+import { Eq, assertType } from '../utils'
+
+export type Address = string
+
+export type OutputRef = node.OutputRef
+
+export interface Destination {
+  address: string
+  attoAlphAmount: Number256
+  tokens?: Token[]
+  lockTime?: number
+  message?: string
+}
+assertType<Eq<keyof Destination, keyof node.Destination>>
+
+export interface Account {
+  address: string
+  group: number
+  publicKey: string
+}
+
+export type SignerAddress = { signerAddress: string }
+type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'targetBlockHash'> & SignerAddress
+type SignResult<T> = Omit<T, 'gasPrice'> & { signature: string; gasPrice: Number256 }
+
+export interface SignTransferTxParams {
+  signerAddress: string
+  destinations: Destination[]
+  utxos?: OutputRef[]
+  gasAmount?: number
+  gasPrice?: Number256
+}
+assertType<Eq<keyof SignTransferTxParams, keyof TxBuildParams<node.BuildTransaction>>>()
+export interface SignTransferTxResult {
+  fromGroup: number
+  toGroup: number
+  unsignedTx: string
+  txId: string
+  signature: string
+  gasAmount: number
+  gasPrice: Number256
+}
+assertType<Eq<SignTransferTxResult, SignResult<node.BuildTransactionResult>>>()
+
+export interface SignDeployContractTxParams {
+  signerAddress: string
+  bytecode: string
+  initialAttoAlphAmount?: Number256
+  initialTokenAmounts?: Token[]
+  issueTokenAmount?: Number256
+  gasAmount?: number
+  gasPrice?: Number256
+}
+assertType<Eq<keyof SignDeployContractTxParams, keyof TxBuildParams<node.BuildDeployContractTx>>>()
+export interface SignDeployContractTxResult {
+  fromGroup: number
+  toGroup: number
+  unsignedTx: string
+  txId: string
+  signature: string
+  contractId: string
+  contractAddress: string
+  gasAmount: number
+  gasPrice: Number256
+}
+assertType<Eq<SignDeployContractTxResult, SignResult<node.BuildDeployContractTxResult> & { contractId: string }>>()
+
+export interface SignExecuteScriptTxParams {
+  signerAddress: string
+  bytecode: string
+  attoAlphAmount?: Number256
+  tokens?: Token[]
+  gasAmount?: number
+  gasPrice?: Number256
+}
+assertType<Eq<keyof SignExecuteScriptTxParams, keyof TxBuildParams<node.BuildExecuteScriptTx>>>()
+export interface SignExecuteScriptTxResult {
+  fromGroup: number
+  toGroup: number
+  unsignedTx: string
+  txId: string
+  signature: string
+  gasAmount: number
+  gasPrice: Number256
+}
+assertType<Eq<SignExecuteScriptTxResult, SignResult<node.BuildExecuteScriptTxResult>>>()
+
+export interface SignUnsignedTxParams {
+  signerAddress: string
+  unsignedTx: string
+}
+assertType<Eq<SignUnsignedTxParams, { unsignedTx: string } & SignerAddress>>()
+export interface SignUnsignedTxResult {
+  fromGroup: number
+  toGroup: number
+  unsignedTx: string
+  txId: string
+  signature: string
+  gasAmount: number
+  gasPrice: Number256
+}
+assertType<Eq<SignUnsignedTxResult, SignTransferTxResult>>
+
+export interface SignMessageParams {
+  signerAddress: string
+  message: string
+}
+assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
+export interface SignMessageResult {
+  signature: string
+}
+
+export interface SubmitTransactionParams {
+  unsignedTx: string
+  signature: string
+}
+export interface SubmissionResult {
+  txId: string
+  fromGroup: number
+  toGroup: number
+}
+
+export interface EnableOptionsBase {
+  // chainGroup - specify whether to use addresses from a specific group
+  chainGroup?: number
+  onDisconnected: () => Promise<void>
+  onNetworkChanged: (network: { networkName: string; networkId: number }) => Promise<void>
+}

package/src/transaction/index.ts

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

package/src/transaction/sign-verify.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 * as utils from '../utils'
+import { ec as EC } from 'elliptic'
+
+const ec = new EC('secp256k1')
+
+export function transactionSign(txHash: string, privateKey: string): string {
+  const keyPair = ec.keyFromPrivate(privateKey)
+  const signature = keyPair.sign(txHash)
+
+  return utils.encodeSignature(signature)
+}
+
+export function transactionVerifySignature(txHash: string, publicKey: string, signature: string): boolean {
+  try {
+    const key = ec.keyFromPublic(publicKey, 'hex')
+    return key.verify(txHash, utils.signatureDecode(ec, signature))
+  } catch (error) {
+    return false
+  }
+}

package/webpack.config.js

@@ -41,6 +41,7 @@ module.exports = {
       fs: false,
       stream: require.resolve('stream-browserify'),
       crypto: require.resolve('crypto-browserify'),
+      path: require.resolve('path-browserify'),
       buffer: require.resolve('buffer/')
     }
   },