@alephium/web3 0.2.0-rc.33 → 0.2.0-rc.35

package/src/contract/contract.ts

@@ -32,7 +32,6 @@ import {
   toApiVal,
   Token,
   Val,
-  toApiTokens,
   fromApiTokens,
   fromApiVals
 } from '../api'
@@ -808,30 +807,29 @@ 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),
-      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
+      initialAttoAlphAmount: params.initialAttoAlphAmount,
+      issueTokenAmount: params.issueTokenAmount,
+      initialTokenAmounts: params.initialTokenAmounts,
       gasAmount: params.gasAmount,
-      gasPrice: extractOptionalNumber256(params.gasPrice)
+      gasPrice: params.gasPrice
     }
     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,27 +894,27 @@ 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),
+      attoAlphAmount: params.attoAlphAmount,
+      tokens: params.tokens,
       gasAmount: params.gasAmount,
-      gasPrice: extractOptionalNumber256(params.gasPrice)
+      gasPrice: params.gasPrice
     }
     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 {
@@ -924,10 +922,6 @@ export class Script extends Artifact {
   }
 }
 
-function extractOptionalNumber256(v?: Val): string | undefined {
-  return typeof v !== 'undefined' ? toApiNumber256(v) : undefined
-}
-
 function fromApiFields(vals: node.Val[], fieldsSig: node.FieldsSig): Fields {
   return fromApiVals(vals, fieldsSig.names, fieldsSig.types)
 }
@@ -1098,16 +1092,12 @@ 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 {
   signerAddress: string
   initialFields?: Fields
-  initialAttoAlphAmount?: string
+  initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
   issueTokenAmount?: Number256
   gasAmount?: number

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,16 +83,18 @@ 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
+  attoAlphAmount?: Number256
   tokens?: Token[]
   gasAmount?: number
-  gasPrice?: string
+  gasPrice?: Number256
 }
 assertType<Eq<keyof SignExecuteScriptTxParams, keyof TxBuildParams<node.BuildExecuteScriptTx>>>()
 export interface SignExecuteScriptTxResult {
@@ -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,9 +132,34 @@ assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
 export interface SignMessageResult {
   signature: string
 }
-assertType<Eq<SignMessageResult, Pick<SignResult, 'signature'>>>()
 
-export abstract class SignerProvider {
+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>
+
+  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>
+  // 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 SignerProviderSimple implements SignerProvider {
   abstract get nodeProvider(): NodeProvider | undefined
   abstract getSelectedAccount(): Promise<Account>
 
@@ -157,26 +170,30 @@ export abstract class SignerProvider {
     return this.nodeProvider
   }
 
-  async submitTransaction(unsignedTx: string, signature: string): Promise<SubmissionResult> {
-    const params: node.SubmitTransaction = { unsignedTx: unsignedTx, signature: signature }
-    return this.getNodeProvider().transactions.postTransactionsSubmit(params)
+  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>(
@@ -193,7 +210,8 @@ export abstract class SignerProvider {
 
   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> {
@@ -207,9 +225,9 @@ export abstract class SignerProvider {
 
   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> {
@@ -225,13 +243,16 @@ export abstract class SignerProvider {
 
   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> {
     const data: node.BuildExecuteScriptTx = {
       ...(await this.usePublicKey(params)),
-      tokens: toApiTokens(params.tokens)
+      attoAlphAmount: toApiNumber256Optional(params.attoAlphAmount),
+      tokens: toApiTokens(params.tokens),
+      gasPrice: toApiNumber256Optional(params.gasPrice)
     }
     return this.getNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data)
   }
@@ -241,39 +262,18 @@ export abstract class SignerProvider {
   async signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
     const data = { unsignedTx: params.unsignedTx }
     const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data)
-    return this.handleSign({
+    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)
@@ -284,7 +284,7 @@ export abstract class SignerProvider {
   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> {
@@ -300,31 +300,6 @@ export abstract class SignerProviderWithMultipleAccounts extends SignerProvider
   abstract setSelectedAccount(address: string): Promise<void>
 }
 
-export class SignerProviderWrapper extends SignerProvider {
-  signer: SignerProvider
-  nodeProvider: NodeProvider
-
-  constructor(signer: SignerProvider, nodeProvider: NodeProvider) {
-    super()
-    this.signer = signer
-    this.nodeProvider = nodeProvider
-  }
-
-  getSelectedAccount(): Promise<Account> {
-    return this.signer.getSelectedAccount()
-  }
-
-  signRaw(signerAddress: string, hexString: string): Promise<string> {
-    return this.signer.signRaw(signerAddress, hexString)
-  }
-}
-
-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')