viem 2.9.2 → 2.9.4

package/op-stack/decorators/walletL2.ts

@@ -0,0 +1,101 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import {
+  type InitiateWithdrawalParameters,
+  type InitiateWithdrawalReturnType,
+  initiateWithdrawal,
+} from '../actions/initiateWithdrawal.js'
+
+export type WalletActionsL2<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = {
+  /**
+   * Initiates a [withdrawal](https://community.optimism.io/docs/protocol/withdrawal-flow/#withdrawal-initiating-transaction) on an L2 to the L1.
+   *
+   * Internally performs a contract write to the [`initiateWithdrawal` function](https://github.com/ethereum-optimism/optimism/blob/283f0aa2e3358ced30ff7cbd4028c0c0c3faa140/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol#L73)
+   * on the [Optimism L2ToL1MessagePasser predeploy contract](https://github.com/ethereum-optimism/optimism/blob/283f0aa2e3358ced30ff7cbd4028c0c0c3faa140/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol).
+   *
+   * - Docs: https://viem.sh/op-stack/actions/initiateWithdrawal
+   *
+   * @param client - Client to use
+   * @param parameters - {@link InitiateWithdrawalParameters}
+   * @returns The L2 transaction hash. {@link InitiateWithdrawalReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom, parseEther } from 'viem'
+   * import { base, mainnet } from 'viem/chains'
+   * import { walletActionsL2 } from 'viem/op-stack'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * }).extend(walletActionsL2())
+   *
+   * const hash = await client.initiateWithdrawal({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   args: {
+   *     gas: 21_000n,
+   *     to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *     value: parseEther('1'),
+   *   },
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { base, mainnet } from 'viem/chains'
+   * import { walletActionsL2 } from 'viem/op-stack'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(walletActionsL2())
+   *
+   * const hash = await client.initiateWithdrawal({
+   *   args: {
+   *     gas: 21_000n,
+   *     to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *     value: parseEther('1'),
+   *   },
+   * })
+   */
+  initiateWithdrawal: <chainOverride extends Chain | undefined = undefined>(
+    parameters: InitiateWithdrawalParameters<chain, account, chainOverride>,
+  ) => Promise<InitiateWithdrawalReturnType>
+}
+
+/**
+ * A suite of Wallet Actions for suited for development with Layer 2 (OP Stack) chains.
+ *
+ * - Docs: https://viem.sh/op-stack/client
+ *
+ * @example
+ * import { createPublicClient, createWalletClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { walletActionsL1 } from 'viem/op-stack'
+ *
+ * const walletClient = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * }).extend(walletActionsL1())
+ *
+ * const hash = await walletClient.depositTransaction({...})
+ */
+export function walletActionsL2() {
+  return <
+    TTransport extends Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined,
+  >(
+    client: Client<TTransport, TChain, TAccount>,
+  ): WalletActionsL2<TChain, TAccount> => {
+    return {
+      initiateWithdrawal: (args) => initiateWithdrawal(client, args),
+    }
+  }
+}

package/op-stack/errors/withdrawal.ts

@@ -0,0 +1,25 @@
+import { BaseError } from '../../errors/base.js'
+import type { Hex } from '../../types/misc.js'
+
+export type GameNotFoundErrorType = GameNotFoundError & {
+  name: 'GameNotFoundError'
+}
+export class GameNotFoundError extends BaseError {
+  override name = 'GameNotFoundError'
+  constructor() {
+    super('Dispute game not found.')
+  }
+}
+
+export type ReceiptContainsNoWithdrawalsErrorType =
+  ReceiptContainsNoWithdrawalsError & {
+    name: 'ReceiptContainsNoWithdrawalsError'
+  }
+export class ReceiptContainsNoWithdrawalsError extends BaseError {
+  override name = 'ReceiptContainsNoWithdrawalsError'
+  constructor({ hash }: { hash: Hex }) {
+    super(
+      `The provided transaction receipt with hash "${hash}" contains no withdrawals.`,
+    )
+  }
+}

