@alephium/web3 1.12.0-beta.0 → 1.12.0-danube.1

package/src/contract/contract.ts

@@ -63,7 +63,7 @@ import {
   groupOfAddress,
   addressFromContractId,
   subContractId,
-  isGrouplessAddressWithoutGroupIndex,
+  isGrouplessAddressWithoutGroupIndex
 } from '../address'
 import { getCurrentNodeProvider } from '../global'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
@@ -96,6 +96,7 @@ import {
   BytesConst
 } from '../codec'
 import { TraceableError } from '../error'
+import { SimulationResult } from '../api/api-alephium'
 
 const crypto = new WebCrypto()
 
@@ -487,16 +488,17 @@ export class Contract extends Artifact {
       blockHash: params.blockHash,
       blockTimeStamp: params.blockTimeStamp,
       txId: params.txId,
-      address: params.address,
+      address: params.contractAddress,
       callerContractAddress: params.callerContractAddress,
       bytecode: this.isInlineFunc(methodIndex) ? this.getByteCodeForTesting() : this.bytecodeDebug,
       initialImmFields: immFields,
       initialMutFields: mutFields,
       initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
       methodIndex,
-      args: this.toApiArgs(funcName, params.testArgs),
+      args: this.toApiArgs(funcName, params.args),
       existingContracts: this.toApiContractStates(params.existingContracts),
-      inputAssets: toApiInputAssets(params.inputAssets)
+      inputAssets: toApiInputAssets(params.inputAssets),
+      dustAmount: params.dustAmount?.toString()
     }
   }
 
@@ -607,16 +609,14 @@ export class Contract extends Artifact {
       params.exposePrivateFunctions ?? false
     )
     const selectedAccount = await signer.getSelectedAccount()
