tempo.ts 0.4.4 → 0.5.0

package/src/viem/Actions/faucet.ts

@@ -1,4 +1,13 @@
-import type { Account, Address, Chain, Client, Hash, Transport } from 'viem'
+import type {
+  Account,
+  Address,
+  Chain,
+  Client,
+  Hash,
+  TransactionReceipt,
+  Transport,
+} from 'viem'
+import { waitForTransactionReceipt } from 'viem/actions'
 import { parseAccount } from 'viem/utils'
 
 /**
@@ -48,3 +57,56 @@ export declare namespace fund {
 
   export type ReturnValue = readonly Hash[]
 }
+
+/**
+ * Funds an account with an initial amount of set token(s)
+ * on Tempo's testnet. Waits for the transactions to be included
+ * on a block before returning a response.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const hashes = await Actions.faucet.fundSync(client, {
+ *   account: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function fundSync<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: fundSync.Parameters,
+): Promise<fundSync.ReturnValue> {
+  const account = parseAccount(parameters.account)
+  const hashes = await client.request<{
+    Method: 'tempo_fundAddress'
+    Parameters: [address: Address]
+    ReturnType: readonly Hash[]
+  }>({
+    method: 'tempo_fundAddress',
+    params: [account.address],
+  })
+  const receipts = await Promise.all(
+    hashes.map((hash) => waitForTransactionReceipt(client, { hash })),
+  )
+  return receipts
+}
+
+export declare namespace fundSync {
+  export type Parameters = {
+    /** Account to fund. */
+    account: Account | Address
+  }
+
+  export type ReturnValue = readonly TransactionReceipt[]
+}

package/src/viem/Actions/fee.test.ts

@@ -3,10 +3,14 @@ import { Abis } from 'tempo.ts/viem'
 import { parseUnits } from 'viem'
 import { writeContractSync } from 'viem/actions'
 import { afterEach, describe, expect, test } from 'vitest'
-import { accounts, client, rpcUrl } from '../../../test/viem/config.js'
+import { rpcUrl } from '../../../test/config.js'
+import {
+  accounts,
+  clientWithAccount,
+  fundAddress,
+} from '../../../test/viem/config.js'
 import * as actions from './index.js'
 
-const account = accounts[0]
 const account2 = accounts[1]
 const account3 = accounts[2]
 
