viem 2.0.0-alpha.9 → 2.0.0-beta.1

package/actions/wallet/signTransaction.ts

@@ -1,8 +1,13 @@
 import type { Account } from '../../accounts/types.js'
-import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.js'
+import type { SignTransactionErrorType as SignTransactionErrorType_account } from '../../accounts/utils/signTransaction.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { AccountNotFoundError } from '../../errors/account.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { GetAccountParameter } from '../../types/account.js'
 import type { Chain, GetChain } from '../../types/chain.js'
 import { type RpcTransactionRequest } from '../../types/rpc.js'
@@ -12,14 +17,23 @@ import type {
   TransactionSerialized,
 } from '../../types/transaction.js'
 import type { UnionOmit } from '../../types/utils.js'
-import { assertCurrentChain } from '../../utils/chain.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+import {
+  type AssertCurrentChainErrorType,
+  assertCurrentChain,
+} from '../../utils/chain/assertCurrentChain.js'
+import type { NumberToHexErrorType } from '../../utils/encoding/toHex.js'
 import {
   type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import { numberToHex } from '../../utils/index.js'
-import { assertRequest } from '../../utils/transaction/assertRequest.js'
-import { getChainId } from '../public/getChainId.js'
+import {
+  type AssertRequestErrorType,
+  assertRequest,
+} from '../../utils/transaction/assertRequest.js'
+import { type GetChainIdErrorType, getChainId } from '../public/getChainId.js'
 
 export type SignTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
@@ -36,6 +50,16 @@ export type SignTransactionParameters<
 
 export type SignTransactionReturnType = TransactionSerialized
 
+export type SignTransactionErrorType =
+  | ParseAccountErrorType
+  | AssertRequestErrorType
+  | GetChainIdErrorType
+  | AssertCurrentChainErrorType
+  | SignTransactionErrorType_account
+  | NumberToHexErrorType
+  | RequestErrorType
+  | ErrorType
+
 /**
  * Signs a transaction.
  *
@@ -82,7 +106,7 @@ export type SignTransactionReturnType = TransactionSerialized
 export async function signTransaction<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
-  TChainOverride extends Chain | undefined,
+  TChainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, TChain, TAccount>,
   args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
@@ -104,7 +128,7 @@ export async function signTransaction<
     ...args,
   })
 
-  const chainId = await getChainId(client)
+  const chainId = await getAction(client, getChainId)({})
   if (chain !== null)
     assertCurrentChain({
       currentChainId: chainId,
@@ -118,8 +142,8 @@ export async function signTransaction<
   if (account.type === 'local')
     return account.signTransaction(
       {
-        chainId,
         ...transaction,
+        chainId,
       } as unknown as TransactionSerializable,
       { serializer: client.chain?.serializers?.transaction },
     ) as Promise<SignTransactionReturnType>

package/actions/wallet/signTypedData.ts

@@ -1,17 +1,28 @@
 import type { TypedData } from 'abitype'
 
 import type { Account } from '../../accounts/types.js'
-import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.js'
+import type { SignTypedDataErrorType as SignTypedDataErrorType_account } from '../../accounts/utils/signTypedData.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import { AccountNotFoundError } from '../../errors/account.js'
+import {
+  AccountNotFoundError,
+  type AccountNotFoundErrorType,
+} from '../../errors/account.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { GetAccountParameter } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
-import { isHex } from '../../utils/data/isHex.js'
-import { stringify } from '../../utils/stringify.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+import { type IsHexErrorType, isHex } from '../../utils/data/isHex.js'
+import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
 import {
+  type GetTypesForEIP712DomainErrorType,
+  type ValidateTypedDataErrorType,
   getTypesForEIP712Domain,
   validateTypedData,
 } from '../../utils/typedData.js'
@@ -27,6 +38,17 @@ export type SignTypedDataParameters<
 
 export type SignTypedDataReturnType = Hex
 
+export type SignTypedDataErrorType =
+  | AccountNotFoundErrorType
+  | ParseAccountErrorType
+  | GetTypesForEIP712DomainErrorType
+  | ValidateTypedDataErrorType
+  | StringifyErrorType
+  | SignTypedDataErrorType_account
+  | IsHexErrorType
+  | RequestErrorType
+  | ErrorType
+
 /**
  * Signs typed data and calculates an Ethereum-specific signature in [https://eips.ethereum.org/EIPS/eip-712](https://eips.ethereum.org/EIPS/eip-712): `sign(keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message)))`
  *

package/actions/wallet/switchChain.ts

@@ -1,14 +1,24 @@
 import type { Account } from '../../accounts/types.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
-import { numberToHex } from '../../utils/encoding/toHex.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../utils/encoding/toHex.js'
 
 export type SwitchChainParameters = {
   /** ID of Chain to switch to */
   id: Chain['id']
 }
 
