@alephium/web3 1.8.5 → 1.10.0

package/src/codec/instr-codec.ts

@@ -20,7 +20,7 @@ import { ArrayCodec } from './array-codec'
 import { i256Codec, u256Codec, i32Codec } from './compact-int-codec'
 import { ByteString, byteStringCodec, byteStringsCodec } from './bytestring-codec'
 import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
-import { byteCodec, Codec } from './codec'
+import { assert, byteCodec, Codec } from './codec'
 import { intAs4BytesCodec } from './int-as-4bytes-codec'
 import { Reader } from './reader'
 export type Instr =
@@ -1263,3 +1263,58 @@ export class InstrCodec extends Codec<Instr> {
 }
 export const instrCodec = new InstrCodec()
 export const instrsCodec = new ArrayCodec<Instr>(instrCodec)
+
+function checkU256(number: bigint) {
+  if (number < 0n || number >= 2n ** 256n) {
+    throw new Error(`Invalid u256 number: ${number}`)
+  }
+}
+
+export function toU256(number: bigint) {
+  checkU256(number)
+  switch (number) {
+    case 0n:
+      return U256Const0
+    case 1n:
+      return U256Const1
+    case 2n:
+      return U256Const2
+    case 3n:
+      return U256Const3
+    case 4n:
+      return U256Const4
+    case 5n:
+      return U256Const5
+    default:
+      return U256Const(number)
+  }
+}
+
+function checkI256(number: bigint) {
+  const upperBound = 2n ** 255n
+  if (number < -upperBound || number >= upperBound) {
+    throw new Error(`Invalid i256 number: ${number}`)
+  }
+}
+
+export function toI256(number: bigint) {
+  checkI256(number)
+  switch (number) {
+    case 0n:
+      return I256Const0
+    case 1n:
+      return I256Const1
+    case 2n:
+      return I256Const2
+    case 3n:
+      return I256Const3
+    case 4n:
+      return I256Const4
+    case 5n:
+      return I256Const5
+    case -1n:
+      return I256ConstN1
+    default:
+      return I256Const(number)
+  }
+}

package/src/codec/unlock-script-codec.ts

@@ -64,3 +64,5 @@ export const unlockScriptCodec = new EnumCodec<UnlockScript>('unlock script', {
   P2SH: p2shCodec,
   SameAsPrevious: sameAsPreviousCodec
 })
+
+export const encodedSameAsPrevious = unlockScriptCodec.encode({ kind: 'SameAsPrevious', value: 'SameAsPrevious' })

package/src/constants.ts

@@ -22,7 +22,11 @@ export const MIN_UTXO_SET_AMOUNT = BigInt(1000000000000)
 export const ALPH_TOKEN_ID = ''.padStart(64, '0')
 export const ONE_ALPH = 10n ** 18n
 export const DUST_AMOUNT = 10n ** 15n
+/**
+ * @deprecated `ZERO_ADDRESS` is deprecated. Use `NULL_CONTRACT_ADDRESS` instead.
+ */
 export const ZERO_ADDRESS = 'tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq'
+export const NULL_CONTRACT_ADDRESS = 'tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq'
 export const DEFAULT_GAS_AMOUNT = 20000
 export const DEFAULT_GAS_PRICE = 10n ** 11n
 export const DEFAULT_GAS_ATTOALPH_AMOUNT = BigInt(DEFAULT_GAS_AMOUNT) * DEFAULT_GAS_PRICE

package/src/contract/contract.ts