package/op-stack/formatters.ts

@@ -0,0 +1,76 @@
+import { type ChainFormatters } from '../types/chain.js'
+import type { Hash } from '../types/misc.js'
+import { type RpcTransaction } from '../types/rpc.js'
+import { hexToBigInt } from '../utils/encoding/fromHex.js'
+import { defineBlock } from '../utils/formatters/block.js'
+import {
+  defineTransaction,
+  formatTransaction,
+} from '../utils/formatters/transaction.js'
+import { defineTransactionReceipt } from '../utils/formatters/transactionReceipt.js'
+import type {
+  OpStackBlockOverrides,
+  OpStackRpcBlockOverrides,
+} from './types/block.js'
+import type {
+  OpStackRpcTransaction,
+  OpStackRpcTransactionReceiptOverrides,
+  OpStackTransaction,
+  OpStackTransactionReceiptOverrides,
+} from './types/transaction.js'
+
+export const formatters = {
+  block: /*#__PURE__*/ defineBlock({
+    format(
+      args: OpStackRpcBlockOverrides & {
+        transactions: Hash[] | OpStackRpcTransaction[]
+      },
+    ): OpStackBlockOverrides & {
+      transactions: Hash[] | OpStackTransaction[]
+    } {
+      const transactions = args.transactions?.map((transaction) => {
+        if (typeof transaction === 'string') return transaction
+        const formatted = formatTransaction(
+          transaction as RpcTransaction,
+        ) as OpStackTransaction
+        if (formatted.typeHex === '0x7e') {
+          formatted.isSystemTx = transaction.isSystemTx
+          formatted.mint = transaction.mint
+            ? hexToBigInt(transaction.mint)
+            : undefined
+          formatted.sourceHash = transaction.sourceHash
+          formatted.type = 'deposit'
+        }
+        return formatted
+      }) as Hash[] | OpStackTransaction[]
+      return {
+        transactions,
+        stateRoot: args.stateRoot,
+      }
+    },
+  }),
+  transaction: /*#__PURE__*/ defineTransaction({
+    format(args: OpStackRpcTransaction): OpStackTransaction {
+      const transaction = {} as OpStackTransaction
+      if (args.type === '0x7e') {
+        transaction.isSystemTx = args.isSystemTx
+        transaction.mint = args.mint ? hexToBigInt(args.mint) : undefined
+        transaction.sourceHash = args.sourceHash
+        transaction.type = 'deposit'
+      }
+      return transaction
+    },
+  }),
+  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+    format(
+      args: OpStackRpcTransactionReceiptOverrides,
+    ): OpStackTransactionReceiptOverrides {
+      return {
+        l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
+        l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
+        l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
+        l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null,
+      }
+    },
+  }),
+} as const satisfies ChainFormatters

package/op-stack/index.ts