+export type SwitchChainErrorType =
+  | NumberToHexErrorType
+  | RequestErrorType
+  | ErrorType
+
 /**
  * Switch the target chain in a wallet.
  *

package/actions/wallet/watchAsset.ts

@@ -1,11 +1,14 @@
 import type { Account } from '../../accounts/types.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { WatchAssetParams } from '../../types/eip1193.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
 
 export type WatchAssetParameters = WatchAssetParams
 export type WatchAssetReturnType = boolean
+export type WatchAssetErrorType = RequestErrorType | ErrorType
 
 /**
  * Adds an EVM chain to the wallet.

package/actions/wallet/writeContract.ts

@@ -3,6 +3,7 @@ import type { Abi } from 'abitype'
 import type { Account } from '../../accounts/types.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { GetAccountParameter } from '../../types/account.js'
 import type { Chain, GetChain } from '../../types/chain.js'
 import type {
@@ -13,10 +14,14 @@ import type {
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type { Prettify, UnionEvaluate, UnionOmit } from '../../types/utils.js'
-import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../utils/abi/encodeFunctionData.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import {
-  type SendTransactionParameters,
+  type SendTransactionErrorType,
   type SendTransactionReturnType,
   sendTransaction,
 } from './sendTransaction.js'
@@ -32,7 +37,7 @@ export type WriteContractParameters<
     'nonpayable' | 'payable',
     functionName
   > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
-  chain extends Chain | undefined = Chain,
+  chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
   ///
@@ -44,19 +49,15 @@ export type WriteContractParameters<
   args,
   allFunctionNames
 > &
+  GetChain<chain, chainOverride> &
   Prettify<
     GetAccountParameter<account> &
-      GetChain<chain, chainOverride> &
       GetValue<
         abi,
         functionName,
-        SendTransactionParameters<
-          chain,
-          account,
-          chainOverride
-        > extends SendTransactionParameters
-          ? SendTransactionParameters<chain, account, chainOverride>['value']
-          : SendTransactionParameters['value']
+        FormattedTransactionRequest<
+          chainOverride extends Chain ? chainOverride : chain
+        >['value']
       > & {
         /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
         dataSuffix?: Hex
@@ -73,6 +74,11 @@ export type WriteContractParameters<
 
 export type WriteContractReturnType = SendTransactionReturnType
 
+export type WriteContractErrorType =
+  | EncodeFunctionDataErrorType
+  | SendTransactionErrorType
+  | ErrorType
+
 /**
  * Executes a write function on a contract.
  *
@@ -144,10 +150,10 @@ export async function writeContract<
   const { abi, address, args, dataSuffix, functionName, ...request } =
     parameters as WriteContractParameters
   const data = encodeFunctionData({ abi, args, functionName })
-  const hash = await sendTransaction(client, {
+  const action = getAction(client, sendTransaction)
+  return action({
     data: `${data}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
     to: address,
     ...request,
   })
-  return hash
 }

package/chains/celo/formatters.ts

@@ -19,6 +19,7 @@ import type {
   CeloTransactionReceiptOverrides,
   CeloTransactionRequest,
 } from './types.js'
+import { isCIP42, isCIP64 } from './utils.js'
 
 export const formattersCelo = {
   block: /*#__PURE__*/ defineBlock({
@@ -35,10 +36,15 @@ export const formattersCelo = {
         return {
           ...formatTransaction(transaction as RpcTransaction),
           feeCurrency: transaction.feeCurrency,
-          gatewayFee: transaction.gatewayFee
-            ? hexToBigInt(transaction.gatewayFee)
-            : null,
-          gatewayFeeRecipient: transaction.gatewayFeeRecipient,
+
+          ...(transaction.type !== '0x7b'
+            ? {
+                gatewayFee: transaction.gatewayFee
+                  ? hexToBigInt(transaction.gatewayFee)
+                  : null,
+                gatewayFeeRecipient: transaction.gatewayFeeRecipient || null,
+              }
+            : {}),
         }
       }) as Hash[] | CeloTransaction[]
       return {
@@ -49,11 +55,19 @@ export const formattersCelo = {
   }),
   transaction: /*#__PURE__*/ defineTransaction({
     format(args: CeloRpcTransaction): CeloTransaction {
-      return {
-        feeCurrency: args.feeCurrency,
-        gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
-        gatewayFeeRecipient: args.gatewayFeeRecipient,
-      } as CeloTransaction
+      const transaction = { feeCurrency: args.feeCurrency } as CeloTransaction
+
+      if (args.type === '0x7b') transaction.type = 'cip64'
+      else {
+        if (args.type === '0x7c') transaction.type = 'cip42'
+
+        transaction.gatewayFee = args.gatewayFee
+          ? hexToBigInt(args.gatewayFee)
+          : null
+        transaction.gatewayFeeRecipient = args.gatewayFeeRecipient
+      }
+
+      return transaction
     },
   }),
   transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
@@ -67,17 +81,24 @@ export const formattersCelo = {
       }
     },
   }),
