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

package/src/signer/signer.ts

@@ -17,138 +17,43 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ec as EC } from 'elliptic'
-import {
-  ExplorerProvider,
-  fromApiNumber256,
-  fromApiTokens,
-  NodeProvider,
-  Number256,
-  toApiNumber256,
-  toApiNumber256Optional,
-  toApiTokens,
-  Token
-} from '../api'
+import { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, 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,
+  ExtSignTransferTxParams,
+  ExtSignDeployContractTxParams,
+  ExtSignExecuteScriptTxParams,
+  ExtSignUnsignedTxParams,
+  ExtSignMessageParams
+} from './types'
+import { TransactionBuilder } from './tx-builder'
 
 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,21 +66,34 @@ export interface SignerProvider {
   signMessage(params: SignMessageParams): Promise<SignMessageResult>
 }
 
-export abstract class SignerProviderSimple implements SignerProvider {
-  abstract get nodeProvider(): NodeProvider | undefined
+// Abstraction for interactive signer (e.g. WalletConnect instance, Extension wallet object)
+export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase>
+  extends SignerProvider {
+  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 extends TransactionBuilder implements SignerProvider {
   abstract get explorerProvider(): ExplorerProvider | undefined
+
   abstract getSelectedAccount(): Promise<Account>
 
-  private getNodeProvider(): NodeProvider {
-    if (this.nodeProvider === undefined) {
-      throw Error('The signer does not contain a node provider')
-    }
-    return this.nodeProvider
+  async getSelectedAddress(): Promise<Address> {
+    const account = await this.getSelectedAccount()
+    return account.address
   }
 
   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> {
@@ -199,82 +117,56 @@ 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> {
     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> {
@@ -288,6 +180,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 +194,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 +255,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/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

@@ -0,0 +1,155 @@
+/*
+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
+  networkId: string
+  onDisconnected: () => 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 }

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/')
     }
   },