@@ -0,0 +1,281 @@
+export {
+  buildDepositTransaction,
+  type BuildDepositTransactionErrorType,
+  type BuildDepositTransactionParameters,
+  type BuildDepositTransactionReturnType,
+} from './actions/buildDepositTransaction.js'
+export {
+  buildInitiateWithdrawal,
+  type BuildInitiateWithdrawalErrorType,
+  type BuildInitiateWithdrawalParameters,
+  type BuildInitiateWithdrawalReturnType,
+} from './actions/buildInitiateWithdrawal.js'
+export {
+  buildProveWithdrawal,
+  type BuildProveWithdrawalErrorType,
+  type BuildProveWithdrawalParameters,
+  type BuildProveWithdrawalReturnType,
+} from './actions/buildProveWithdrawal.js'
+export {
+  depositTransaction,
+  type DepositTransactionErrorType,
+  type DepositTransactionParameters,
+  type DepositTransactionReturnType,
+} from './actions/depositTransaction.js'
+export {
+  estimateContractL1Fee,
+  type EstimateContractL1FeeErrorType,
+  type EstimateContractL1FeeParameters,
+  type EstimateContractL1FeeReturnType,
+} from './actions/estimateContractL1Fee.js'
+export {
+  estimateContractL1Gas,
+  type EstimateContractL1GasErrorType,
+  type EstimateContractL1GasParameters,
+  type EstimateContractL1GasReturnType,
+} from './actions/estimateContractL1Gas.js'
+export {
+  estimateContractTotalFee,
+  type EstimateContractTotalFeeErrorType,
+  type EstimateContractTotalFeeParameters,
+  type EstimateContractTotalFeeReturnType,
+} from './actions/estimateContractTotalFee.js'
+export {
+  estimateContractTotalGas,
+  type EstimateContractTotalGasErrorType,
+  type EstimateContractTotalGasParameters,
+  type EstimateContractTotalGasReturnType,
+} from './actions/estimateContractTotalGas.js'
+export {
+  estimateL1Fee,
+  type EstimateL1FeeErrorType,
+  type EstimateL1FeeParameters,
+  type EstimateL1FeeReturnType,
+} from './actions/estimateL1Fee.js'
+export {
+  getGame,
+  type GetGameErrorType,
+  type GetGameParameters,
+  type GetGameReturnType,
+} from './actions/getGame.js'
+export {
+  getGames,
+  type GetGamesErrorType,
+  type GetGamesParameters,
+  type GetGamesReturnType,
+} from './actions/getGames.js'
+export {
+  getL1BaseFee,
+  type GetL1BaseFeeErrorType,
+  type GetL1BaseFeeParameters,
+  type GetL1BaseFeeReturnType,
+} from './actions/getL1BaseFee.js'
+export {
+  estimateL1Gas,
+  type EstimateL1GasErrorType,
+  type EstimateL1GasParameters,
+  type EstimateL1GasReturnType,
+} from './actions/estimateL1Gas.js'
+export {
+  estimateTotalFee,
+  type EstimateTotalFeeErrorType,
+  type EstimateTotalFeeParameters,
+  type EstimateTotalFeeReturnType,
+} from './actions/estimateTotalFee.js'
+export {
+  estimateTotalGas,
+  type EstimateTotalGasErrorType,
+  type EstimateTotalGasParameters,
+  type EstimateTotalGasReturnType,
+} from './actions/estimateTotalGas.js'
+export {
+  finalizeWithdrawal,
+  type FinalizeWithdrawalErrorType,
+  type FinalizeWithdrawalParameters,
+  type FinalizeWithdrawalReturnType,
+} from './actions/finalizeWithdrawal.js'
+export {
+  getL2Output,
+  type GetL2OutputErrorType,
+  type GetL2OutputParameters,
+  type GetL2OutputReturnType,
+} from './actions/getL2Output.js'
+export {
+  getPortalVersion,
+  type GetPortalVersionErrorType,
+  type GetPortalVersionParameters,
+  type GetPortalVersionReturnType,
+} from './actions/getPortalVersion.js'
+export {
+  getTimeToNextGame,
+  type GetTimeToNextGameErrorType,
+  type GetTimeToNextGameParameters,
+  type GetTimeToNextGameReturnType,
+} from './actions/getTimeToNextGame.js'
+export {
+  getTimeToFinalize,
+  type GetTimeToFinalizeErrorType,
+  type GetTimeToFinalizeParameters,
+  type GetTimeToFinalizeReturnType,
+} from './actions/getTimeToFinalize.js'
+export {
+  getTimeToNextL2Output,
+  type GetTimeToNextL2OutputErrorType,
+  type GetTimeToNextL2OutputParameters,
+  type GetTimeToNextL2OutputReturnType,
+} from './actions/getTimeToNextL2Output.js'
+export {
+  getTimeToProve,
+  type GetTimeToProveErrorType,
+  type GetTimeToProveParameters,
+  type GetTimeToProveReturnType,
+} from './actions/getTimeToProve.js'
+export {
+  getWithdrawalStatus,
+  type GetWithdrawalStatusErrorType,
+  type GetWithdrawalStatusParameters,
+  type GetWithdrawalStatusReturnType,
+} from './actions/getWithdrawalStatus.js'
+export {
+  initiateWithdrawal,
+  type InitiateWithdrawalErrorType,
+  type InitiateWithdrawalParameters,
+  type InitiateWithdrawalReturnType,
+} from './actions/initiateWithdrawal.js'
+export {
+  proveWithdrawal,
+  type ProveWithdrawalErrorType,
+  type ProveWithdrawalParameters,
+  type ProveWithdrawalReturnType,
+} from './actions/proveWithdrawal.js'
+export {
+  waitForNextGame,
+  type WaitForNextGameErrorType,
+  type WaitForNextGameParameters,
+  type WaitForNextGameReturnType,
+} from './actions/waitForNextGame.js'
+export {
+  waitForNextL2Output,
+  type WaitForNextL2OutputErrorType,
+  type WaitForNextL2OutputParameters,
+  type WaitForNextL2OutputReturnType,
+} from './actions/waitForNextL2Output.js'
+export {
+  waitToFinalize,
+  type WaitToFinalizeErrorType,
+  type WaitToFinalizeParameters,
+  type WaitToFinalizeReturnType,
+} from './actions/waitToFinalize.js'
+export {
+  waitToProve,
+  type WaitToProveErrorType,
+  type WaitToProveParameters,
+  type WaitToProveReturnType,
+} from './actions/waitToProve.js'
+
+export { chainConfig } from './chainConfig.js'
+
+export * from './chains.js'
+
+export {
+  publicActionsL1,
+  type PublicActionsL1,
+} from './decorators/publicL1.js'
+export {
+  publicActionsL2,
+  type PublicActionsL2,
+} from './decorators/publicL2.js'
+export {
+  walletActionsL1,
+  type WalletActionsL1,
+} from './decorators/walletL1.js'
+export {
+  walletActionsL2,
+  type WalletActionsL2,
+} from './decorators/walletL2.js'
+
+export {
+  parseTransaction,
+  type ParseTransactionErrorType,
+  type ParseTransactionReturnType,
+} from './parsers.js'
+
+export {
+  serializeTransaction,
+  serializers,
+  type SerializeTransactionErrorType,
+  type SerializeTransactionReturnType,
+} from './serializers.js'
+
+export type {
+  OpStackBlock,
+  OpStackBlockOverrides,
+  OpStackRpcBlock,
+  OpStackRpcBlockOverrides,
+} from './types/block.js'
+export type {
+  OpStackDepositTransaction,
+  OpStackRpcDepositTransaction,
+  OpStackRpcTransaction,
+  OpStackRpcTransactionReceipt,
+  OpStackRpcTransactionReceiptOverrides,
+  OpStackTransaction,
+  OpStackTransactionReceipt,
+  OpStackTransactionReceiptOverrides,
+} from './types/transaction.js'
+
+export {
+  extractWithdrawalMessageLogs,
+  type ExtractWithdrawalMessageLogsErrorType,
+  type ExtractWithdrawalMessageLogsParameters,
+  type ExtractWithdrawalMessageLogsReturnType,
+} from './utils/extractWithdrawalMessageLogs.js'
+
+export {
+  extractTransactionDepositedLogs,
+  type ExtractTransactionDepositedLogsErrorType,
+  type ExtractTransactionDepositedLogsParameters,
+  type ExtractTransactionDepositedLogsReturnType,
+} from './utils/extractTransactionDepositedLogs.js'
+
+export {
+  opaqueDataToDepositData,
+  type OpaqueDataToDepositDataErrorType,
+  type OpaqueDataToDepositDataParameters,
+  type OpaqueDataToDepositDataReturnType,
+} from './utils/opaqueDataToDepositData.js'
+
+export {
+  getL2TransactionHash,
+  type GetL2TransactionHashErrorType,
+  type GetL2TransactionHashParameters,
+  type GetL2TransactionHashReturnType,
+} from './utils/getL2TransactionHash.js'
+
+export {
+  getL2TransactionHashes,
+  type GetL2TransactionHashesErrorType,
+  type GetL2TransactionHashesParameters,
+  type GetL2TransactionHashesReturnType,
+} from './utils/getL2TransactionHashes.js'
+
+export {
+  getSourceHash,
+  type GetSourceHashErrorType,
+  type GetSourceHashParameters,
+  type GetSourceHashReturnType,
+} from './utils/getSourceHash.js'
+
+export {
+  getWithdrawalHashStorageSlot,
+  type GetWithdrawalHashStorageSlotErrorType,
+  type GetWithdrawalHashStorageSlotParameters,
+  type GetWithdrawalHashStorageSlotReturnType,
+} from './utils/getWithdrawalHashStorageSlot.js'
+
+export {
+  getWithdrawals,
+  type GetWithdrawalsErrorType,
+  type GetWithdrawalsParameters,
+  type GetWithdrawalsReturnType,
+} from './utils/getWithdrawals.js'