+
   transactionRequest: /*#__PURE__*/ defineTransactionRequest({
     format(args: CeloTransactionRequest): CeloRpcTransactionRequest {
       const request = {
         feeCurrency: args.feeCurrency,
-        gatewayFee:
+      } as CeloRpcTransactionRequest
+
+      if (isCIP64(args)) request.type = '0x7b'
+      else {
+        if (isCIP42(args)) request.type = '0x7c'
+
+        request.gatewayFee =
           typeof args.gatewayFee !== 'undefined'
             ? numberToHex(args.gatewayFee)
-            : undefined,
-        gatewayFeeRecipient: args.gatewayFeeRecipient,
-      } as CeloRpcTransactionRequest
-      if (args.type === 'cip42') request.type = '0x7c'
+            : undefined
+        request.gatewayFeeRecipient = args.gatewayFeeRecipient
+      }
+
       return request
     },
   }),

package/chains/celo/parsers.ts

@@ -11,12 +11,17 @@ import {
   parseTransaction,
   toTransactionArray,
 } from '../../utils/transaction/parseTransaction.js'
-import { assertTransactionCIP42 } from './serializers.js'
+import {
+  assertTransactionCIP42,
+  assertTransactionCIP64,
+} from './serializers.js'
 import type {
   CeloTransactionSerialized,
   CeloTransactionType,
   TransactionSerializableCIP42,
+  TransactionSerializableCIP64,
   TransactionSerializedCIP42,
+  TransactionSerializedCIP64,
 } from './types.js'
 
 export type ParseTransactionCeloReturnType<
@@ -38,6 +43,11 @@ export function parseTransactionCelo<
       serializedTransaction as TransactionSerializedCIP42,
     ) as ParseTransactionCeloReturnType<TSerialized>
 
+  if (serializedType === '0x7b')
+    return parseTransactionCIP64(
+      serializedTransaction as TransactionSerializedCIP64,
+    ) as ParseTransactionCeloReturnType<TSerialized>
+
   return parseTransaction(
     serializedTransaction,
   ) as ParseTransactionCeloReturnType<TSerialized>
@@ -121,3 +131,74 @@ function parseTransactionCIP42(
 
   return transaction as TransactionSerializableCIP42
 }
