@alephium/web3 0.2.0-test.0 → 0.2.0

package/src/contract/events.ts

@@ -16,14 +16,15 @@ 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 { ContractEvent } from '../api/api-alephium'
+import { web3 } from '..'
+import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
-export class EventSubscription extends Subscription<ContractEvent> {
+export class EventSubscription extends Subscription<node.ContractEvent> {
   readonly contractAddress: string
   private fromCount: number
 
-  constructor(options: SubscribeOptions<ContractEvent>, contractAddress: string, fromCount?: number) {
+  constructor(options: SubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
     super(options)
     this.contractAddress = contractAddress
     this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
@@ -31,7 +32,7 @@ export class EventSubscription extends Subscription<ContractEvent> {
     this.startPolling()
   }
 
-  override startPolling() {
+  override startPolling(): void {
     this.eventEmitter.on('tick', async () => {
       await this.polling()
     })
@@ -42,9 +43,9 @@ export class EventSubscription extends Subscription<ContractEvent> {
     return this.fromCount
   }
 
-  override async polling() {
+  override async polling(): Promise<void> {
     try {
-      const events = await this.provider.events.getEventsContractContractaddress(this.contractAddress, {
+      const events = await web3.getCurrentNodeProvider().events.getEventsContractContractaddress(this.contractAddress, {
         start: this.fromCount
       })
       if (this.cancelled) {
@@ -67,7 +68,7 @@ export class EventSubscription extends Subscription<ContractEvent> {
 }
 
 export function subscribeToEvents(
-  options: SubscribeOptions<ContractEvent>,
+  options: SubscribeOptions<node.ContractEvent>,
   contractAddress: string,
   fromCount?: number
 ): EventSubscription {

package/src/contract/ralph.ts

@@ -17,9 +17,9 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Buffer } from 'buffer/'
+import { Val } from '../api'
 import { bs58, isHexString } from '../utils'
-import { node } from '../api'
-import { Fields, Val } from './contract'
+import { Fields, FieldsSig } from './contract'
 
 const bigIntZero = BigInt(0)
 
@@ -236,7 +236,7 @@ export function encodeScriptField(tpe: string, value: Val): Uint8Array {
 
 const scriptFieldRegex = /\{([0-9]*)\}/g
 
-export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: FieldsSig): string {
   return bytecodeTemplate.replace(scriptFieldRegex, (_, fieldIndex: string) => {
     const fieldName = fieldsSig.names[`${fieldIndex}`]
     const fieldType = fieldsSig.types[`${fieldIndex}`]
@@ -249,7 +249,7 @@ export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fi
   })
 }
 
-export function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+export function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: FieldsSig): string {
   const fieldsEncoded = fieldsSig.names.flatMap((fieldName, fieldIndex) => {
     const fieldType = fieldsSig.types[`${fieldIndex}`]
     if (fieldName in fields) {
@@ -343,6 +343,31 @@ function invalidVal(tpe: string, value: Val): Error {
   return Error(`Invalid API value ${value} for type ${tpe}`)
 }
 
+export function buildDebugBytecode(bytecode: string, bytecodePatch: string): string {
+  if (bytecodePatch === '') {
+    return bytecode
+  }
+
+  const pattern = /[=+-][0-9a-f]*/g
+  let result = ''
+  let index = 0
+  for (const parts of bytecodePatch.matchAll(pattern)) {
+    const part = parts[0]
+    const diffType = part[0]
+    if (diffType === '=') {
+      const length = parseInt(part.substring(1))
+      result = result + bytecode.slice(index, index + length)
+      index = index + length
+    } else if (diffType === '+') {
+      result = result + part.substring(1)
+    } else {
+      const length = parseInt(part.substring(1))
+      index = index + length
+    }
+  }
+  return result
+}
+
 // export function buildContractByteCode(
 //   compiled: node.TemplateContractByteCode,
 //   templateVariables: TemplateVariables

package/src/global.ts

@@ -0,0 +1,56 @@
+/*
+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 { ExplorerProvider, NodeProvider } from './api'
+
+let _currentNodeProvider: NodeProvider | undefined = undefined
+
+export function setCurrentNodeProvider(provider: NodeProvider): void
+export function setCurrentNodeProvider(baseUrl: string, apiKey?: string): void
+export function setCurrentNodeProvider(provider: NodeProvider | string, apiKey?: string): void {
+  if (typeof provider == 'string') {
+    _currentNodeProvider = new NodeProvider(provider, apiKey)
+  } else {
+    _currentNodeProvider = provider
+  }
+}
+
+export function getCurrentNodeProvider(): NodeProvider {
+  if (typeof _currentNodeProvider === 'undefined') {
+    throw Error('No node provider is set.')
+  }
+  return _currentNodeProvider
+}
+
+let _currentExplorerProvider: ExplorerProvider | undefined = undefined
+
+export function setCurrentExplorerProvider(provider: ExplorerProvider): void
+export function setCurrentExplorerProvider(baseUrl: string, apiKey?: string): void
+export function setCurrentExplorerProvider(provider: ExplorerProvider | string, apiKey?: string): void {
+  if (typeof provider == 'string') {
+    _currentExplorerProvider = new ExplorerProvider(provider, apiKey)
+  } else {
+    _currentExplorerProvider = provider
+  }
+}
+
+// Different from `NodeProvider`, this may return `undefined`
+// as ExplorerProvider is not necessary for all applications
+export function getCurrentExplorerProvider(): ExplorerProvider | undefined {
+  return _currentExplorerProvider
+}

package/src/index.ts

@@ -16,6 +16,10 @@ 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/>.
 */
 
+BigInt.prototype['toJSON'] = function () {
+  return this.toString()
+}
+
 export * from './api'
 export * from './contract'
 export * from './signer'
@@ -23,3 +27,6 @@ export * from './utils'
 export * from './transaction'
 
 export * from './constants'
+export * as web3 from './global'
+
+export * as utils from './utils'

package/src/signer/index.ts

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

package/src/signer/signer.ts

@@ -17,22 +17,25 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ec as EC } from 'elliptic'
-import { NodeProvider } from '../api'
+import {
+  ExplorerProvider,
+  fromApiNumber256,
+  fromApiTokens,
+  NodeProvider,
+  Number256,
+  toApiNumber256,
+  toApiNumber256Optional,
+  toApiTokens,
+  Token
+} from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
 import { Eq, assertType } from '../utils'
 import blake from 'blakejs'
-import { Token } from '../api/api-alephium'
 
-const ec = new EC('secp256k1')
+export type OutputRef = node.OutputRef
 
-export interface SignResult {
-  fromGroup: number
-  toGroup: number
-  unsignedTx: string
-  txId: string
-  signature: string
-}
+const ec = new EC('secp256k1')
 
 export interface Account {
   address: string
@@ -40,42 +43,39 @@ export interface Account {
   publicKey: string
 }
 
-export type SubmitTx = { submitTx?: boolean }
 export type SignerAddress = { signerAddress: string }
-type TxBuildParams<T> = Omit<T, 'fromPublicKey'> & SignerAddress & SubmitTx
-
-export type GetAccountsParams = undefined
-export type GetAccountsResult = Account[]
+type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'targetBlockHash'> & SignerAddress
+type SignResult<T> = Omit<T, 'gasPrice'> & { signature: string; gasPrice: Number256 }
 
 export interface SignTransferTxParams {
   signerAddress: string
-  destinations: node.Destination[]
-  utxos?: node.OutputRef[]
+  destinations: Destination[]
+  utxos?: OutputRef[]
   gasAmount?: number
-  gasPrice?: string
-  submitTx?: boolean
+  gasPrice?: Number256
 }
-assertType<Eq<SignTransferTxParams, TxBuildParams<node.BuildTransaction>>>()
+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>>()
+assertType<Eq<SignTransferTxResult, SignResult<node.BuildTransactionResult>>>()
 
 export interface SignDeployContractTxParams {
   signerAddress: string
   bytecode: string
-  initialAttoAlphAmount?: string
+  initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
-  issueTokenAmount?: string
+  issueTokenAmount?: Number256
   gasAmount?: number
-  gasPrice?: string
-  submitTx?: boolean
+  gasPrice?: Number256
 }
-assertType<Eq<SignDeployContractTxParams, TxBuildParams<node.BuildDeployContractTx>>>()
+assertType<Eq<keyof SignDeployContractTxParams, keyof TxBuildParams<node.BuildDeployContractTx>>>()
 export interface SignDeployContractTxResult {
   fromGroup: number
   toGroup: number
@@ -84,52 +84,46 @@ export interface SignDeployContractTxResult {
   signature: string
   contractId: string
   contractAddress: string
+  gasAmount: number
+  gasPrice: Number256
 }
-assertType<Eq<SignDeployContractTxResult, SignResult & { contractId: string; contractAddress: string }>>()
+assertType<Eq<SignDeployContractTxResult, SignResult<node.BuildDeployContractTxResult> & { contractId: string }>>()
 
 export interface SignExecuteScriptTxParams {
   signerAddress: string
   bytecode: string
-  attoAlphAmount?: string
-  tokens?: node.Token[]
+  attoAlphAmount?: Number256
+  tokens?: Token[]
   gasAmount?: number
-  gasPrice?: string
-  submitTx?: boolean
+  gasPrice?: Number256
 }
-assertType<Eq<SignExecuteScriptTxParams, TxBuildParams<node.BuildExecuteScriptTx>>>()
+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>>()
+assertType<Eq<SignExecuteScriptTxResult, SignResult<node.BuildExecuteScriptTxResult>>>()
 
 export interface SignUnsignedTxParams {
   signerAddress: string
   unsignedTx: string
-  submitTx?: boolean
 }
-assertType<Eq<SignUnsignedTxParams, { unsignedTx: string } & SubmitTx & SignerAddress>>()
+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, SignResult>>()
-
-export interface SignHexStringParams {
-  signerAddress: string
-  hexString: string
-}
-assertType<Eq<SignHexStringParams, { hexString: string } & SignerAddress>>()
-export interface SignHexStringResult {
-  signature: string
-}
-assertType<Eq<SignHexStringResult, Pick<SignResult, 'signature'>>>()
+assertType<Eq<SignUnsignedTxResult, SignTransferTxResult>>
 
 export interface SignMessageParams {
   signerAddress: string
@@ -139,144 +133,150 @@ assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
 export interface SignMessageResult {
   signature: string
 }
-assertType<Eq<SignMessageResult, Pick<SignResult, 'signature'>>>()
+
+export interface SubmitTransactionParams {
+  unsignedTx: string
+  signature: string
+}
+export interface SubmissionResult {
+  txId: string
+  fromGroup: number
+  toGroup: number
+}
 
 export interface SignerProvider {
-  getAccounts(): Promise<Account[]>
-  signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
-  signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  get nodeProvider(): NodeProvider | undefined
+  get explorerProvider(): ExplorerProvider | undefined
+
+  getSelectedAccount(): Promise<Account>
+
+  signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
+  signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
+  signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+
   signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  signHexString(params: SignHexStringParams): Promise<SignHexStringResult>
+  // The message will be prefixed with 'Alephium Signed Message: ' before signing
+  // so that the resulted signature cannot be reused for building transactions.
   signMessage(params: SignMessageParams): Promise<SignMessageResult>
 }
 
-export abstract class SignerWithNodeProvider implements SignerProvider {
-  readonly provider: NodeProvider
-  alwaysSubmitTx: boolean
-
-  abstract getAccounts(): Promise<Account[]>
+export abstract class SignerProviderSimple implements SignerProvider {
+  abstract get nodeProvider(): NodeProvider | undefined
+  abstract get explorerProvider(): ExplorerProvider | undefined
+  abstract getSelectedAccount(): Promise<Account>
 
-  async getAccount(signerAddress: string): Promise<Account> {
-    const accounts = await this.getAccounts()
-    const account = accounts.find((a) => a.address === signerAddress)
-    if (typeof account === 'undefined') {
-      throw new Error('Unmatched signerAddress')
-    } else {
-      return account
+  private getNodeProvider(): NodeProvider {
+    if (this.nodeProvider === undefined) {
+      throw Error('The signer does not contain a node provider')
     }
+    return this.nodeProvider
   }
 
-  constructor(provider: NodeProvider, alwaysSubmitTx: boolean) {
-    this.provider = provider
-    this.alwaysSubmitTx = alwaysSubmitTx
+  async submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult> {
+    const data: node.SubmitTransaction = { unsignedTx: params.unsignedTx, signature: params.signature }
+    return this.getNodeProvider().transactions.postTransactionsSubmit(data)
   }
 
-  private async defaultSignerAddress(): Promise<string> {
-    return (await this.getAccounts())[0].address
+  async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
+    const signResult = await this.signTransferTx(params)
+    await this.submitTransaction(signResult)
+    return signResult
   }
-
-  async submitTransaction(unsignedTx: string, txHash: string, signerAddress?: string): Promise<SubmissionResult> {
-    const address = typeof signerAddress !== 'undefined' ? signerAddress : await this.defaultSignerAddress()
-    const signature = await this.signRaw(address, txHash)
-    const params: node.SubmitTransaction = { unsignedTx: unsignedTx, signature: signature }
-    return this.provider.transactions.postTransactionsSubmit(params)
+  async signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
+    const signResult = await this.signDeployContractTx(params)
+    await this.submitTransaction(signResult)
+    return signResult
   }
-
-  private shouldSubmitTx(params: SubmitTx): boolean {
-    return this.alwaysSubmitTx || (params.submitTx ? params.submitTx : true)
+  async signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
+    const signResult = await this.signExecuteScriptTx(params)
+    await this.submitTransaction(signResult)
+    return signResult
+  }
+  async signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
+    const signResult = await this.signUnsignedTx(params)
+    await this.submitTransaction(signResult)
+    return signResult
   }
 
   private async usePublicKey<T extends SignerAddress>(
     params: T
   ): Promise<Omit<T, 'signerAddress'> & { fromPublicKey: string }> {
     const { signerAddress, ...restParams } = params
-    const allAccounts = await this.getAccounts()
-    const signerAccount = allAccounts.find((account) => account.address === signerAddress)
-    if (typeof signerAccount === 'undefined') {
-      throw new Error('Unknown signer address')
+    const selectedAccount = await this.getSelectedAccount()
+    if (signerAddress !== selectedAccount.address) {
+      throw new Error('The signer address is not the selected address')
     } else {
-      return { fromPublicKey: signerAccount.publicKey, ...restParams }
+      return { fromPublicKey: selectedAccount.publicKey, ...restParams }
     }
   }
 
   async signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
     const response = await this.buildTransferTx(params)
-    return this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params))
+    const signature = await this.signRaw(params.signerAddress, response.txId)
+    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
   async buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult> {
-    return this.provider.transactions.postTransactionsBuild(await this.usePublicKey(params))
+    const data: node.BuildTransaction = {
+      ...(await this.usePublicKey(params)),
+      destinations: toApiDestinations(params.destinations),
+      gasPrice: toApiNumber256Optional(params.gasPrice)
+    }
+    return this.getNodeProvider().transactions.postTransactionsBuild(data)
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
     const response = await this.buildContractCreationTx(params)
-    const result = await this.handleSign(
-      { signerAddress: params.signerAddress, ...response },
-      this.shouldSubmitTx(params)
-    )
+    const signature = await this.signRaw(params.signerAddress, response.txId)
     const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress))
-    return { ...result, contractId: contractId, contractAddress: response.contractAddress }
+    return { ...response, contractId, signature, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
   async buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult> {
-    return this.provider.contracts.postContractsUnsignedTxDeployContract(await this.usePublicKey(params))
+    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)
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
     const response = await this.buildScriptTx(params)
-    return this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params))
+    const signature = await this.signRaw(params.signerAddress, response.txId)
+    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
   async buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult> {
-    return this.provider.contracts.postContractsUnsignedTxExecuteScript(await this.usePublicKey(params))
+    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)
   }
 
   // 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.provider.transactions.postTransactionsDecodeUnsignedTx(data)
-    return this.handleSign(
-      {
-        fromGroup: decoded.fromGroup,
-        toGroup: decoded.toGroup,
-        signerAddress: params.signerAddress,
-        unsignedTx: params.unsignedTx,
-        txId: decoded.unsignedTx.txId
-      },
-      params.submitTx ? params.submitTx : true // we don't consider `alwaysSubmitTx` as the tx might needs multiple signatures
-    )
-  }
-
-  protected async handleSign(
-    response: { fromGroup: number; toGroup: number; signerAddress: string; unsignedTx: string; txId: string },
-    submitTx: boolean
-  ): Promise<SignResult> {
-    // sign the tx
-    const signature = await this.signRaw(response.signerAddress, response.txId)
-    // submit the tx if required
-    if (submitTx) {
-      await this.provider.transactions.postTransactionsSubmit({
-        unsignedTx: response.unsignedTx,
-        signature: signature
-      })
-    }
-    // return the signature back to the provider
+    const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data)
+    const signature = await this.signRaw(params.signerAddress, decoded.unsignedTx.txId)
     return {
-      fromGroup: response.fromGroup,
-      toGroup: response.toGroup,
-      unsignedTx: response.unsignedTx,
-      txId: response.txId,
-      signature: signature
+      fromGroup: decoded.fromGroup,
+      toGroup: decoded.toGroup,
+      unsignedTx: params.unsignedTx,
+      txId: decoded.unsignedTx.txId,
+      signature,
+      gasAmount: decoded.unsignedTx.gasAmount,
+      gasPrice: fromApiNumber256(decoded.unsignedTx.gasPrice)
     }
   }
 
-  async signHexString(params: SignHexStringParams): Promise<SignHexStringResult> {
-    const signature = await this.signRaw(params.signerAddress, params.hexString)
-    return { signature: signature }
-  }
-
   async signMessage(params: SignMessageParams): Promise<SignMessageResult> {
     const extendedMessage = extendMessage(params.message)
     const messageHash = blake.blake2b(extendedMessage, undefined, 32)
@@ -287,10 +287,20 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
   abstract signRaw(signerAddress: string, hexString: string): Promise<string>
 }
 
-export interface SubmissionResult {
-  txId: string
-  fromGroup: number
-  toGroup: number
+export abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
+  abstract getAccounts(): Promise<Account[]>
+
+  async getAccount(signerAddress: string): Promise<Account> {
+    const accounts = await this.getAccounts()
+    const account = accounts.find((a) => a.address === signerAddress)
+    if (typeof account === 'undefined') {
+      throw new Error('Unmatched signerAddress')
+    } else {
+      return account
+    }
+  }
+
+  abstract setSelectedAccount(address: string): Promise<void>
 }
 
 export function verifyHexString(hexString: string, publicKey: string, signature: string): boolean {
@@ -311,3 +321,24 @@ export function verifySignedMessage(message: string, publicKey: string, signatur
   const messageHash = blake.blake2b(extendedMessage, undefined, 32)
   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) }
+}
+
+export function toApiDestinations(data: Destination[]): node.Destination[] {
+  return data.map(toApiDestination)
+}
+
+export function fromApiDestination(data: node.Destination): Destination {
+  return { ...data, attoAlphAmount: fromApiNumber256(data.attoAlphAmount), tokens: fromApiTokens(data.tokens) }
+}

package/src/transaction/index.ts

@@ -16,5 +16,4 @@ 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 * from './sign-verify'
 export * from './status'

package/src/transaction/status.ts

@@ -16,9 +16,12 @@ 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 { TxStatus } from '../api/api-alephium'
+import { web3 } from '..'
+import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
+export type TxStatus = node.TxStatus
+
 export class TxStatusSubscription extends Subscription<TxStatus> {
   readonly txId: string
   readonly fromGroup?: number
@@ -33,9 +36,9 @@ export class TxStatusSubscription extends Subscription<TxStatus> {
     this.startPolling()
   }
 
-  override async polling() {
+  override async polling(): Promise<void> {
     try {
-      const txStatus = await this.provider.transactions.getTransactionsStatus({
+      const txStatus = await web3.getCurrentNodeProvider().transactions.getTransactionsStatus({
         txId: this.txId,
         fromGroup: this.fromGroup,
         toGroup: this.toGroup