@@ -204,6 +204,7 @@ export class Contract extends Artifact {
   readonly decodedContract: contract.Contract
 
   private bytecodeForTesting: string | undefined
+  private decodedTestingContract: contract.Contract | undefined
   private codeHashForTesting: string | undefined
 
   constructor(
@@ -239,13 +240,23 @@ export class Contract extends Artifact {
 
     this.decodedContract = contract.contractCodec.decodeContract(hexToBinUnsafe(this.bytecode))
     this.bytecodeForTesting = undefined
+    this.decodedTestingContract = undefined
     this.codeHashForTesting = undefined
   }
 
+  isInlineFunc(index: number): boolean {
+    if (index >= this.functions.length) {
+      throw new Error(`Invalid function index ${index}, function size: ${this.functions.length}`)
+    }
+    const inlineFuncFromIndex = this.decodedContract.methods.length
+    return index >= inlineFuncFromIndex
+  }
+
   getByteCodeForTesting(): string {
     if (this.bytecodeForTesting !== undefined) return this.bytecodeForTesting
 
-    if (this.publicFunctions().length == this.functions.length) {
+    const hasInlineFunction = this.functions.length > this.decodedContract.methods.length
+    if (!hasInlineFunction && this.publicFunctions().length == this.functions.length) {
       this.bytecodeForTesting = this.bytecodeDebug
       this.codeHashForTesting = this.codeHashDebug
       return this.bytecodeForTesting
@@ -263,6 +274,13 @@ export class Contract extends Artifact {
     return this.bytecodeForTesting
   }
 
+  getDecodedTestingContract() {
+    if (this.decodedTestingContract !== undefined) return this.decodedTestingContract
+    const bytecodeForTesting = hexToBinUnsafe(this.getByteCodeForTesting())
+    this.decodedTestingContract = contract.contractCodec.decodeContract(bytecodeForTesting)
+    return this.decodedTestingContract
+  }
+
   hasCodeHash(hash: string): boolean {
     return this.codeHash === hash || this.codeHashDebug === hash || this.codeHashForTesting === hash
   }
@@ -283,8 +301,10 @@ export class Contract extends Artifact {
     return this.functions.filter((_, index) => this.getDecodedMethod(index).useContractAssets)
   }
 
-  isMethodUsePreapprovedAssets(methodIndex: number): boolean {
-    return this.getDecodedMethod(methodIndex).usePreapprovedAssets
+  isMethodUsePreapprovedAssets(isDevnet: boolean, methodIndex: number): boolean {
+    if (!isDevnet || !this.isInlineFunc(methodIndex)) return this.getDecodedMethod(methodIndex).usePreapprovedAssets
+    const contract = this.getDecodedTestingContract()
+    return contract.methods[`${methodIndex}`].usePreapprovedAssets
   }
 
   // TODO: safely parse json
@@ -455,6 +475,7 @@ export class Contract extends Artifact {
           )
     const immFields = allFields.filter((f) => !f.isMutable).map((f) => toApiVal(f.value, f.type))
     const mutFields = allFields.filter((f) => f.isMutable).map((f) => toApiVal(f.value, f.type))
+    const methodIndex = this.getMethodIndex(funcName)
     return {
       group: params.group,
       blockHash: params.blockHash,
@@ -462,11 +483,11 @@ export class Contract extends Artifact {
       txId: params.txId,
       address: params.address,
       callerAddress: params.callerAddress,
-      bytecode: this.bytecodeDebug,
+      bytecode: this.isInlineFunc(methodIndex) ? this.getByteCodeForTesting() : this.bytecodeDebug,
       initialImmFields: immFields,
       initialMutFields: mutFields,
       initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
-      methodIndex: this.getMethodIndex(funcName),
+      methodIndex,
       args: this.toApiArgs(funcName, params.testArgs),
       existingContracts: this.toApiContractStates(params.existingContracts),
       inputAssets: toApiInputAssets(params.inputAssets)
@@ -1851,7 +1872,8 @@ export async function signExecuteMethod<I extends ContractInstance, F extends Fi
 ): Promise<SignExecuteScriptTxResult> {
   const methodIndex = contract.contract.getMethodIndex(methodName)
   const functionSig = contract.contract.functions[methodIndex]
-  const methodUsePreapprovedAssets = contract.contract.isMethodUsePreapprovedAssets(methodIndex)
+  const isDevnet = await contract.contract.isDevnet(params.signer)
+  const methodUsePreapprovedAssets = contract.contract.isMethodUsePreapprovedAssets(isDevnet, methodIndex)
   const bytecodeTemplate = getBytecodeTemplate(
     methodIndex,
     methodUsePreapprovedAssets,
@@ -1882,7 +1904,7 @@ export async function signExecuteMethod<I extends ContractInstance, F extends Fi
   }
 
   const result = await signer.signAndSubmitExecuteScriptTx(signerParams)
-  if (isContractDebugMessageEnabled() && (await contract.contract.isDevnet(signer))) {
+  if (isContractDebugMessageEnabled() && isDevnet) {
     await printDebugMessagesFromTx(result.txId, signer.nodeProvider)
   }
   return result
@@ -2159,3 +2181,20 @@ export const getContractIdFromUnsignedTx = async (
 
 // This function only works in the simple case where a single non-subcontract is created in the tx
 export const getTokenIdFromUnsignedTx = getContractIdFromUnsignedTx
+
+export async function getContractCodeByCodeHash(
+  nodeProvider: NodeProvider,
+  codeHash: HexString
+): Promise<HexString | undefined> {
+  if (isHexString(codeHash) && codeHash.length === 64) {
+    try {
+      return await nodeProvider.contracts.getContractsCodehashCode(codeHash)
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('not found')) {
+        return undefined
+      }
+      throw new TraceableError(`Failed to get contract by code hash ${codeHash}`, error)
+    }
+  }
+  throw new Error(`Invalid code hash: ${codeHash}`)
+}

package/src/contract/dapp-tx-builder.ts

@@ -0,0 +1,209 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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 { contractIdFromAddress, isContractAddress } from '../address'
+import { Val } from '../api'
+import {
+  AddressConst,
+  ApproveAlph,
+  ApproveToken,
+  BytesConst,
+  CallExternal,
+  ConstFalse,
+  ConstTrue,
+  Dup,
+  Instr,
+  Pop,
+  toI256,
+  toU256,
+  U256Const,
+  Method
+} from '../codec'
+import { LockupScript, lockupScriptCodec } from '../codec/lockup-script-codec'
+import { scriptCodec } from '../codec/script-codec'
+import { ALPH_TOKEN_ID } from '../constants'
+import { TraceableError } from '../error'
+import { SignExecuteScriptTxParams } from '../signer'
+import { base58ToBytes, binToHex, HexString, hexToBinUnsafe, isBase58, isHexString } from '../utils'
+
+export class DappTransactionBuilder {
+  private callerLockupScript: LockupScript
+  private approvedAssets: Map<HexString, bigint>
+  private instrs: Instr[]
+
+  constructor(public readonly callerAddress: string) {
+    try {
+      this.callerLockupScript = lockupScriptCodec.decode(base58ToBytes(this.callerAddress))
+      if (this.callerLockupScript.kind !== 'P2PKH' && this.callerLockupScript.kind !== 'P2SH') {
+        throw new Error(`Expected a P2PKH address or P2SH address`)
+      }
+    } catch (error) {
+      throw new TraceableError(`Invalid caller address: ${callerAddress}`, error)
+    }
+    this.approvedAssets = new Map<HexString, bigint>()
+    this.instrs = []
+  }
+
+  callContract(params: {
+    contractAddress: string
+    methodIndex: number
+    args: Val[]
+    attoAlphAmount?: bigint
+    tokens?: { id: HexString; amount: bigint }[]
+    retLength?: number
+  }) {
+    if (!isBase58(params.contractAddress)) {
+      throw new Error(`Invalid contract address: ${params.contractAddress}, expected a base58 string`)
+    }
+    if (!isContractAddress(params.contractAddress)) {
+      throw new Error(`Invalid contract address: ${params.contractAddress}, expected a P2C address`)
+    }
+
+    if (params.methodIndex < 0) {
+      throw new Error(`Invalid method index: ${params.methodIndex}`)
+    }
+
+    const allTokens = (params.tokens ?? []).concat([{ id: ALPH_TOKEN_ID, amount: params.attoAlphAmount ?? 0n }])
+    const instrs = [
+      ...genApproveAssets(this.callerLockupScript, this.approveTokens(allTokens)),
+      ...genContractCall(params.contractAddress, params.methodIndex, params.args, params.retLength ?? 0)
+    ]
+    this.instrs.push(...instrs)
+    return this
+  }
+
+  getResult(): SignExecuteScriptTxParams {
+    const method: Method = {
+      isPublic: true,
+      usePreapprovedAssets: this.approvedAssets.size > 0,
+      useContractAssets: false,
+      usePayToContractOnly: false,
+      argsLength: 0,
+      localsLength: 0,
+      returnLength: 0,
+      instrs: this.instrs
+    }
+    const script = { methods: [method] }
+    const bytecode = scriptCodec.encode(script)
+    const tokens = Array.from(this.approvedAssets.entries()).map(([id, amount]) => ({ id, amount }))
+    this.approvedAssets.clear()
+    this.instrs = []
+    return {
+      signerAddress: this.callerAddress,
+      signerKeyType: this.callerLockupScript.kind === 'P2PKH' ? 'default' : 'bip340-schnorr',
+      bytecode: binToHex(bytecode),
+      attoAlphAmount: tokens.find((t) => t.id === ALPH_TOKEN_ID)?.amount,
+      tokens: tokens.filter((t) => t.id !== ALPH_TOKEN_ID)
+    }
+  }
+
+  private addTokenToMap(tokenId: HexString, amount: bigint, map: Map<HexString, bigint>) {
+    const current = map.get(tokenId)
+    if (current !== undefined) {
+      map.set(tokenId, current + amount)
+    } else if (amount > 0n) {
+      map.set(tokenId, amount)
+    }
+  }
+
+  private approveTokens(tokens: { id: HexString; amount: bigint }[]): { id: HexString; amount: bigint }[] {
+    const tokenAmounts = new Map<HexString, bigint>()
+    tokens.forEach((token) => {
+      if (!(isHexString(token.id) && token.id.length === 64)) {
+        throw new Error(`Invalid token id: ${token.id}`)
+      }
+      if (token.amount < 0n) {
+        throw new Error(`Invalid token amount: ${token.amount}`)
+      }
+      this.addTokenToMap(token.id, token.amount, tokenAmounts)
+      this.addTokenToMap(token.id, token.amount, this.approvedAssets)
+    })
+    return Array.from(tokenAmounts.entries()).map(([id, amount]) => ({ id, amount }))
+  }
+}
+
+function genApproveAssets(callerLockupScript: LockupScript, tokens: { id: HexString; amount: bigint }[]): Instr[] {
+  if (tokens.length === 0) {
+    return []
+  }
+  const approveInstrs = tokens.flatMap((token) => {
+    if (token.id === ALPH_TOKEN_ID) {
+      return [U256Const(token.amount), ApproveAlph]
+    } else {
+      const tokenId = BytesConst(hexToBinUnsafe(token.id))
+      return [tokenId, U256Const(token.amount), ApproveToken]
+    }
+  })
+  return [
+    AddressConst(callerLockupScript),
+    ...Array.from(Array(tokens.length - 1).keys()).map(() => Dup),
+    ...approveInstrs
+  ]
+}
+
+function bigintToNumeric(value: bigint): Instr {
+  return value >= 0 ? toU256(value) : toI256(value)
+}
+
+function strToNumeric(str: string): Instr {
+  const regex = /^-?\d+[ui]?$/
+  if (regex.test(str)) {
+    if (str.endsWith('i')) return toI256(BigInt(str.slice(0, str.length - 1)))
+    if (str.endsWith('u')) return toU256(BigInt(str.slice(0, str.length - 1)))
+    return bigintToNumeric(BigInt(str))
+  }
+  throw new Error(`Invalid number: ${str}`)
+}
+
+function toAddressOpt(str: string): LockupScript | undefined {
+  if (!isBase58(str)) return undefined
+  try {
+    return lockupScriptCodec.decode(base58ToBytes(str))
+  } catch (_) {
+    return undefined
+  }
+}
+
+export function genArgs(args: Val[]): Instr[] {
+  return args.flatMap((arg) => {
+    if (typeof arg === 'boolean') return arg ? [ConstTrue] : [ConstFalse]
+    if (typeof arg === 'bigint') return bigintToNumeric(arg)
+    if (typeof arg === 'string') {
+      if (isHexString(arg)) return [BytesConst(hexToBinUnsafe(arg))]
+      const addressOpt = toAddressOpt(arg)
+      if (addressOpt !== undefined) return AddressConst(addressOpt)
+      return strToNumeric(arg)
+    }
+    if (Array.isArray(arg)) return genArgs(arg)
+    if (arg instanceof Map) throw new Error(`Map cannot be used as a function argument`)
+    if (typeof arg === 'object') return genArgs(Object.values(arg))
+    throw new Error(`Unknown argument type: ${typeof arg}, arg: ${arg}`)
+  })
+}
+
+function genContractCall(contractAddress: string, methodIndex: number, args: Val[], retLength: number): Instr[] {
+  const argInstrs = genArgs(args)
+  return [
+    ...argInstrs,
+    toU256(BigInt(argInstrs.length)),
+    toU256(BigInt(retLength)),
+    BytesConst(contractIdFromAddress(contractAddress)),
+    CallExternal(methodIndex),
+    ...Array.from(Array(retLength).keys()).map(() => Pop)
+  ]
+}

package/src/contract/events.ts

@@ -19,6 +19,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import * as web3 from '../global'
 import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
+import { ContractEvents } from '../api/api-alephium'
 
 export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
   onEventCountChanged?: (eventCount: number) => Promise<void> | void
@@ -40,11 +41,22 @@ export class EventSubscription extends Subscription<node.ContractEvent> {
     return this.fromCount
   }
 
+  private async getEvents(start: number): Promise<ContractEvents> {
+    try {
+      return await web3
+        .getCurrentNodeProvider()
+        .events.getEventsContractContractaddress(this.contractAddress, { start })
+    } catch (error) {
+      if (error instanceof Error && error.message.includes(`Contract events of ${this.contractAddress} not found`)) {
+        return { events: [], nextStart: start }
+      }
+      throw error
+    }
+  }
+
   override async polling(): Promise<void> {
     try {
-      const events = await web3.getCurrentNodeProvider().events.getEventsContractContractaddress(this.contractAddress, {
-        start: this.fromCount
-      })
+      const events = await this.getEvents(this.fromCount)
       if (this.fromCount === events.nextStart) {
         return
       }

package/src/contract/index.ts

@@ -21,3 +21,4 @@ export * from './contract'
 export * from './events'
 export * from './script-simulator'
 export * from './deployment'
+export { DappTransactionBuilder } from './dapp-tx-builder'

package/src/contract/ralph.ts

@@ -26,24 +26,11 @@ import {
   ConstFalse,
   ConstTrue,
   i256Codec,
-  I256Const,
-  I256Const0,
-  I256Const1,
-  I256Const2,
-  I256Const3,
-  I256Const4,
-  I256Const5,
-  I256ConstN1,
   i32Codec,
   instrCodec,
   u256Codec,
-  U256Const,
-  U256Const0,
-  U256Const1,
-  U256Const2,
-  U256Const3,
-  U256Const4,
-  U256Const5
+  toU256,
+  toI256
 } from '../codec'
 import { boolCodec } from '../codec/codec'
 import { TraceableError } from '../error'
@@ -118,43 +105,11 @@ function invalidScriptField(tpe: string, value: Val): Error {
 }
 
 function encodeScriptFieldI256(value: bigint): Uint8Array {
-  switch (value) {
-    case 0n:
-      return instrCodec.encode(I256Const0)
-    case 1n:
-      return instrCodec.encode(I256Const1)
-    case 2n:
-      return instrCodec.encode(I256Const2)
-    case 3n:
-      return instrCodec.encode(I256Const3)
-    case 4n:
-      return instrCodec.encode(I256Const4)
-    case 5n:
-      return instrCodec.encode(I256Const5)
-    case -1n:
-      return instrCodec.encode(I256ConstN1)
-    default:
-      return instrCodec.encode(I256Const(value))
-  }
+  return instrCodec.encode(toI256(value))
 }
 
 function encodeScriptFieldU256(value: bigint): Uint8Array {
-  switch (value) {
-    case 0n:
-      return instrCodec.encode(U256Const0)
-    case 1n:
-      return instrCodec.encode(U256Const1)
-    case 2n:
-      return instrCodec.encode(U256Const2)
-    case 3n:
-      return instrCodec.encode(U256Const3)
-    case 4n:
-      return instrCodec.encode(U256Const4)
-    case 5n:
-      return instrCodec.encode(U256Const5)
-    default:
-      return instrCodec.encode(U256Const(value))
-  }
+  return instrCodec.encode(toU256(value))
 }
 
 export function encodeScriptFieldAsString(tpe: string, value: Val): string {

package/src/exchange/exchange.ts

@@ -17,10 +17,10 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { AddressType, addressFromPublicKey, addressFromScript } from '../address'
-import { base58ToBytes, binToHex, hexToBinUnsafe, isHexString } from '../utils'
+import { base58ToBytes, binToHex, HexString, hexToBinUnsafe, isHexString } from '../utils'
 import { Transaction } from '../api/api-alephium'
 import { Address } from '../signer'
-import { P2SH, unlockScriptCodec } from '../codec/unlock-script-codec'
+import { encodedSameAsPrevious, P2SH, unlockScriptCodec } from '../codec/unlock-script-codec'
 import { scriptCodec } from '../codec/script-codec'
 import { TraceableError } from '../error'
 
@@ -40,19 +40,15 @@ export function isALPHTransferTx(tx: Transaction): boolean {
   return isTransferTx(tx) && checkALPHOutput(tx)
 }
 
-export function getALPHDepositInfo(tx: Transaction): { targetAddress: Address; depositAmount: bigint }[] {
-  if (!isALPHTransferTx(tx)) {
-    return []
-  }
-  const inputAddresses: Address[] = []
-  for (const input of tx.unsigned.inputs) {
-    try {
-      const address = getAddressFromUnlockScript(input.unlockScript)
-      if (!inputAddresses.includes(address)) {
-        inputAddresses.push(address)
-      }
-    } catch (_) {}
-  }
+export interface BaseDepositInfo {
+  targetAddress: Address
+  depositAmount: bigint
+}
+
+export function getALPHDepositInfo(tx: Transaction): BaseDepositInfo[] {
+  if (!isALPHTransferTx(tx)) return []
+
+  const inputAddresses = getInputAddresses(tx)
   const result = new Map<Address, bigint>()
   tx.unsigned.fixedOutputs.forEach((o) => {
     if (!inputAddresses.includes(o.address)) {
@@ -67,7 +63,63 @@ export function getALPHDepositInfo(tx: Transaction): { targetAddress: Address; d
   return Array.from(result.entries()).map(([key, value]) => ({ targetAddress: key, depositAmount: value }))
 }
 
-// we assume that the tx is a simple transfer tx, i.e. isSimpleALPHTransferTx(tx) == true
+function getInputAddresses(tx: Transaction): Address[] {
+  const inputAddresses: Address[] = []
+  for (const input of tx.unsigned.inputs) {
+    try {
+      if (input.unlockScript === binToHex(encodedSameAsPrevious)) continue
+      const address = getAddressFromUnlockScript(input.unlockScript)
+      if (!inputAddresses.includes(address)) {
+        inputAddresses.push(address)
+      }
+    } catch (error) {
+      throw new TraceableError(`Failed to decode address from unlock script`, error)
+    }
+  }
+  return inputAddresses
+}
+
+export interface TokenDepositInfo extends BaseDepositInfo {
+  tokenId: HexString
+}
+
+export interface DepositInfo {
+  alph: BaseDepositInfo[]
+  tokens: TokenDepositInfo[]
+}
+
+export function getDepositInfo(tx: Transaction): DepositInfo {
+  if (!isTransferTx(tx)) return { alph: [], tokens: [] }
+
+  const inputAddresses = getInputAddresses(tx)
+  const alphDepositInfos = new Map<Address, bigint>()
+  const tokenDepositInfos = new Map<HexString, Map<Address, bigint>>()
+  tx.unsigned.fixedOutputs.forEach((o) => {
+    if (!inputAddresses.includes(o.address)) {
+      const alphAmount = alphDepositInfos.get(o.address) ?? 0n
+      alphDepositInfos.set(o.address, alphAmount + BigInt(o.attoAlphAmount))
+
+      o.tokens.forEach((token) => {
+        const depositPerToken = tokenDepositInfos.get(token.id) ?? new Map<Address, bigint>()
+        const currentAmount = depositPerToken.get(o.address) ?? 0n
+        depositPerToken.set(o.address, currentAmount + BigInt(token.amount))
+        tokenDepositInfos.set(token.id, depositPerToken)
+      })
+    }
+  })
+  return {
+    alph: Array.from(alphDepositInfos.entries()).map(([key, value]) => ({ targetAddress: key, depositAmount: value })),
+    tokens: Array.from(tokenDepositInfos.entries()).flatMap(([tokenId, depositPerToken]) => {
+      return Array.from(depositPerToken.entries()).map(([targetAddress, depositAmount]) => ({
+        tokenId,
+        targetAddress,
+        depositAmount
+      }))
+    })
+  }
+}
+
+// we assume that the tx is a simple transfer tx, i.e. isALPHTransferTx(tx) || isTokenTransferTx(tx)
 export function getSenderAddress(tx: Transaction): Address {
   return getAddressFromUnlockScript(tx.unsigned.inputs[0].unlockScript)
 }
@@ -115,7 +167,7 @@ function checkALPHOutput(tx: Transaction): boolean {
   return outputs.every((o) => o.tokens.length === 0)
 }
 
-function isTransferTx(tx: Transaction): boolean {
+export function isTransferTx(tx: Transaction): boolean {
   if (
     tx.contractInputs.length !== 0 ||
     tx.generatedOutputs.length !== 0 ||

package/src/exchange/index.ts

@@ -16,4 +16,13 @@ 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/>.
 */
 
-export { validateExchangeAddress, isALPHTransferTx, getSenderAddress, getALPHDepositInfo } from './exchange'
+export {
+  validateExchangeAddress,
+  getSenderAddress,
+  isALPHTransferTx,
+  getALPHDepositInfo,
+  BaseDepositInfo,
+  TokenDepositInfo,
+  DepositInfo,
+  getDepositInfo
+} from './exchange'

package/src/signer/tx-builder.ts

@@ -39,7 +39,7 @@ import {
 import { unsignedTxCodec } from '../codec'
 import { groupIndexOfTransaction } from '../transaction'
 import { blakeHash } from '../codec/hash'
-import { BuildDeployContractTxResult, BuildChainedTx } from '../api/api-alephium'
+import { BuildDeployContractTxResult, BuildChainedTx, BuildExecuteScriptTxResult } from '../api/api-alephium'
 
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider
@@ -140,7 +140,7 @@ export abstract class TransactionBuilder {
           } as SignDeployContractChainedTxResult
         }
         case 'ExecuteScript': {
-          const buildExecuteScriptTxResult = buildResult.value
+          const buildExecuteScriptTxResult = buildResult.value as BuildExecuteScriptTxResult
           return {
             ...this.convertExecuteScriptTxResult(buildExecuteScriptTxResult),
             type: buildResultType

package/src/signer/types.ts

@@ -113,6 +113,7 @@ export interface SignExecuteScriptTxResult {
   signature: string
   gasAmount: number
   gasPrice: Number256
+  simulatedOutputs: node.Output[]
 }
 assertType<
   Eq<