@alephium/web3 0.2.0-rc.32 → 0.2.0-rc.34

package/src/contract/contract.ts

@@ -808,10 +808,13 @@ export class Contract extends Artifact {
     }
   }
 
-  async paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams> {
+  async txParamsForDeployment(
+    signer: SignerProvider,
+    params: Omit<BuildDeployContractTx, 'signerAddress'>
+  ): Promise<SignDeployContractTxParams> {
     const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {})
     const signerParams: SignDeployContractTxParams = {
-      signerAddress: params.signerAddress,
+      signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: bytecode,
       initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
       issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
@@ -822,16 +825,12 @@ export class Contract extends Artifact {
     return signerParams
   }
 
-  async transactionForDeployment(
+  async deploy(
     signer: SignerProvider,
     params: Omit<BuildDeployContractTx, 'signerAddress'>
   ): Promise<DeployContractTransaction> {
-    const signerParams = await this.paramsForDeployment({
-      ...params,
-      signerAddress: (await signer.getSelectedAccount()).address
-    })
-    const response = await signer.buildContractCreationTx(signerParams)
-    return fromApiDeployContractUnsignedTx(response)
+    const signerParams = await this.txParamsForDeployment(signer, params)
+    return signer.signAndSubmitDeployContractTx(signerParams)
   }
 
   buildByteCodeToDeploy(initialFields: Fields): string {
@@ -896,9 +895,12 @@ export class Script extends Artifact {
     return JSON.stringify(object, null, 2)
   }
 
-  async paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams> {
+  async txParamsForExecution(
+    signer: SignerProvider,
+    params: Omit<BuildExecuteScriptTx, 'signerAddress'>
+  ): Promise<SignExecuteScriptTxParams> {
     const signerParams: SignExecuteScriptTxParams = {
-      signerAddress: params.signerAddress,
+      signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
       attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
       tokens: toApiTokens(params.tokens),
@@ -908,15 +910,12 @@ export class Script extends Artifact {
     return signerParams
   }
 
-  async transactionForDeployment(
+  async execute(
     signer: SignerProvider,
     params: Omit<BuildExecuteScriptTx, 'signerAddress'>
   ): Promise<BuildScriptTxResult> {
-    const signerParams = await this.paramsForDeployment({
-      ...params,
-      signerAddress: (await signer.getSelectedAccount()).address
-    })
-    return await signer.buildScriptTx(signerParams)
+    const signerParams = await this.txParamsForExecution(signer, params)
+    return await signer.signAndSubmitExecuteScriptTx(signerParams)
   }
 
   buildByteCodeToDeploy(initialFields: Fields): string {
@@ -1098,10 +1097,6 @@ export interface DeployContractTransaction {
   contractId: string
 }
 
-function fromApiDeployContractUnsignedTx(result: node.BuildDeployContractTxResult): DeployContractTransaction {
-  return { ...result, contractId: binToHex(contractIdFromAddress(result.contractAddress)) }
-}
-
 type BuildTxParams<T> = Omit<T, 'bytecode'> & { initialFields?: Val[] }
 
 export interface BuildDeployContractTx {

package/src/signer/signer.ts

@@ -36,14 +36,6 @@ export type OutputRef = node.OutputRef
 
 const ec = new EC('secp256k1')
 
-export interface SignResult {
-  fromGroup: number
-  toGroup: number
-  unsignedTx: string
-  txId: string
-  signature: string
-}
-
 export interface Account {
   address: string
   group: number
@@ -52,9 +44,7 @@ export interface Account {
 
 export type SignerAddress = { signerAddress: string }
 type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'targetBlockHash'> & SignerAddress
-
-export type GetAccountsParams = undefined
-export type GetAccountsResult = Account[]
+type SignResult<T> = Omit<T, 'gasPrice'> & { signature: string; gasPrice: Number256 }
 
 export interface SignTransferTxParams {
   signerAddress: string
@@ -70,8 +60,10 @@ export interface SignTransferTxResult {
   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
@@ -91,8 +83,10 @@ 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
@@ -109,8 +103,10 @@ export interface SignExecuteScriptTxResult {
   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
@@ -123,18 +119,10 @@ export interface SignUnsignedTxResult {
   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
@@ -144,42 +132,68 @@ assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
 export interface SignMessageResult {
   signature: string
 }
-assertType<Eq<SignMessageResult, Pick<SignResult, 'signature'>>>()
 
-export interface SignerProviderWithoutNodeProvider {
+export interface SubmitTransactionParams {
+  unsignedTx: string
+  signature: string
+}
+export interface SubmissionResult {
+  txId: string
+  fromGroup: number
+  toGroup: number
+}
+
+export interface SignerProvider {
+  get nodeProvider(): NodeProvider | undefined
+
   getSelectedAccount(): Promise<Account>
-  signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
-  signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+
+  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 SignerProvider implements SignerProviderWithoutNodeProvider {
-  abstract get nodeProvider(): NodeProvider
+export abstract class SignerProviderSimple implements SignerProvider {
+  abstract get nodeProvider(): NodeProvider | undefined
   abstract getSelectedAccount(): Promise<Account>
 
-  async submitTransaction(unsignedTx: string, signature: string): Promise<SubmissionResult> {
-    const params: node.SubmitTransaction = { unsignedTx: unsignedTx, signature: signature }
-    return this.nodeProvider.transactions.postTransactionsSubmit(params)
+  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)
   }
 
-  async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SubmissionResult> {
+  async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
     const signResult = await this.signTransferTx(params)
-    return this.submitTransaction(signResult.unsignedTx, signResult.signature)
+    await this.submitTransaction(signResult)
+    return signResult
   }
-  async signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SubmissionResult> {
+  async signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
     const signResult = await this.signDeployContractTx(params)
-    return this.submitTransaction(signResult.unsignedTx, signResult.signature)
+    await this.submitTransaction(signResult)
+    return signResult
   }
-  async signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SubmissionResult> {
+  async signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
     const signResult = await this.signExecuteScriptTx(params)
-    return this.submitTransaction(signResult.unsignedTx, signResult.signature)
+    await this.submitTransaction(signResult)
+    return signResult
   }
-  async signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SubmissionResult> {
+  async signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
     const signResult = await this.signUnsignedTx(params)
-    return this.submitTransaction(signResult.unsignedTx, signResult.signature)
+    await this.submitTransaction(signResult)
+    return signResult
   }
 
   private async usePublicKey<T extends SignerAddress>(
@@ -196,7 +210,8 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
 
   async signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
     const response = await this.buildTransferTx(params)
-    return this.handleSign({ signerAddress: params.signerAddress, ...response })
+    const signature = await this.signRaw(params.signerAddress, response.txId)
+    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
   async buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult> {
@@ -205,14 +220,14 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
       destinations: toApiDestinations(params.destinations),
       gasPrice: toApiNumber256Optional(params.gasPrice)
     }
-    return this.nodeProvider.transactions.postTransactionsBuild(data)
+    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 })
+    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> {
@@ -223,12 +238,13 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
       issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
       gasPrice: toApiNumber256Optional(params.gasPrice)
     }
-    return this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
+    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 })
+    const signature = await this.signRaw(params.signerAddress, response.txId)
+    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
   async buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult> {
@@ -236,47 +252,26 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
       ...(await this.usePublicKey(params)),
       tokens: toApiTokens(params.tokens)
     }
-    return this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data)
+    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.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data)
-    return this.handleSign({
+    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,
-      signerAddress: params.signerAddress,
       unsignedTx: params.unsignedTx,
-      txId: decoded.unsignedTx.txId
-    })
-  }
-
-  protected async handleSign(response: {
-    fromGroup: number
-    toGroup: number
-    signerAddress: string
-    unsignedTx: string
-    txId: string
-  }): Promise<SignResult> {
-    // sign the tx
-    const signature = await this.signRaw(response.signerAddress, response.txId)
-    // return the signature back to the provider
-    return {
-      fromGroup: response.fromGroup,
-      toGroup: response.toGroup,
-      unsignedTx: response.unsignedTx,
-      txId: response.txId,
-      signature: signature
+      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,7 +282,7 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
   abstract signRaw(signerAddress: string, hexString: string): Promise<string>
 }
 
-export abstract class SignerProviderWithMultipleAccounts extends SignerProvider {
+export abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
   abstract getAccounts(): Promise<Account[]>
 
   async getAccount(signerAddress: string): Promise<Account> {
@@ -303,12 +298,6 @@ export abstract class SignerProviderWithMultipleAccounts extends SignerProvider
   abstract setSelectedAccount(address: string): Promise<void>
 }
 
-export interface SubmissionResult {
-  txId: string
-  fromGroup: number
-  toGroup: number
-}
-
 export function verifyHexString(hexString: string, publicKey: string, signature: string): boolean {
   try {
     const key = ec.keyFromPublic(publicKey, 'hex')