@@ -17,42 +21,23 @@ afterEach(async () => {
 describe('getUserToken', () => {
   test('default', async () => {
     // Fund accounts
-    await writeContractSync(client, {
-      abi: Abis.tip20,
-      address: '0x20c0000000000000000000000000000000000001',
-      functionName: 'transfer',
-      args: [account2.address, parseUnits('100', 6)],
-    })
-    await writeContractSync(client, {
-      abi: Abis.tip20,
-      address: '0x20c0000000000000000000000000000000000001',
-      functionName: 'transfer',
-      args: [account3.address, parseUnits('100', 6)],
-    })
+    await fundAddress(clientWithAccount, { address: account2.address })
+    await fundAddress(clientWithAccount, { address: account3.address })
 
     // Set token (address)
-    await actions.fee.setUserTokenSync(client, {
+    await actions.fee.setUserTokenSync(clientWithAccount, {
       account: account2,
       token: '0x20c0000000000000000000000000000000000001',
     })
 
     // Set another token (id)
-    await actions.fee.setUserTokenSync(client, {
+    await actions.fee.setUserTokenSync(clientWithAccount, {
       account: account3,
       token: 2n,
     })
 
-    // Assert that account (with default) & account2 (with custom) tokens are set correctly.
-    expect(
-      await actions.fee.getUserToken(client, { account }),
-    ).toMatchInlineSnapshot(`
-      {
-        "address": "0x20C0000000000000000000000000000000000001",
-        "id": 1n,
-      }
-    `)
     expect(
-      await actions.fee.getUserToken(client, { account: account2 }),
+      await actions.fee.getUserToken(clientWithAccount, { account: account2 }),
     ).toMatchInlineSnapshot(`
       {
         "address": "0x20C0000000000000000000000000000000000001",
@@ -60,7 +45,7 @@ describe('getUserToken', () => {
       }
     `)
     expect(
-      await actions.fee.getUserToken(client, { account: account3 }),
+      await actions.fee.getUserToken(clientWithAccount, { account: account3 }),
     ).toMatchInlineSnapshot(`
       {
         "address": "0x20C0000000000000000000000000000000000002",
@@ -72,7 +57,9 @@ describe('getUserToken', () => {
 
 describe('setUserToken', () => {
   test('default', async () => {
-    expect(await actions.fee.getUserToken(client)).toMatchInlineSnapshot(
+    expect(
+      await actions.fee.getUserToken(clientWithAccount),
+    ).toMatchInlineSnapshot(
       `
       {
         "address": "0x20C0000000000000000000000000000000000001",
@@ -82,7 +69,7 @@ describe('setUserToken', () => {
     )
 
     const { receipt: setReceipt, ...setResult } =
-      await actions.fee.setUserTokenSync(client, {
+      await actions.fee.setUserTokenSync(clientWithAccount, {
         token: 2n,
       })
     expect(setReceipt).toBeDefined()
@@ -93,7 +80,9 @@ describe('setUserToken', () => {
       }
     `)
 
-    expect(await actions.fee.getUserToken(client, {})).toMatchInlineSnapshot(
+    expect(
+      await actions.fee.getUserToken(clientWithAccount, {}),
+    ).toMatchInlineSnapshot(
       `
         {
           "address": "0x20C0000000000000000000000000000000000002",
@@ -103,7 +92,7 @@ describe('setUserToken', () => {
     )
 
     const { receipt: resetReceipt, ...resetResult } =
-      await actions.fee.setUserTokenSync(client, {
+      await actions.fee.setUserTokenSync(clientWithAccount, {
         feeToken: 1n,
         token: 1n,
       })
@@ -115,7 +104,9 @@ describe('setUserToken', () => {
       }
     `)
 
-    expect(await actions.fee.getUserToken(client, {})).toMatchInlineSnapshot(
+    expect(
+      await actions.fee.getUserToken(clientWithAccount, {}),
+    ).toMatchInlineSnapshot(
       `
       {
         "address": "0x20C0000000000000000000000000000000000001",
@@ -134,7 +125,7 @@ describe('watchSetUserToken', async () => {
     }> = []
 
     // Start watching for user token set events
-    const unwatch = actions.fee.watchSetUserToken(client, {
+    const unwatch = actions.fee.watchSetUserToken(clientWithAccount, {
       onUserTokenSet: (args, log) => {
         receivedSets.push({ args, log })
       },
@@ -142,27 +133,27 @@ describe('watchSetUserToken', async () => {
 
     try {
       // Set token for account2
-      await writeContractSync(client, {
+      await writeContractSync(clientWithAccount, {
         abi: Abis.tip20,
         address: '0x20c0000000000000000000000000000000000001',
         functionName: 'transfer',
         args: [account2.address, parseUnits('1', 6)],
       })
 
-      await actions.fee.setUserTokenSync(client, {
+      await actions.fee.setUserTokenSync(clientWithAccount, {
         account: account2,
         token: '0x20c0000000000000000000000000000000000001',
       })
 
       // Set token for account3
-      await writeContractSync(client, {
+      await writeContractSync(clientWithAccount, {
         abi: Abis.tip20,
         address: '0x20c0000000000000000000000000000000000001',
         functionName: 'transfer',
         args: [account3.address, parseUnits('1', 6)],
       })
 
-      await actions.fee.setUserTokenSync(client, {
+      await actions.fee.setUserTokenSync(clientWithAccount, {
         account: account3,
         token: '0x20c0000000000000000000000000000000000002',
       })
@@ -195,7 +186,7 @@ describe('watchSetUserToken', async () => {
     }> = []
 
     // Start watching for user token set events only for account2
-    const unwatch = actions.fee.watchSetUserToken(client, {
+    const unwatch = actions.fee.watchSetUserToken(clientWithAccount, {
       args: {
         user: account2.address,
       },
@@ -206,14 +197,14 @@ describe('watchSetUserToken', async () => {
 
     try {
       // Transfer gas to accounts
-      await writeContractSync(client, {
+      await writeContractSync(clientWithAccount, {
         abi: Abis.tip20,
         address: '0x20c0000000000000000000000000000000000001',
         functionName: 'transfer',
         args: [account2.address, parseUnits('1', 6)],
       })
 
-      await writeContractSync(client, {
+      await writeContractSync(clientWithAccount, {
         abi: Abis.tip20,
         address: '0x20c0000000000000000000000000000000000001',
         functionName: 'transfer',
@@ -221,19 +212,19 @@ describe('watchSetUserToken', async () => {
       })
 
       // Set token for account2 (should be captured)
-      await actions.fee.setUserTokenSync(client, {
+      await actions.fee.setUserTokenSync(clientWithAccount, {
         account: account2,
         token: '0x20c0000000000000000000000000000000000001',
       })
 
       // Set token for account3 (should NOT be captured)
-      await actions.fee.setUserTokenSync(client, {
+      await actions.fee.setUserTokenSync(clientWithAccount, {
         account: account3,
         token: '0x20c0000000000000000000000000000000000002',
       })
 
       // Set token for account2 again (should be captured)
-      await actions.fee.setUserTokenSync(client, {
+      await actions.fee.setUserTokenSync(clientWithAccount, {
         account: account2,
         feeToken: 1n,
         token: 2n,