-    let signerAddress = selectedAccount.address
-    if (isGrouplessAddressWithoutGroupIndex(selectedAccount.address)) {
+    if (selectedAccount.keyType === 'gl-secp256k1') {
       if (group === undefined) {
         throw new Error('Groupless address requires explicit group number for contract deployment')
       }
-      signerAddress = `${selectedAccount.address}:${group}`
     }
 
     const signerParams: SignDeployContractTxParams = {
-      signerAddress,
+      signerAddress: selectedAccount.address,
       signerKeyType: selectedAccount.keyType,
       bytecode: bytecode,
       initialAttoAlphAmount: params?.initialAttoAlphAmount,
@@ -624,7 +624,8 @@ export class Contract extends Artifact {
       issueTokenTo: params?.issueTokenTo,
       initialTokenAmounts: params?.initialTokenAmounts,
       gasAmount: params?.gasAmount,
-      gasPrice: params?.gasPrice
+      gasPrice: params?.gasPrice,
+      group: group
     }
     return signerParams
   }
@@ -790,11 +791,8 @@ export class Script extends Artifact {
     return JSON.stringify(object, null, 2)
   }
 
-  async txParamsForExecution<P extends Fields>(
-    signer: SignerProvider,
-    params: ExecuteScriptParams<P>
-  ): Promise<SignExecuteScriptTxParams> {
-    const selectedAccount = await signer.getSelectedAccount()
+  async txParamsForExecution<P extends Fields>(params: ExecuteScriptParams<P>): Promise<SignExecuteScriptTxParams> {
+    const selectedAccount = await params.signer.getSelectedAccount()
     const signerParams: SignExecuteScriptTxParams = {
       signerAddress: selectedAccount.address,
       signerKeyType: selectedAccount.keyType,
@@ -981,7 +979,7 @@ export interface TestContractParams<
   M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>
 > {
   group?: number // default 0
-  address?: string
+  contractAddress?: string
   callerContractAddress?: string
   blockHash?: string
   blockTimeStamp?: number
@@ -989,9 +987,10 @@ export interface TestContractParams<
   initialFields: F
   initialMaps?: M
   initialAsset?: Asset // default 1 ALPH
-  testArgs: A
+  args: A
   existingContracts?: ContractStateWithMaps[] // default no existing contracts
   inputAssets?: InputAsset[] // default no input asserts
+  dustAmount?: Number256
 }
 
 export interface ContractEvent<T extends Fields = Fields> {
@@ -1071,6 +1070,7 @@ export interface DeployContractParams<P extends Fields = Fields> {
   gasAmount?: number
   gasPrice?: Number256
   exposePrivateFunctions?: boolean
+  group?: number
 }
 assertType<
   Eq<
@@ -1108,9 +1108,16 @@ export abstract class ContractFactory<I extends ContractInstance, F extends Fiel
       group
     )
     const result = await signer.signAndSubmitDeployContractTx(signerParams)
-    return {
-      ...result,
-      contractInstance: this.at(result.contractAddress)
+    if ('transferTxs' in result) {
+      return {
+        ...result.tx,
+        contractInstance: this.at(result.tx.contractAddress)
+      }
+    } else {
+      return {
+        ...result,
+        contractInstance: this.at(result.contractAddress)
+      }
     }
   }
 
@@ -1150,9 +1157,15 @@ export class ExecutableScript<P extends Fields = Fields, R extends Val | null =
     this.getContractByCodeHash = getContractByCodeHash
   }
 
-  async execute(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<ExecuteScriptResult> {
-    const signerParams = await this.script.txParamsForExecution(signer, params)
-    return await signer.signAndSubmitExecuteScriptTx(signerParams)
+  async execute(params: ExecuteScriptParams<P>): Promise<ExecuteScriptResult> {
+    const signerParams = await this.script.txParamsForExecution(params)
+    const result = await params.signer.signAndSubmitExecuteScriptTx(signerParams)
+
+    if ('transferTxs' in result) {
+      return result.tx
+    } else {
+      return result
+    }
   }
 
   async call(params: CallScriptParams<P>): Promise<CallScriptResult<R>> {
@@ -1177,6 +1190,7 @@ export class ExecutableScript<P extends Fields = Fields, R extends Val | null =
 
 export interface ExecuteScriptParams<P extends Fields = Fields> {
   initialFields: P
+  signer: SignerProvider
   attoAlphAmount?: Number256
   tokens?: Token[]
   gasAmount?: number
@@ -1190,6 +1204,7 @@ export interface ExecuteScriptResult {
   signature: string
   gasAmount: number
   gasPrice: Number256
+  simulationResult: SimulationResult
 }
 
 export interface CallScriptParams<P extends Fields = Fields> {
@@ -1456,7 +1471,7 @@ function getTestExistingContracts(
   selfContract: Contract,
   selfContractId: string,
   group: number,
-  params: Optional<TestContractParams, 'testArgs' | 'initialFields'>,
+  params: Optional<TestContractParams, 'args' | 'initialFields'>,
   getContractByCodeHash: (codeHash: string) => Contract
 ): ContractState[] {
   const selfMaps = params.initialMaps ?? {}
@@ -1507,7 +1522,7 @@ function getNewCreatedContractExceptMaps(
 
 export function extractMapsFromApiResult(
   selfAddress: string,
-  params: Optional<TestContractParams, 'testArgs' | 'initialFields'>,
+  params: Optional<TestContractParams, 'args' | 'initialFields'>,
   group: number,
   apiResult: node.TestContractResult,
   getContractByCodeHash: (codeHash: string) => Contract
@@ -1540,22 +1555,23 @@ export async function testMethod<
 >(
   factory: ContractFactory<I, F>,
   methodName: string,
-  params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>,
+  params: Optional<TestContractParams<F, A, M>, 'args' | 'initialFields'>,
   getContractByCodeHash: (codeHash: string) => Contract
 ): Promise<TestContractResult<R, M>> {
   const txId = params?.txId ?? randomTxId()
   const selfContract = factory.contract
-  const selfAddress = params.address ?? addressFromContractId(binToHex(crypto.getRandomValues(new Uint8Array(32))))
+  const selfAddress =
+    params.contractAddress ?? addressFromContractId(binToHex(crypto.getRandomValues(new Uint8Array(32))))
   const selfContractId = binToHex(contractIdFromAddress(selfAddress))
   const group = params.group ?? 0
   const existingContracts = getTestExistingContracts(selfContract, selfContractId, group, params, getContractByCodeHash)
 
   const apiParams = selfContract.toApiTestContractParams(methodName, {
     ...params,
-    address: selfAddress,
+    contractAddress: selfAddress,
     txId: txId,
     initialFields: addStdIdToFields(selfContract, params.initialFields ?? {}),
-    testArgs: params.testArgs === undefined ? {} : params.testArgs,
+    args: params.args === undefined ? {} : params.args,
     existingContracts
   })
   const apiResult = await getCurrentNodeProvider().contracts.postContractsTestContract(apiParams)
@@ -1955,7 +1971,7 @@ export async function signExecuteMethod<I extends ContractInstance, F extends Fi
     gasPrice: params.gasPrice
   }
 
-  const result = await signer.signAndSubmitExecuteScriptTx(signerParams)
+  const result = (await signer.signAndSubmitExecuteScriptTx(signerParams)) as SignExecuteScriptTxResult
   if (isContractDebugMessageEnabled() && isDevnet) {
     await printDebugMessagesFromTx(result.txId, signer.nodeProvider)
   }

package/src/contract/deployment.ts

@@ -16,6 +16,7 @@ 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 { SimulationResult } from '../api/api-alephium'
 import { ContractInstance } from './contract'
 
 export interface ExecutionResult {
@@ -37,4 +38,5 @@ export interface DeployContractExecutionResult<I extends ContractInstance = Cont
 
 export interface RunScriptResult extends ExecutionResult {
   groupIndex: number
+  simulationResult: SimulationResult
 }

package/src/signer/signer.ts

@@ -41,7 +41,9 @@ import {
   KeyType,
   MessageHasher,
   SignChainedTxParams,
-  SignChainedTxResult
+  SignChainedTxResult,
+  BuildTxResult,
+  SignTxResult
 } from './types'
 import { TransactionBuilder } from './tx-builder'
 import { addressFromPublicKey, groupOfAddress } from '../address'
@@ -65,9 +67,13 @@ export abstract class SignerProvider {
     }
   }
 
-  abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
-  abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTxResult<SignTransferTxResult>>
+  abstract signAndSubmitDeployContractTx(
+    params: SignDeployContractTxParams
+  ): Promise<SignTxResult<SignDeployContractTxResult>>
+  abstract signAndSubmitExecuteScriptTx(
+    params: SignExecuteScriptTxParams
+  ): Promise<SignTxResult<SignExecuteScriptTxResult>>
   abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
   abstract signAndSubmitChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>
 
@@ -99,19 +105,55 @@ export abstract class SignerProviderSimple extends SignerProvider {
     return this.nodeProvider.transactions.postTransactionsSubmit(data)
   }
 
-  async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
+  async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTxResult<SignTransferTxResult>> {
     const signResult = await this.signTransferTx(params)
-    await this.submitTransaction(signResult)
+
+    if ('transferTxs' in signResult) {
+      for (const r of signResult.transferTxs) {
+        await this.submitTransaction(r)
+      }
+
+      await this.submitTransaction(signResult.tx)
+    } else {
+      await this.submitTransaction(signResult)
+    }
+
     return signResult
   }
-  async signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
+
+  async signAndSubmitDeployContractTx(
+    params: SignDeployContractTxParams
+  ): Promise<SignTxResult<SignDeployContractTxResult>> {
     const signResult = await this.signDeployContractTx(params)
-    await this.submitTransaction(signResult)
+
+    if ('transferTxs' in signResult) {
+      for (const r of signResult.transferTxs) {
+        await this.submitTransaction(r)
+      }
+
+      await this.submitTransaction(signResult.tx)
+    } else {
+      await this.submitTransaction(signResult)
+    }
+
     return signResult
   }
-  async signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
+
+  async signAndSubmitExecuteScriptTx(
+    params: SignExecuteScriptTxParams
+  ): Promise<SignTxResult<SignExecuteScriptTxResult>> {
     const signResult = await this.signExecuteScriptTx(params)
-    await this.submitTransaction(signResult)
+
+    if ('transferTxs' in signResult) {
+      for (const r of signResult.transferTxs) {
+        await this.submitTransaction(r)
+      }
+
+      await this.submitTransaction(signResult.tx)
+    } else {
+      await this.submitTransaction(signResult)
+    }
+
     return signResult
   }
   async signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
@@ -129,41 +171,93 @@ export abstract class SignerProviderSimple extends SignerProvider {
 
   protected abstract getPublicKey(address: string): Promise<string>
 
-  async signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
+  async signTransferTx(params: SignTransferTxParams): Promise<SignTxResult<SignTransferTxResult>> {
     const response = await this.buildTransferTx(params)
-    const signature = await this.signRaw(params.signerAddress, response.txId)
-    return { signature, ...response }
+
+    if ('transferTxs' in response) {
+      const transferTxs: SignTransferTxResult[] = []
+      for (let i = 0; i < response.transferTxs.length; i++) {
+        const txSignature = await this.signRaw(params.signerAddress, response.transferTxs[i].txId)
+        transferTxs.push({
+          ...response.transferTxs[i],
+          signature: txSignature
+        })
+      }
+
+      const signature = await this.signRaw(params.signerAddress, response.tx.txId)
+      return {
+        transferTxs,
+        tx: { ...response.tx, signature }
+      }
+    } else {
+      const signature = await this.signRaw(params.signerAddress, response.txId)
+      return { signature, ...response }
+    }
   }
 
-  async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
+  async buildTransferTx(params: SignTransferTxParams): Promise<BuildTxResult<SignTransferTxResult>> {
     return TransactionBuilder.from(this.nodeProvider).buildTransferTx(
       params,
       await this.getPublicKey(params.signerAddress)
     )
   }
 
-  async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
+  async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignTxResult<SignDeployContractTxResult>> {
     const response = await this.buildDeployContractTx(params)
-    const signature = await this.signRaw(params.signerAddress, response.txId)
-    return { signature, ...response }
+
+    if ('transferTxs' in response) {
+      const transferTxs: SignTransferTxResult[] = []
+      for (let i = 0; i < response.transferTxs.length; i++) {
+        const txSignature = await this.signRaw(params.signerAddress, response.transferTxs[i].txId)
+        transferTxs.push({
+          ...response.transferTxs[i],
+          signature: txSignature
+        })
+      }
+
+      const signature = await this.signRaw(params.signerAddress, response.tx.txId)
+      return {
+        transferTxs,
+        tx: { ...response.tx, signature }
+      }
+    } else {
+      const signature = await this.signRaw(params.signerAddress, response.txId)
+      return { signature, ...response }
+    }
   }
 
-  async buildDeployContractTx(
-    params: SignDeployContractTxParams
-  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+  async buildDeployContractTx(params: SignDeployContractTxParams): Promise<BuildTxResult<SignDeployContractTxResult>> {
     return TransactionBuilder.from(this.nodeProvider).buildDeployContractTx(
       params,
       await this.getPublicKey(params.signerAddress)
     )
   }
 
-  async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
+  async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignTxResult<SignExecuteScriptTxResult>> {
     const response = await this.buildExecuteScriptTx(params)
-    const signature = await this.signRaw(params.signerAddress, response.txId)
-    return { signature, ...response }
+
+    if ('transferTxs' in response) {
+      const transferTxs: SignTransferTxResult[] = []
+      for (let i = 0; i < response.transferTxs.length; i++) {
+        const txSignature = await this.signRaw(params.signerAddress, response.transferTxs[i].txId)
+        transferTxs.push({
+          ...response.transferTxs[i],
+          signature: txSignature
+        })
+      }
+
+      const signature = await this.signRaw(params.signerAddress, response.tx.txId)
+      return {
+        transferTxs,
+        tx: { ...response.tx, signature }
+      }
+    } else {
+      const signature = await this.signRaw(params.signerAddress, response.txId)
+      return { signature, ...response }
+    }
   }
 
-  async buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+  async buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<BuildTxResult<SignExecuteScriptTxResult>> {
     return TransactionBuilder.from(this.nodeProvider).buildExecuteScriptTx(
       params,
       await this.getPublicKey(params.signerAddress)

package/src/signer/tx-builder.ts

@@ -35,15 +35,18 @@ import {
   SignTransferTxResult,
   SignUnsignedTxParams,
   SignUnsignedTxResult,
-  SignGrouplessTransferTxParams,
-  SignGrouplessDeployContractTxParams,
-  SignTransferChainedTxResult,
-  SignGrouplessExecuteScriptTxParams
+  BuildTxResult,
+  GrouplessBuildTxResult
 } from './types'
 import { unsignedTxCodec } from '../codec'
 import { groupIndexOfTransaction } from '../transaction'
 import { blakeHash } from '../codec/hash'
-import { BuildDeployContractTxResult, BuildChainedTx, BuildExecuteScriptTxResult } from '../api/api-alephium'
+import {
+  BuildDeployContractTxResult,
+  BuildChainedTx,
+  BuildExecuteScriptTxResult,
+  BuildTransferTxResult
+} from '../api/api-alephium'
 
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider
@@ -67,10 +70,7 @@ export abstract class TransactionBuilder {
     }
   }
 
-  async buildTransferTx(
-    params: SignTransferTxParams,
-    publicKey: string
-  ): Promise<Omit<SignTransferTxResult, 'signature'>> {
+  async buildTransferTx(params: SignTransferTxParams, publicKey: string): Promise<BuildTxResult<SignTransferTxResult>> {
     const data = this.buildTransferTxParams(params, publicKey)
     const response = await this.nodeProvider.transactions.postTransactionsBuild(data)
     return this.convertTransferTxResult(response)
@@ -79,7 +79,7 @@ export abstract class TransactionBuilder {
   async buildDeployContractTx(
     params: SignDeployContractTxParams,
     publicKey: string
-  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+  ): Promise<BuildTxResult<SignDeployContractTxResult>> {
     const data = this.buildDeployContractTxParams(params, publicKey)
     const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
     return this.convertDeployContractTxResult(response)
@@ -88,7 +88,7 @@ export abstract class TransactionBuilder {
   async buildExecuteScriptTx(
     params: SignExecuteScriptTxParams,
     publicKey: string
-  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+  ): Promise<BuildTxResult<SignExecuteScriptTxResult>> {
     const data = this.buildExecuteScriptTxParams(params, publicKey)
     const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data)
     return this.convertExecuteScriptTxResult(response)
@@ -130,9 +130,9 @@ export abstract class TransactionBuilder {
       const buildResultType = buildResult.type
       switch (buildResultType) {
         case 'Transfer': {
-          const buildTransferTxResult = buildResult.value
+          const buildTransferTxResult = buildResult.value as BuildTransferTxResult
           return {
-            ...this.convertTransferTxResult(buildTransferTxResult),
+            ...(this.convertTransferTxResult(buildTransferTxResult) as Omit<SignTransferTxResult, 'signature'>),
             type: buildResultType
           }
         }
@@ -158,51 +158,6 @@ export abstract class TransactionBuilder {
     return results
   }
 
-  async buildGrouplessTransferTx(
-    params: SignGrouplessTransferTxParams
-  ): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
-    const data = this.buildGrouplessTransferTxParams(params)
-    const response = await this.nodeProvider.groupless.postGrouplessTransfer(data)
-    return response.map((result) => {
-      return {
-        ...this.convertTransferTxResult(result),
-        type: 'Transfer' as const
-      }
-    })
-  }
-
-  async buildGrouplessDeployContractTx(
-    params: SignGrouplessDeployContractTxParams
-  ): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
-    const data = this.buildGrouplessDeployContractTxParams(params)
-    const response = await this.nodeProvider.groupless.postGrouplessDeployContract(data)
-    const transferTxs = response.transferTxs.map((result) => ({
-      ...this.convertTransferTxResult(result),
-      type: 'Transfer' as const
-    }))
-    const deployContractTx = {
-      ...this.convertDeployContractTxResult(response.deployContractTx),
-      type: 'DeployContract' as const
-    }
-    return [...transferTxs, deployContractTx]
-  }
-
-  async buildGrouplessExecuteScriptTx(
-    params: SignGrouplessExecuteScriptTxParams
-  ): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
-    const data = this.buildGrouplessExecuteScriptTxParams(params)
-    const response = await this.nodeProvider.groupless.postGrouplessExecuteScript(data)
-    const transferTxs = response.transferTxs.map((result) => ({
-      ...this.convertTransferTxResult(result),
-      type: 'Transfer' as const
-    }))
-    const executeScriptTx = {
-      ...this.convertExecuteScriptTxResult(response.executeScriptTx),
-      type: 'ExecuteScript' as const
-    }
-    return [...transferTxs, executeScriptTx]
-  }
-
   static buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'> {
     const unsignedTxBin = hexToBinUnsafe(params.unsignedTx)
     const decoded = unsignedTxCodec.decode(unsignedTxBin)
@@ -231,44 +186,6 @@ export abstract class TransactionBuilder {
     }
   }
 
-  private buildGrouplessTransferTxParams(params: SignGrouplessTransferTxParams): node.BuildGrouplessTransferTx {
-    return {
-      fromAddress: params.fromAddress,
-      destinations: toApiDestinations(params.destinations),
-      gasPrice: toApiNumber256Optional(params.gasPrice),
-      targetBlockHash: params.targetBlockHash
-    }
-  }
-
-  private buildGrouplessDeployContractTxParams(
-    params: SignGrouplessDeployContractTxParams
-  ): node.BuildGrouplessDeployContractTx {
-    return {
-      fromAddress: params.fromAddress,
-      bytecode: params.bytecode,
-      initialAttoAlphAmount: toApiNumber256Optional(params.initialAttoAlphAmount),
-      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
-      issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
-      issueTokenTo: params.issueTokenTo,
-      gasPrice: toApiNumber256Optional(params.gasPrice),
-      targetBlockHash: params.targetBlockHash
-    }
-  }
-
-  private buildGrouplessExecuteScriptTxParams(
-    params: SignGrouplessExecuteScriptTxParams
-  ): node.BuildGrouplessExecuteScriptTx {
-    return {
-      fromAddress: params.fromAddress,
-      bytecode: params.bytecode,
-      attoAlphAmount: toApiNumber256Optional(params.attoAlphAmount),
-      tokens: toApiTokens(params.tokens),
-      gasPrice: toApiNumber256Optional(params.gasPrice),
-      targetBlockHash: params.targetBlockHash,
-      gasEstimationMultiplier: params.gasEstimationMultiplier
-    }
-  }
-
   private buildDeployContractTxParams(
     params: SignDeployContractTxParams,
     publicKey: string
@@ -301,7 +218,21 @@ export abstract class TransactionBuilder {
     }
   }
 
-  private convertTransferTxResult(result: node.BuildTransferTxResult): Omit<SignTransferTxResult, 'signature'> {
+  private convertTransferTxResult(result: node.BuildTransferTxResult): BuildTxResult<SignTransferTxResult> {
+    // BuildGrouplessTransferTxResult
+    if ('transferTxs' in result) {
+      return {
+        transferTxs: result.transferTxs.map((r) => ({
+          ...r,
+          gasPrice: fromApiNumber256(r.gasPrice)
+        })),
+        tx: {
+          ...result.transferTx,
+          gasPrice: fromApiNumber256(result.transferTx.gasPrice)
+        }
+      }
+    }
+
     return {
       ...result,
       gasPrice: fromApiNumber256(result.gasPrice)
@@ -310,7 +241,23 @@ export abstract class TransactionBuilder {
 
   private convertDeployContractTxResult(
     result: node.BuildDeployContractTxResult
-  ): Omit<SignDeployContractTxResult, 'signature'> {
+  ): BuildTxResult<SignDeployContractTxResult> {
+    if ('transferTxs' in result) {
+      const contractId = binToHex(contractIdFromAddress(result.deployContractTx.contractAddress))
+      return {
+        transferTxs: result.transferTxs.map((r) => ({
+          ...r,
+          gasPrice: fromApiNumber256(r.gasPrice)
+        })),
+        tx: {
+          ...result.deployContractTx,
+          groupIndex: result.deployContractTx.fromGroup,
+          contractId,
+          gasPrice: fromApiNumber256(result.deployContractTx.gasPrice)
+        }
+      }
+    }
+
     const contractId = binToHex(contractIdFromAddress(result.contractAddress))
     return {
       ...result,
@@ -322,7 +269,21 @@ export abstract class TransactionBuilder {
 
   private convertExecuteScriptTxResult(
     result: node.BuildExecuteScriptTxResult
-  ): Omit<SignExecuteScriptTxResult, 'signature'> {
+  ): BuildTxResult<SignExecuteScriptTxResult> {
+    if ('transferTxs' in result) {
+      return {
+        transferTxs: result.transferTxs.map((r) => ({
+          ...r,
+          gasPrice: fromApiNumber256(r.gasPrice)
+        })),
+        tx: {
+          ...result.executeScriptTx,
+          groupIndex: result.executeScriptTx.fromGroup,
+          gasPrice: fromApiNumber256(result.executeScriptTx.gasPrice)
+        }
+      }
+    }
+
     return {
       ...result,
       groupIndex: result.fromGroup,