+
+function parseTransactionCIP64(
+  serializedTransaction: TransactionSerializedCIP64,
+): TransactionSerializableCIP64 {
+  const transactionArray = toTransactionArray(serializedTransaction)
+
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    to,
+    value,
+    data,
+    accessList,
+    feeCurrency,
+    v,
+    r,
+    s,
+  ] = transactionArray
+
+  if (transactionArray.length !== 13 && transactionArray.length !== 10) {
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        feeCurrency,
+        ...(transactionArray.length > 10
+          ? {
+              v,
+              r,
+              s,
+            }
+          : {}),
+      },
+      serializedTransaction,
+      type: 'cip64',
+    })
+  }
+
+  const transaction: Partial<TransactionSerializableCIP64> = {
+    chainId: hexToNumber(chainId as Hex),
+    type: 'cip64',
+  }
+
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(data) && data !== '0x') transaction.data = data
+  if (isHex(nonce) && nonce !== '0x') transaction.nonce = hexToNumber(nonce)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(feeCurrency) && feeCurrency !== '0x')
+    transaction.feeCurrency = feeCurrency
+  if (isHex(maxFeePerGas) && maxFeePerGas !== '0x')
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas)
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas)
+  if (accessList.length !== 0 && accessList !== '0x')
+    transaction.accessList = parseAccessList(accessList as RecursiveArray<Hex>)
+
+  assertTransactionCIP64(transaction as TransactionSerializableCIP64)
+
+  return transaction as TransactionSerializableCIP64
+}

package/chains/celo/serializers.ts