package/op-stack/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
-  "types": "../_types/chains/opStack/index.d.ts",
-  "module": "../_esm/chains/opStack/index.js",
-  "main": "../_cjs/chains/opStack/index.js"
+  "types": "../_types/op-stack/index.d.ts",
+  "module": "../_esm/op-stack/index.js",
+  "main": "../_cjs/op-stack/index.js"
 }

package/op-stack/parsers.ts

@@ -0,0 +1,88 @@
+import { InvalidSerializedTransactionError } from '../errors/transaction.js'
+import type { ErrorType } from '../errors/utils.js'
+import { isHex } from '../utils/data/isHex.js'
+import { sliceHex } from '../utils/data/slice.js'
+import { hexToBigInt, hexToBool } from '../utils/encoding/fromHex.js'
+import type { GetSerializedTransactionType } from '../utils/transaction/getSerializedTransactionType.js'
+import {
+  type ParseTransactionErrorType as ParseTransactionErrorType_,
+  type ParseTransactionReturnType as ParseTransactionReturnType_,
+  parseTransaction as parseTransaction_,
+  toTransactionArray,
+} from '../utils/transaction/parseTransaction.js'
+import { assertTransactionDeposit } from './serializers.js'
+import type {
+  OpStackTransactionSerialized,
+  OpStackTransactionType,
+  TransactionSerializableDeposit,
+  TransactionSerializedDeposit,
+} from './types/transaction.js'
+
+export type ParseTransactionReturnType<
+  TSerialized extends
+    OpStackTransactionSerialized = OpStackTransactionSerialized,
+  TType extends
+    OpStackTransactionType = GetSerializedTransactionType<TSerialized>,
+> = TSerialized extends TransactionSerializedDeposit
+  ? TransactionSerializableDeposit
+  : ParseTransactionReturnType_<TSerialized, TType>
+
+export type ParseTransactionErrorType = ParseTransactionErrorType_ | ErrorType
+
+export function parseTransaction<
+  TSerialized extends OpStackTransactionSerialized,
+>(serializedTransaction: TSerialized): ParseTransactionReturnType<TSerialized> {
+  const serializedType = sliceHex(serializedTransaction, 0, 1)
+
+  if (serializedType === '0x7e')
+    return parseTransactionDeposit(
+      serializedTransaction as TransactionSerializedDeposit,
+    ) as ParseTransactionReturnType<TSerialized>
+
+  return parseTransaction_(
+    serializedTransaction,
+  ) as ParseTransactionReturnType<TSerialized>
+}
+
+function parseTransactionDeposit(
+  serializedTransaction: TransactionSerializedDeposit,
+): ParseTransactionReturnType<TransactionSerializedDeposit> {
+  const transactionArray = toTransactionArray(serializedTransaction)
+
+  const [sourceHash, from, to, mint, value, gas, isSystemTx, data] =
+    transactionArray
+
+  if (transactionArray.length !== 8 || !isHex(sourceHash) || !isHex(from))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        sourceHash,
+        from,
+        gas,
+        to,
+        mint,
+        value,
+        isSystemTx,
+        data,
+      },
+      serializedTransaction,
+      type: 'deposit',
+    })
+
+  const transaction: TransactionSerializableDeposit = {
+    sourceHash,
+    from,
+    type: 'deposit',
+  }
+
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(mint) && mint !== '0x') transaction.mint = hexToBigInt(mint)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(isSystemTx) && isSystemTx !== '0x')
+    transaction.isSystemTx = hexToBool(isSystemTx)
+  if (isHex(data) && data !== '0x') transaction.data = data
+
+  assertTransactionDeposit(transaction)
+
+  return transaction
+}

