@alephium/web3 1.7.4 → 1.8.0

package/src/api/api-alephium.ts

@@ -189,6 +189,51 @@ export interface BrokerInfo {
   }
 }
 
+/** BuildChainedDeployContractTx */
+export interface BuildChainedDeployContractTx {
+  value: BuildDeployContractTx
+  type: string
+}
+
+/** BuildChainedDeployContractTxResult */
+export interface BuildChainedDeployContractTxResult {
+  value: BuildDeployContractTxResult
+  type: string
+}
+
+/** BuildChainedExecuteScriptTx */
+export interface BuildChainedExecuteScriptTx {
+  value: BuildExecuteScriptTx
+  type: string
+}
+
+/** BuildChainedExecuteScriptTxResult */
+export interface BuildChainedExecuteScriptTxResult {
+  value: BuildExecuteScriptTxResult
+  type: string
+}
+
+/** BuildChainedTransferTx */
+export interface BuildChainedTransferTx {
+  value: BuildTransferTx
+  type: string
+}
+
+/** BuildChainedTransferTxResult */
+export interface BuildChainedTransferTxResult {
+  value: BuildTransferTxResult
+  type: string
+}
+
+/** BuildChainedTx */
+export type BuildChainedTx = BuildChainedDeployContractTx | BuildChainedExecuteScriptTx | BuildChainedTransferTx
+
+/** BuildChainedTxResult */
+export type BuildChainedTxResult =
+  | BuildChainedDeployContractTxResult
+  | BuildChainedExecuteScriptTxResult
+  | BuildChainedTransferTxResult
+
 /** BuildDeployContractTx */
 export interface BuildDeployContractTx {
   /** @format hex-string */
@@ -353,8 +398,8 @@ export interface BuildSweepMultisig {
   targetBlockHash?: string
 }
 
-/** BuildTransaction */
-export interface BuildTransaction {
+/** BuildTransferTx */
+export interface BuildTransferTx {
   /** @format hex-string */
   fromPublicKey: string
   /** @format hex-string */
@@ -369,8 +414,8 @@ export interface BuildTransaction {
   targetBlockHash?: string
 }
 
-/** BuildTransactionResult */
-export interface BuildTransactionResult {
+/** BuildTransferTxResult */
+export interface BuildTransferTxResult {
   unsignedTx: string
   /** @format gas */
   gasAmount: number
@@ -1204,6 +1249,8 @@ export interface TransactionTemplate {
   unsigned: UnsignedTx
   inputSignatures: string[]
   scriptSignatures: string[]
+  /** @format int64 */
+  seenAt: number
 }
 
 /** Transfer */
@@ -1603,7 +1650,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 3.7.0
+ * @version 3.8.1
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -2529,12 +2576,12 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      *
      * @tags Transactions
      * @name PostTransactionsBuild
-     * @summary Build an unsigned transaction to a number of recipients
+     * @summary Build an unsigned transfer transaction to a number of recipients
      * @request POST:/transactions/build
      */
-    postTransactionsBuild: (data: BuildTransaction, params: RequestParams = {}) =>
+    postTransactionsBuild: (data: BuildTransferTx, params: RequestParams = {}) =>
       this.request<
-        BuildTransactionResult,
+        BuildTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
       >({
         path: `/transactions/build`,
@@ -2555,7 +2602,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      */
     postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params: RequestParams = {}) =>
       this.request<
-        BuildTransactionResult,
+        BuildTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
       >({
         path: `/transactions/build-multi-addresses`,
@@ -2652,6 +2699,32 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * No description
+     *
+     * @tags Transactions
+     * @name GetTransactionsRichDetailsTxid
+     * @summary Get transaction with enriched input information when node indexes are enabled.
+     * @request GET:/transactions/rich-details/{txId}
+     */
+    getTransactionsRichDetailsTxid: (
+      txId: string,
+      query?: {
+        /** @format int32 */
+        fromGroup?: number
+        /** @format int32 */
+        toGroup?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<RichTransaction, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/transactions/rich-details/${txId}`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * No description
      *
@@ -2728,6 +2801,27 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         query: query,
         format: 'json',
         ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * No description
+     *
+     * @tags Transactions
+     * @name PostTransactionsBuildChained
+     * @summary Build a chain of transactions
+     * @request POST:/transactions/build-chained
+     */
+    postTransactionsBuildChained: (data: BuildChainedTx[], params: RequestParams = {}) =>
+      this.request<
+        BuildChainedTxResult[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/transactions/build-chained`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
       }).then(convertHttpResponse)
   }
   mempool = {
@@ -3095,7 +3189,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      */
     postMultisigBuild: (data: BuildMultisig, params: RequestParams = {}) =>
       this.request<
-        BuildTransactionResult,
+        BuildTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
       >({
         path: `/multisig/build`,

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'