@alephium/web3 1.7.3 → 1.8.0

package/src/contract/contract.ts

@@ -2046,12 +2046,14 @@ function toFieldsSig(contractName: string, functionSig: FunctionSig): FieldsSig
   }
 }
 
+type Calls = Record<string, Optional<CallContractParams<any>, 'args'>>
 export async function multicallMethods<I extends ContractInstance, F extends Fields>(
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
-  callss: Record<string, Optional<CallContractParams<any>, 'args'>>[],
+  _callss: Calls | Calls[],
   getContractByCodeHash: (codeHash: string) => Contract
 ): Promise<Record<string, CallContractResult<any>>[] | Record<string, CallContractResult<any>>> {
+  const callss = Array.isArray(_callss) ? _callss : [_callss]
   const callEntries = callss.map((calls) => Object.entries(calls))
   const callsParams = callEntries.map((entries) => {
     return entries.map((entry) => {
@@ -2068,7 +2070,7 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
   })
   const result = await getCurrentNodeProvider().contracts.postContractsMulticallContract({ calls: callsParams.flat() })
   let callResultIndex = 0
-  return callsParams.map((calls, index0) => {
+  const results = callsParams.map((calls, index0) => {
     const callsResult: Record<string, CallContractResult<any>> = {}
     const entries = callEntries[`${index0}`]
     calls.forEach((call, index1) => {
@@ -2085,6 +2087,7 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
     })
     return callsResult
   })
+  return Array.isArray(_callss) ? results : results[0]
 }
 
 export async function getContractEventsCurrentCount(contractAddress: Address): Promise<number> {

package/src/signer/signer.ts

@@ -28,7 +28,6 @@ import {
   Destination,
   SignDeployContractTxParams,
   SignDeployContractTxResult,
-  SignerAddress,
   SignExecuteScriptTxParams,
   SignExecuteScriptTxResult,
   SignMessageParams,
@@ -40,7 +39,9 @@ import {
   SubmissionResult,
   SubmitTransactionParams,
   KeyType,
-  MessageHasher
+  MessageHasher,
+  SignChainedTxParams,
+  SignChainedTxResult
 } from './types'
 import { TransactionBuilder } from './tx-builder'
 import { addressFromPublicKey, groupOfAddress } from '../address'
@@ -68,6 +69,7 @@ export abstract class SignerProvider {
   abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
   abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
   abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract signAndSubmitChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>
 
   abstract signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
   // The message will be prefixed with 'Alephium Signed Message: ' before signing
@@ -117,17 +119,16 @@ export abstract class SignerProviderSimple extends SignerProvider {
     await this.submitTransaction(signResult)
     return signResult
   }
+  override async signAndSubmitChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]> {
+    const signResults = await this.signChainedTx(params)
+    for (const r of signResults) {
+      await this.submitTransaction(r)
+    }
+    return signResults
+  }
 
   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 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)
@@ -169,6 +170,19 @@ export abstract class SignerProviderSimple extends SignerProvider {
     )
   }
 
+  async signChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]> {
+    const response = await this.buildChainedTx(params)
+    const signatures = await Promise.all(response.map((r, i) => this.signRaw(params[`${i}`].signerAddress, r.txId)))
+    return response.map((r, i) => ({ ...r, signature: signatures[`${i}`] } as SignChainedTxResult))
+  }
+
+  async buildChainedTx(params: SignChainedTxParams[]): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
+    return TransactionBuilder.from(this.nodeProvider).buildChainedTx(
+      params,
+      await Promise.all(params.map((p) => this.getPublicKey(p.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> {

package/src/signer/tx-builder.ts

@@ -21,20 +21,26 @@ import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiToke
 import { addressFromPublicKey, contractIdFromAddress } from '../address'
 import { toApiDestinations } from './signer'
 import {
+  SignChainedTxParams,
+  SignChainedTxResult,
   KeyType,
+  SignDeployContractChainedTxResult,
   SignDeployContractTxParams,
   SignDeployContractTxResult,
   SignerAddress,
+  SignExecuteScriptChainedTxResult,
   SignExecuteScriptTxParams,
   SignExecuteScriptTxResult,
+  SignTransferChainedTxResult,
   SignTransferTxParams,
   SignTransferTxResult,
   SignUnsignedTxParams,
   SignUnsignedTxResult
 } from './types'
-import { unsignedTxCodec, UnsignedTxCodec } from '../codec'
+import { unsignedTxCodec } from '../codec'
 import { groupIndexOfTransaction } from '../transaction'
 import { blakeHash } from '../codec/hash'
+import { BuildDeployContractTxResult, BuildChainedTx, BuildChainedTxResult } from '../api/api-alephium'
 
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider
@@ -62,28 +68,129 @@ export abstract class TransactionBuilder {
     params: SignTransferTxParams,
     publicKey: string
   ): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    const data = this.buildTransferTxParams(params, publicKey)
+    const response = await this.nodeProvider.transactions.postTransactionsBuild(data)
+    return this.convertTransferTxResult(response)
+  }
+
+  async buildDeployContractTx(
+    params: SignDeployContractTxParams,
+    publicKey: string
+  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+    const data = this.buildDeployContractTxParams(params, publicKey)
+    const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
+    return this.convertDeployContractTxResult(response)
+  }
+
+  async buildExecuteScriptTx(
+    params: SignExecuteScriptTxParams,
+    publicKey: string
+  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    const data = this.buildExecuteScriptTxParams(params, publicKey)
+    const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data)
+    return this.convertExecuteScriptTxResult(response)
+  }
+
+  async buildChainedTx(
+    params: SignChainedTxParams[],
+    publicKeys: string[]
+  ): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
+    if (params.length !== publicKeys.length) {
+      throw new Error(
+        'The number of build chained transaction parameters must match the number of public keys provided'
+      )
+    }
+
+    const data: BuildChainedTx[] = params.map((param, index) => {
+      const paramType = param.type
+      switch (paramType) {
+        case 'Transfer': {
+          const value = this.buildTransferTxParams(param, publicKeys[index])
+          return { type: paramType, value }
+        }
+        case 'DeployContract': {
+          const value = this.buildDeployContractTxParams(param, publicKeys[index])
+          return { type: paramType, value }
+        }
+        case 'ExecuteScript': {
+          const value = this.buildExecuteScriptTxParams(param, publicKeys[index])
+          return { type: paramType, value }
+        }
+        default:
+          throw new Error(`Unsupported transaction type: ${paramType}`)
+      }
+    })
+
+    const buildChainedTxsResponse = await this.nodeProvider.transactions.postTransactionsBuildChained(data)
+
+    const results = buildChainedTxsResponse.map((buildResult) => {
+      const buildResultType = buildResult.type
+      switch (buildResultType) {
+        case 'Transfer': {
+          const buildTransferTxResult = buildResult.value
+          return {
+            ...this.convertTransferTxResult(buildTransferTxResult),
+            type: buildResultType
+          }
+        }
+        case 'DeployContract': {
+          const buildDeployContractTxResult = buildResult.value as BuildDeployContractTxResult
+          return {
+            ...this.convertDeployContractTxResult(buildDeployContractTxResult),
+            type: buildResultType
+          } as SignDeployContractChainedTxResult
+        }
+        case 'ExecuteScript': {
+          const buildExecuteScriptTxResult = buildResult.value
+          return {
+            ...this.convertExecuteScriptTxResult(buildExecuteScriptTxResult),
+            type: buildResultType
+          } as SignExecuteScriptChainedTxResult
+        }
+        default:
+          throw new Error(`Unexpected transaction type: ${buildResultType} for ${buildResult.value.txId}`)
+      }
+    })
+
+    return results
+  }
+
+  buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'> {
+    const unsignedTxBin = hexToBinUnsafe(params.unsignedTx)
+    const decoded = unsignedTxCodec.decode(unsignedTxBin)
+    const txId = binToHex(blakeHash(unsignedTxBin))
+    const [fromGroup, toGroup] = groupIndexOfTransaction(decoded)
+    return {
+      fromGroup: fromGroup,
+      toGroup: toGroup,
+      unsignedTx: params.unsignedTx,
+      txId: txId,
+      gasAmount: decoded.gasAmount,
+      gasPrice: decoded.gasPrice
+    }
+  }
+
+  private buildTransferTxParams(params: SignTransferTxParams, publicKey: string): node.BuildTransferTx {
     TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { destinations, gasPrice, ...rest } = params
-    const data: node.BuildTransaction = {
+    return {
       fromPublicKey: publicKey,
       fromPublicKeyType: params.signerKeyType,
       destinations: toApiDestinations(destinations),
       gasPrice: toApiNumber256Optional(gasPrice),
       ...rest
     }
-    const response = await this.nodeProvider.transactions.postTransactionsBuild(data)
-    return { ...response, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
-  async buildDeployContractTx(
+  private buildDeployContractTxParams(
     params: SignDeployContractTxParams,
     publicKey: string
-  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+  ): node.BuildDeployContractTx {
     TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params
-    const data: node.BuildDeployContractTx = {
+    return {
       fromPublicKey: publicKey,
       fromPublicKeyType: params.signerKeyType,
       initialAttoAlphAmount: toApiNumber256Optional(initialAttoAlphAmount),
@@ -92,19 +199,13 @@ export abstract class TransactionBuilder {
       gasPrice: toApiNumber256Optional(gasPrice),
       ...rest
     }
-    const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
-    const contractId = binToHex(contractIdFromAddress(response.contractAddress))
-    return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
-  async buildExecuteScriptTx(
-    params: SignExecuteScriptTxParams,
-    publicKey: string
-  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+  private buildExecuteScriptTxParams(params: SignExecuteScriptTxParams, publicKey: string): node.BuildExecuteScriptTx {
     TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { attoAlphAmount, tokens, gasPrice, ...rest } = params
-    const data: node.BuildExecuteScriptTx = {
+    return {
       fromPublicKey: publicKey,
       fromPublicKeyType: params.signerKeyType,
       attoAlphAmount: toApiNumber256Optional(attoAlphAmount),
@@ -112,22 +213,34 @@ export abstract class TransactionBuilder {
       gasPrice: toApiNumber256Optional(gasPrice),
       ...rest
     }
-    const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data)
-    return { ...response, groupIndex: response.fromGroup, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
-  buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'> {
-    const unsignedTxBin = hexToBinUnsafe(params.unsignedTx)
-    const decoded = unsignedTxCodec.decode(unsignedTxBin)
-    const txId = binToHex(blakeHash(unsignedTxBin))
-    const [fromGroup, toGroup] = groupIndexOfTransaction(decoded)
+  private convertTransferTxResult(result: node.BuildTransferTxResult): Omit<SignTransferTxResult, 'signature'> {
     return {
-      fromGroup: fromGroup,
-      toGroup: toGroup,
-      unsignedTx: params.unsignedTx,
-      txId: txId,
-      gasAmount: decoded.gasAmount,
-      gasPrice: decoded.gasPrice
+      ...result,
+      gasPrice: fromApiNumber256(result.gasPrice)
+    }
+  }
+
+  private convertDeployContractTxResult(
+    result: node.BuildDeployContractTxResult
+  ): Omit<SignDeployContractTxResult, 'signature'> {
+    const contractId = binToHex(contractIdFromAddress(result.contractAddress))
+    return {
+      ...result,
+      groupIndex: result.fromGroup,
+      contractId,
+      gasPrice: fromApiNumber256(result.gasPrice)
+    }
+  }
+
+  private convertExecuteScriptTxResult(
+    result: node.BuildExecuteScriptTxResult
+  ): Omit<SignExecuteScriptTxResult, 'signature'> {
+    return {
+      ...result,
+      groupIndex: result.fromGroup,
+      gasPrice: fromApiNumber256(result.gasPrice)
     }
   }
 }

package/src/signer/types.ts

@@ -54,7 +54,7 @@ export interface SignTransferTxParams {
   gasAmount?: number
   gasPrice?: Number256
 }
-assertType<Eq<keyof SignTransferTxParams, keyof TxBuildParams<node.BuildTransaction>>>()
+assertType<Eq<keyof SignTransferTxParams, keyof TxBuildParams<node.BuildTransferTx>>>()
 export interface SignTransferTxResult {
   fromGroup: number
   toGroup: number
@@ -64,7 +64,7 @@ export interface SignTransferTxResult {
   gasAmount: number
   gasPrice: Number256
 }
-assertType<Eq<SignTransferTxResult, SignResult<node.BuildTransactionResult>>>()
+assertType<Eq<SignTransferTxResult, SignResult<node.BuildTransferTxResult>>>()
 
 export interface SignDeployContractTxParams {
   signerAddress: string
@@ -138,6 +138,26 @@ export interface SignUnsignedTxResult {
 }
 assertType<Eq<SignUnsignedTxResult, SignTransferTxResult>>
 
+export type SignTransferChainedTxParams = SignTransferTxParams & { type: 'Transfer' }
+export type SignDeployContractChainedTxParams = SignDeployContractTxParams & {
+  type: 'DeployContract'
+}
+export type SignExecuteScriptChainedTxParams = SignExecuteScriptTxParams & { type: 'ExecuteScript' }
+export type SignChainedTxParams =
+  | SignTransferChainedTxParams
+  | SignDeployContractChainedTxParams
+  | SignExecuteScriptChainedTxParams
+
+export type SignTransferChainedTxResult = SignTransferTxResult & { type: 'Transfer' }
+export type SignDeployContractChainedTxResult = SignDeployContractTxResult & {
+  type: 'DeployContract'
+}
+export type SignExecuteScriptChainedTxResult = SignExecuteScriptTxResult & { type: 'ExecuteScript' }
+export type SignChainedTxResult =
+  | SignTransferChainedTxResult
+  | SignDeployContractChainedTxResult
+  | SignExecuteScriptChainedTxResult
+
 export type MessageHasher =
   | 'alephium' // Message is prefixed with 'Alephium signed message: ' before hashed with blake2b
   | 'sha256'

package/src/utils/utils.ts

@@ -169,3 +169,11 @@ export type Eq<X, Y> = _Eq<{ [P in keyof X]: X[P] }, { [P in keyof Y]: Y[P] }>
 // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
 export function assertType<T extends true>(): void {}
 export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>
+
+export type Narrow<type> =
+  | (unknown extends type ? unknown : never)
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (type extends Function ? type : never)
+  | (type extends bigint | boolean | number | string ? type : never)
+  | (type extends [] ? [] : never)
+  | { [K in keyof type]: Narrow<type[K]> }