initial commit for viem api

src/experimental/arbitrumDeposit/abis/inbox.ts

@@ -4,7 +4,7 @@ export const inboxAbi = [
     name: 'depositEth',
     outputs: [{ type: 'uint256' }],
     stateMutability: 'payable',
-    type: 'function'
+    type: 'function',
   },
   {
     inputs: [
@@ -15,28 +15,26 @@ export const inboxAbi = [
       { name: 'callValueRefundAddress', type: 'address' },
       { name: 'gasLimit', type: 'uint256' },
       { name: 'maxFeePerGas', type: 'uint256' },
-      { name: 'data', type: 'bytes' }
+      { name: 'data', type: 'bytes' },
     ],
     name: 'createRetryableTicket',
     outputs: [{ type: 'uint256' }],
     stateMutability: 'payable',
-    type: 'function'
+    type: 'function',
   },
   {
     anonymous: false,
     inputs: [
       { indexed: false, name: 'messageNum', type: 'uint256' },
-      { indexed: false, name: 'data', type: 'bytes' }
+      { indexed: false, name: 'data', type: 'bytes' },
     ],
     name: 'InboxMessageDelivered',
-    type: 'event'
+    type: 'event',
   },
   {
     anonymous: false,
-    inputs: [
-      { indexed: false, name: 'messageNum', type: 'uint256' }
-    ],
+    inputs: [{ indexed: false, name: 'messageNum', type: 'uint256' }],
     name: 'InboxMessageDeliveredFromOrigin',
-    type: 'event'
-  }
-] as const 
+    type: 'event',
+  },
+] as const

src/experimental/arbitrumDeposit/depositEth.ts

@@ -0,0 +1,32 @@
+import { Account, Address, encodeFunctionData, WalletClient } from 'viem'
+import { inboxAbi } from './abis/inbox'
+import { localEthChain } from '../chains'
+import { ArbitrumNetwork } from '../../lib/dataEntities/networks'
+
+export type DepositEthParams = {
+  amount: bigint
+  account: Account | Address
+  gasPrice: bigint
+  to: ArbitrumNetwork
+}
+export async function depositEth(
+  walletClient: WalletClient,
+  { amount, account, gasPrice, to }: DepositEthParams
+) {
+  const signedTx = await walletClient.signTransaction({
+    to: to.ethBridge.inbox as Address,
+    value: amount,
+    data: encodeFunctionData({
+      abi: inboxAbi,
+      functionName: 'depositEth',
+    }),
+    from: typeof account === 'string' ? account : account.address,
+    account,
+    chain: localEthChain,
+    gas: BigInt('130000'),
+    maxFeePerGas: gasPrice,
+    maxPriorityFeePerGas: gasPrice,
+  })
+
+  return signedTx
+}

src/experimental/arbitrumDeposit/prepareDepositEthTransaction.ts

@@ -0,0 +1,23 @@
+import { Account, Address, encodeFunctionData, PublicClient } from 'viem'
+import { inboxAbi } from './abis/inbox'
+
+export type PrepareDepositEthTransaction = {
+  amount: bigint
+  account: Account
+  inbox: Address
+}
+export async function prepareDepositEthTransaction(
+  publicClient: PublicClient,
+  { amount, account, inbox }: PrepareDepositEthTransaction
+) {
+  return publicClient.prepareTransactionRequest({
+    chain: publicClient.chain,
+    to: inbox,
+    data: encodeFunctionData({
+      abi: inboxAbi,
+      functionName: 'depositEth',
+    }),
+    value: amount,
+    account,
+  })
+}

src/experimental/arbitrumDeposit/publicActions.ts

@@ -0,0 +1,16 @@
+import { PublicClient } from 'viem'
+import { sendDepositEth, SendDepositEthParams } from './sendDepositEth'
+
+export type ArbitrumPublicActions = {
+  sendDepositEth: (args: SendDepositEthParams) => Promise<`0x${string}`>
+}
+
+export function arbitrumPublicActions() {
+  return <TClient extends PublicClient>(
+    publicClient: TClient
+  ): ArbitrumPublicActions => {
+    return {
+      sendDepositEth: args => sendDepositEth(publicClient, args),
+    }
+  }
+}

src/experimental/arbitrumDeposit/sendDepositEth.ts

@@ -0,0 +1,22 @@
+import { parseTransaction, PublicClient, serializeTransaction } from 'viem'
+
+export type SendDepositEthParams = {
+  signedTx: any
+}
+export async function sendDepositEth(
+  publicClient: PublicClient,
+  { signedTx }: SendDepositEthParams
+) {
+  // Parse and serialize with L2 chain ID
+  const parsedTx = parseTransaction(signedTx.raw)
+  const serializedTx = serializeTransaction({
+    ...parsedTx,
+  })
+
+  // Send to L2
+  const hash = await publicClient.sendRawTransaction({
+    serializedTransaction: serializedTx,
+  })
+
+  return hash
+}

src/experimental/arbitrumDeposit/walletActions.ts

@@ -0,0 +1,16 @@
+import { type WalletClient } from 'viem'
+import { depositEth, DepositEthParams } from './depositEth'
+
+export type ArbitrumWalletActions = {
+  depositEth: (args: DepositEthParams) => Promise<`0x${string}`>
+}
+
+export function arbitrumWalletActions() {
+  return <TClient extends WalletClient>(
+    walletClient: TClient
+  ): ArbitrumWalletActions => {
+    return {
+      depositEth: args => depositEth(walletClient, args),
+    }
+  }
+}

src/experimental/createArbitrumClient.ts

@@ -0,0 +1,62 @@
+import { Address, PublicClient, WalletClient } from 'viem'
+import { arbitrum, arbitrumNova, arbitrumSepolia } from 'viem/chains'
+import { prepareDepositEthTransaction } from './arbitrumDeposit/prepareDepositEthTransaction'
+
+function getInboxFromChainId(
+  chainId:
+    | typeof arbitrum.id
+    | typeof arbitrumNova.id
+    | typeof arbitrumSepolia.id
+) {
+  return {
+    [arbitrum.id]: '0x...',
+    [arbitrumNova.id]: '0x...',
+    [arbitrumSepolia.id]: '0x...',
+  }[chainId]
+}
+
+export async function createArbitrumClient({
+  parentChainPublicClient,
+  parentChainWalletClient,
+  childChainPublicClient,
+  childChainWalletClient,
+}: {
+  parentChainPublicClient: PublicClient
+  parentChainWalletClient: WalletClient
+  childChainPublicClient: PublicClient
+  childChainWalletClient: WalletClient
+}): Promise<{
+  depositEth: (amount: bigint) => void
+}> {
+  return {
+    async depositEth(amount: bigint) {
+      const tx = await prepareDepositEthTransaction(parentChainPublicClient, {
+        amount,
+        account: parentChainWalletClient.account!,
+        inbox: getInboxFromChainId(
+          childChainWalletClient.chain?.id!
+        ) as Address,
+      })
+      const hash = await parentChainPublicClient.sendRawTransaction({
+        serializedTransaction: await parentChainWalletClient.signTransaction(
+          tx
+        ),
+      })
+
+      // Await on childChainPublicClient for the transaction
+      return hash
+    },
+  }
+}
+
+/**
+ * const { depositEth } = createArbitrumClient({
+ *   parentChainPublicClient,
+ *   parentChainWalletClient,
+ *   childChainPublicClient,
+ *   childChainWalletClient,
+ * })
+ *
+ * depositEth({ amount: 150000n })
+ *
+ */