package/op-stack/serializers.ts

@@ -0,0 +1,88 @@
+import { InvalidAddressError } from '../errors/address.js'
+import type { ErrorType } from '../errors/utils.js'
+import type { ChainSerializers } from '../types/chain.js'
+import type { Hex, Signature } from '../types/misc.js'
+import type { TransactionSerializable } from '../types/transaction.js'
+import type { RequiredBy } from '../types/utils.js'
+import { isAddress } from '../utils/address/isAddress.js'
+import { concatHex } from '../utils/data/concat.js'
+import { toHex } from '../utils/encoding/toHex.js'
+import { toRlp } from '../utils/encoding/toRlp.js'
+import {
+  type SerializeTransactionErrorType as SerializeTransactionErrorType_,
+  serializeTransaction as serializeTransaction_,
+} from '../utils/transaction/serializeTransaction.js'
+import type {
+  OpStackTransactionSerializable,
+  TransactionSerializableDeposit,
+  TransactionSerializedDeposit,
+} from './types/transaction.js'
+
+export type SerializeTransactionReturnType = ReturnType<
+  typeof serializeTransaction
+>
+
+export type SerializeTransactionErrorType =
+  | SerializeTransactionErrorType_
+  | ErrorType
+
+export function serializeTransaction(
+  transaction: OpStackTransactionSerializable,
+  signature?: Signature,
+) {
+  if (isDeposit(transaction)) return serializeTransactionDeposit(transaction)
+  return serializeTransaction_(
+    transaction as TransactionSerializable,
+    signature,
+  )
+}
+
+export const serializers = {
+  transaction: serializeTransaction,
+} as const satisfies ChainSerializers
+
+//////////////////////////////////////////////////////////////////////////////
+// Serializers
+
+export type SerializeTransactionDepositReturnType = TransactionSerializedDeposit
+
+function serializeTransactionDeposit(
+  transaction: TransactionSerializableDeposit,
+): SerializeTransactionDepositReturnType {
+  assertTransactionDeposit(transaction)
+
+  const { sourceHash, data, from, gas, isSystemTx, mint, to, value } =
+    transaction
+
+  const serializedTransaction: Hex[] = [
+    sourceHash,
+    from,
+    to ?? '0x',
+    mint ? toHex(mint) : '0x',
+    value ? toHex(value) : '0x',
+    gas ? toHex(gas) : '0x',
+    isSystemTx ? '0x1' : '0x',
+    data ?? '0x',
+  ]
+
+  return concatHex([
+    '0x7e',
+    toRlp(serializedTransaction),
+  ]) as SerializeTransactionDepositReturnType
+}
+
+function isDeposit(
+  transaction: OpStackTransactionSerializable,
+): transaction is RequiredBy<TransactionSerializableDeposit, 'type'> {
+  if (transaction.type === 'deposit') return true
+  if (typeof transaction.sourceHash !== 'undefined') return true
+  return false
+}
+
+export function assertTransactionDeposit(
+  transaction: TransactionSerializableDeposit,
+) {
+  const { from, to } = transaction
+  if (from && !isAddress(from)) throw new InvalidAddressError({ address: from })
+  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
+}