@@ -18,21 +18,22 @@ import {
 import type {
   CeloTransactionSerializable,
   TransactionSerializableCIP42,
+  TransactionSerializableCIP64,
   TransactionSerializedCIP42,
+  TransactionSerializedCIP64,
 } from './types.js'
+import { isCIP42, isCIP64, isEmpty, isPresent } from './utils.js'
 
 export const serializeTransactionCelo: SerializeTransactionFn<
-  CeloTransactionSerializable
+  CeloTransactionSerializable | TransactionSerializable
 > = (tx, signature) => {
-  // Handle CIP-42 transactions
-  if (isCIP42(tx))
-    return serializeTransactionCIP42(
-      tx as TransactionSerializableCIP42,
-      signature,
-    )
-
-  // Handle other transaction types
-  return serializeTransaction(tx as TransactionSerializable, signature)
+  if (isCIP64(tx)) {
+    return serializeTransactionCIP64(tx, signature)
+  } else if (isCIP42(tx)) {
+    return serializeTransactionCIP42(tx, signature)
+  } else {
+    return serializeTransaction(tx as TransactionSerializable, signature)
+  }
 }
 
 export const serializersCelo = {
@@ -43,6 +44,7 @@ export const serializersCelo = {
 // Serializers
 
 export type SerializeTransactionCIP42ReturnType = TransactionSerializedCIP42
+export type SerializeTransactionCIP64ReturnType = TransactionSerializedCIP64
 
 // There shall be a typed transaction with the code 0x7c that has the following format:
 // 0x7c || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, feecurrency, gatewayFeeRecipient, gatewayfee, destination, amount, data, access_list, signature_y_parity, signature_r, signature_s]).
@@ -96,25 +98,53 @@ function serializeTransactionCIP42(
   ]) as SerializeTransactionCIP42ReturnType
 }
 
-//////////////////////////////////////////////////////////////////////////////
-// Utilities
+function serializeTransactionCIP64(
+  transaction: TransactionSerializableCIP64,
+  signature?: Signature,
+): SerializeTransactionCIP64ReturnType {
+  assertTransactionCIP64(transaction)
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    accessList,
+    feeCurrency,
+    data,
+  } = transaction
 
-// process as CIP42 if any of these fields are present. realistically gatewayfee is not used but is part of spec
-function isCIP42(transaction: CeloTransactionSerializable) {
-  if (
-    'maxFeePerGas' in transaction &&
-    'maxPriorityFeePerGas' in transaction &&
-    ('feeCurrency' in transaction ||
-      'gatewayFee' in transaction ||
-      'gatewayFeeRecipient' in transaction)
-  )
-    return true
-  return false
+  const serializedTransaction = [
+    toHex(chainId),
+    nonce ? toHex(nonce) : '0x',
+    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+    maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+    gas ? toHex(gas) : '0x',
+    to ?? '0x',
+    value ? toHex(value) : '0x',
+    data ?? '0x',
+    serializeAccessList(accessList),
+    feeCurrency!,
+  ]
+
+  if (signature) {
+    serializedTransaction.push(
+      signature.v === 27n ? '0x' : toHex(1), // yParity
+      trim(signature.r),
+      trim(signature.s),
+    )
+  }
+
+  return concatHex([
+    '0x7b',
+    toRlp(serializedTransaction),
+  ]) as SerializeTransactionCIP64ReturnType
 }
 
-// maxFeePerGas must be less than 2^256 - 1: however writing like that caused exceptions to be raised
-const MAX_MAX_FEE_PER_GAS =
-  115792089237316195423570985008687907853269984665640564039457584007913129639935n
+// maxFeePerGas must be less than 2^256 - 1
+const MAX_MAX_FEE_PER_GAS = 2n ** 256n - 1n
 
 export function assertTransactionCIP42(
   transaction: TransactionSerializableCIP42,
@@ -136,34 +166,80 @@ export function assertTransactionCIP42(
       '`gasPrice` is not a valid CIP-42 Transaction attribute.',
     )
 
-  if (maxFeePerGas && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
+  if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
     throw new FeeCapTooHighError({ maxFeePerGas })
 
   if (
-    maxPriorityFeePerGas &&
-    maxFeePerGas &&
+    isPresent(maxPriorityFeePerGas) &&
+    isPresent(maxFeePerGas) &&
     maxPriorityFeePerGas > maxFeePerGas
   )
     throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
 
   if (
-    (gatewayFee && !gatewayFeeRecipient) ||
-    (gatewayFeeRecipient && !gatewayFee)
+    (isPresent(gatewayFee) && isEmpty(gatewayFeeRecipient)) ||
+    (isPresent(gatewayFeeRecipient) && isEmpty(gatewayFee))
   ) {
     throw new BaseError(
       '`gatewayFee` and `gatewayFeeRecipient` must be provided together.',
     )
   }
 
-  if (feeCurrency && !feeCurrency?.startsWith('0x')) {
+  if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
     throw new BaseError(
       '`feeCurrency` MUST be a token address for CIP-42 transactions.',
     )
   }
 
-  if (!feeCurrency && !gatewayFeeRecipient) {
+  if (isPresent(gatewayFeeRecipient) && !isAddress(gatewayFeeRecipient)) {
+    throw new InvalidAddressError(gatewayFeeRecipient)
+  }
+
+  if (isEmpty(feeCurrency) && isEmpty(gatewayFeeRecipient)) {
     throw new BaseError(
       'Either `feeCurrency` or `gatewayFeeRecipient` must be provided for CIP-42 transactions.',
     )
   }
 }
+
+export function assertTransactionCIP64(
+  transaction: TransactionSerializableCIP64,
+) {
+  const {
+    chainId,
+    maxPriorityFeePerGas,
+    gasPrice,
+    maxFeePerGas,
+    to,
+    feeCurrency,
+  } = transaction
+
+  if (chainId <= 0) throw new InvalidChainIdError({ chainId })
+  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
+
+  if (gasPrice)
+    throw new BaseError(
+      '`gasPrice` is not a valid CIP-64 Transaction attribute.',
+    )
+
+  if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
+    throw new FeeCapTooHighError({ maxFeePerGas })
+  if (
+    isPresent(maxPriorityFeePerGas) &&
+    isPresent(maxFeePerGas) &&
+    maxPriorityFeePerGas > maxFeePerGas
+  )
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
+
+  if (isPresent(feeCurrency) && !feeCurrency?.startsWith('0x')) {
+    throw new BaseError(
+      '`feeCurrency` MUST be a token address for CIP-64 transactions.',
+    )
+  }
+
+  if (isEmpty(feeCurrency)) {
+    throw new BaseError(
+      '`feeCurrency` must be provided for CIP-64 transactions.',
+    )
+  }
+}