tempo.ts 0.5.1 → 0.5.2

package/src/viem/Transport.ts

@@ -1,4 +1,15 @@
-import { createTransport, type Transport } from 'viem'
+import * as Address from 'ox/Address'
+import * as Hash from 'ox/Hash'
+import * as Hex from 'ox/Hex'
+import * as Provider from 'ox/Provider'
+import * as RpcRequest from 'ox/RpcRequest'
+import { createClient, createTransport, type Transport } from 'viem'
+import {
+  getTransactionReceipt,
+  sendTransaction,
+  sendTransactionSync,
+} from 'viem/actions'
+import type * as tempo_Chain from './Chain.js'
 import * as Transaction from './Transaction.js'
 
 export type FeePayer = Transport<typeof withFeePayer.type>
@@ -45,3 +56,98 @@ export declare namespace withFeePayer {
 
   export type ReturnValue = FeePayer
 }
+
+/**
+ * Creates a transport that instruments a compatibility layer for
+ * `wallet_` RPC actions (`sendCalls`, `getCallsStatus`, etc).
+ *
+ * @param transport - Transport to wrap.
+ * @returns Transport.
+ */
+export function walletNamespaceCompat(transport: Transport): Transport {
+  const sendCallsMagic = Hash.keccak256(Hex.fromString('TEMPO_5792'))
+
+  return (options) => {
+    const t = transport(options)
+
+    const account = options.account
+
+    type Chain = ReturnType<ReturnType<typeof tempo_Chain.define>>
+    const chain = options.chain as Chain
+
+    return {
+      ...t,
+      async request(args: never) {
+        const request = RpcRequest.from(args)
+
+        const client = createClient({
+          account,
+          chain,
+          transport,
+        })
+
+        if (request.method === 'wallet_sendCalls') {
+          const params = request.params[0] ?? {}
+          const { capabilities, chainId, from } = params
+          const { sync } = capabilities ?? {}
+
+          if (!account) throw new Provider.DisconnectedError()
+          if (!chainId) throw new Provider.UnsupportedChainIdError()
+          if (Number(chainId) !== client.chain.id)
+            throw new Provider.UnsupportedChainIdError()
+          if (from && !Address.isEqual(from, account.address))
+            throw new Provider.DisconnectedError()
+
+          const calls = (params.calls ?? []).map((call) => ({
+            to: call.to,
+            value: call.value ? BigInt(call.value) : undefined,
+            data: call.data,
+          }))
+
+          const hash = await (async () => {
+            if (!sync)
+              return sendTransaction(client, {
+                account,
+                calls,
+              })
+
+            const { transactionHash } = await sendTransactionSync(client, {
+              account,
+              calls,
+            })
+            return transactionHash
+          })()
+
+          const id = Hex.concat(hash, Hex.padLeft(chainId, 32), sendCallsMagic)
+
+          return {
+            capabilities: { sync },
+            id,
+          }
+        }
+
+        if (request.method === 'wallet_getCallsStatus') {
+          const [id] = request.params ?? []
+          if (!id) throw new Error('`id` not found')
+          if (!id.endsWith(sendCallsMagic.slice(2)))
+            throw new Error('`id` not supported')
+          Hex.assert(id)
+
+          const hash = Hex.slice(id, 0, 32)
+          const chainId = Hex.slice(id, 32, 64)
+
+          const receipt = await getTransactionReceipt(client, { hash })
+          return {
+            atomic: true,
+            chainId: Number(chainId),
+            receipts: [receipt],
+            status: receipt.status === 'success' ? 200 : 500,
+            version: '2.0.0',
+          }
+        }
+
+        return t.request(args)
+      },
+    } as never
+  }
+}

package/src/wagmi/Actions/index.ts

@@ -2,5 +2,6 @@ export * as amm from './amm.js'
 export * as dex from './dex.js'
 export * as faucet from './faucet.js'
 export * as fee from './fee.js'
+export * as policy from './policy.js'
 export * as reward from './reward.js'
 export * as token from './token.js'

package/src/wagmi/Actions/policy.test.ts

@@ -0,0 +1,461 @@
+import { connect } from '@wagmi/core'
+import { describe, expect, test } from 'vitest'
+import { accounts } from '../../../test/viem/config.js'
+import { config, queryClient } from '../../../test/wagmi/config.js'
+import * as policy from './policy.js'
+
+const account = accounts[0]
+const account2 = accounts[1]
+
+describe('create', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const result = await policy.createSync(config, {
+      type: 'whitelist',
+    })
+
+    expect(result.receipt).toBeDefined()
+    expect(result.policyId).toBeDefined()
+    expect(result.policyType).toBe(0)
+    expect(result.updater).toBe(account.address)
+
+    // verify policy was created
+    const data = await policy.getData(config, {
+      policyId: result.policyId,
+    })
+    expect(data.admin).toBe(account.address)
+    expect(data.type).toBe('whitelist')
+  })
+
+  test('behavior: blacklist', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const result = await policy.createSync(config, {
+      type: 'blacklist',
+    })
+
+    expect(result.receipt).toBeDefined()
+    expect(result.policyId).toBeDefined()
+    expect(result.policyType).toBe(1)
+    expect(result.updater).toBe(account.address)
+
+    // verify policy was created
+    const data = await policy.getData(config, {
+      policyId: result.policyId,
+    })
+    expect(data.admin).toBe(account.address)
+    expect(data.type).toBe('blacklist')
+  })
+})
+
+describe('setAdmin', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'whitelist',
+    })
+
+    // set new admin
+    const { receipt: setAdminReceipt, ...setAdminResult } =
+      await policy.setAdminSync(config, {
+        policyId,
+        admin: account2.address,
+      })
+    expect(setAdminReceipt).toBeDefined()
+    expect(setAdminResult.policyId).toBe(policyId)
+    expect(setAdminResult.admin).toBe(account2.address)
+    expect(setAdminResult.updater).toBe(account.address)
+
+    {
+      // verify new admin
+      const data = await policy.getData(config, {
+        policyId,
+      })
+      expect(data.admin).toBe(account2.address)
+    }
+  })
+})
+
+describe('modifyWhitelist', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create whitelist policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'whitelist',
+    })
+
+    // verify account2 is not authorized
+    {
+      const isAuthorized = await policy.isAuthorized(config, {
+        policyId,
+        user: account2.address,
+      })
+      expect(isAuthorized).toBe(false)
+    }
+
+    // add account2 to whitelist
+    const addResult = await policy.modifyWhitelistSync(config, {
+      policyId,
+      address: account2.address,
+      allowed: true,
+    })
+
+    expect(addResult.receipt).toBeDefined()
+    expect(addResult.policyId).toBe(policyId)
+    expect(addResult.account).toBe(account2.address)
+    expect(addResult.allowed).toBe(true)
+    expect(addResult.updater).toBe(account.address)
+
+    // verify account2 is authorized
+    {
+      const isAuthorized = await policy.isAuthorized(config, {
+        policyId,
+        user: account2.address,
+      })
+      expect(isAuthorized).toBe(true)
+    }
+
+    // remove account2 from whitelist
+    const removeResult = await policy.modifyWhitelistSync(config, {
+      policyId,
+      address: account2.address,
+      allowed: false,
+    })
+
+    expect(removeResult.receipt).toBeDefined()
+    expect(removeResult.policyId).toBe(policyId)
+    expect(removeResult.account).toBe(account2.address)
+    expect(removeResult.allowed).toBe(false)
+    expect(removeResult.updater).toBe(account.address)
+
+    // verify account2 is no longer authorized
+    {
+      const isAuthorized = await policy.isAuthorized(config, {
+        policyId,
+        user: account2.address,
+      })
+      expect(isAuthorized).toBe(false)
+    }
+  })
+})
+
+describe('modifyBlacklist', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create blacklist policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'blacklist',
+    })
+
+    // verify account2 is authorized (not blacklisted)
+    {
+      const isAuthorized = await policy.isAuthorized(config, {
+        policyId,
+        user: account2.address,
+      })
+      expect(isAuthorized).toBe(true)
+    }
+
+    // add account2 to blacklist
+    const addResult = await policy.modifyBlacklistSync(config, {
+      policyId,
+      address: account2.address,
+      restricted: true,
+    })
+
+    expect(addResult.receipt).toBeDefined()
+    expect(addResult.policyId).toBe(policyId)
+    expect(addResult.account).toBe(account2.address)
+    expect(addResult.restricted).toBe(true)
+    expect(addResult.updater).toBe(account.address)
+
+    // verify account2 is not authorized (blacklisted)
+    {
+      const isAuthorized = await policy.isAuthorized(config, {
+        policyId,
+        user: account2.address,
+      })
+      expect(isAuthorized).toBe(false)
+    }
+
+    // remove account2 from blacklist
+    const removeResult = await policy.modifyBlacklistSync(config, {
+      policyId,
+      address: account2.address,
+      restricted: false,
+    })
+
+    expect(removeResult.receipt).toBeDefined()
+    expect(removeResult.policyId).toBe(policyId)
+    expect(removeResult.account).toBe(account2.address)
+    expect(removeResult.restricted).toBe(false)
+    expect(removeResult.updater).toBe(account.address)
+
+    // verify account2 is authorized again
+    {
+      const isAuthorized = await policy.isAuthorized(config, {
+        policyId,
+        user: account2.address,
+      })
+      expect(isAuthorized).toBe(true)
+    }
+  })
+})
+
+describe('getData', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'whitelist',
+    })
+
+    {
+      // get policy data
+      const data = await policy.getData(config, {
+        policyId,
+      })
+      expect(data.admin).toBe(account.address)
+      expect(data.type).toBe('whitelist')
+    }
+  })
+
+  test('behavior: blacklist', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create blacklist policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'blacklist',
+    })
+
+    {
+      // get policy data
+      const data = await policy.getData(config, {
+        policyId,
+      })
+      expect(data.admin).toBe(account.address)
+      expect(data.type).toBe('blacklist')
+    }
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      await connect(config, {
+        connector: config.connectors[0]!,
+      })
+
+      // create policy
+      const { policyId } = await policy.createSync(config, {
+        type: 'whitelist',
+      })
+
+      const options = policy.getData.queryOptions(config, {
+        policyId,
+      })
+      const data = await queryClient.fetchQuery(options)
+
+      expect(data.admin).toBe(account.address)
+      expect(data.type).toBe('whitelist')
+    })
+  })
+})
+
+describe('isAuthorized', () => {
+  test('special policy: always-reject (policyId 0)', async () => {
+    const isAuthorized = await policy.isAuthorized(config, {
+      policyId: 0n,
+      user: account.address,
+    })
+    expect(isAuthorized).toBe(false)
+  })
+
+  test('special policy: always-allow (policyId 1)', async () => {
+    const isAuthorized = await policy.isAuthorized(config, {
+      policyId: 1n,
+      user: account.address,
+    })
+    expect(isAuthorized).toBe(true)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const options = policy.isAuthorized.queryOptions(config, {
+        policyId: 1n,
+        user: account.address,
+      })
+      const isAuthorized = await queryClient.fetchQuery(options)
+
+      expect(isAuthorized).toBe(true)
+    })
+  })
+})
+
+describe('watchCreate', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const events: any[] = []
+    const unwatch = policy.watchCreate(config, {
+      onPolicyCreated: (args, log) => {
+        events.push({ args, log })
+      },
+    })
+
+    // create policy
+    await policy.createSync(config, {
+      type: 'whitelist',
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 500))
+    unwatch()
+
+    expect(events.length).toBe(1)
+    expect(events[0].args.policyId).toBeDefined()
+    expect(events[0].args.updater).toBe(account.address)
+    expect(events[0].args.type).toBe('whitelist')
+  })
+})
+
+describe('watchAdminUpdated', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'whitelist',
+    })
+
+    const events: any[] = []
+    const unwatch = policy.watchAdminUpdated(config, {
+      onAdminUpdated: (args, log) => {
+        events.push({ args, log })
+      },
+    })
+
+    // set new admin
+    await policy.setAdminSync(config, {
+      policyId,
+      admin: account2.address,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 500))
+    unwatch()
+
+    expect(events.length).toBe(1)
+    expect(events[0].args.policyId).toBe(policyId)
+    expect(events[0].args.updater).toBe(account.address)
+    expect(events[0].args.admin).toBe(account2.address)
+  })
+})
+
+describe('watchWhitelistUpdated', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create whitelist policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'whitelist',
+    })
+
+    const events: any[] = []
+    const unwatch = policy.watchWhitelistUpdated(config, {
+      onWhitelistUpdated: (args, log) => {
+        events.push({ args, log })
+      },
+    })
+
+    // add address to whitelist
+    await policy.modifyWhitelistSync(config, {
+      policyId,
+      address: account2.address,
+      allowed: true,
+    })
+
+    // remove address from whitelist
+    await policy.modifyWhitelistSync(config, {
+      policyId,
+      address: account2.address,
+      allowed: false,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 500))
+    unwatch()
+
+    expect(events.length).toBe(2)
+    expect(events[0].args.policyId).toBe(policyId)
+    expect(events[0].args.updater).toBe(account.address)
+    expect(events[0].args.account).toBe(account2.address)
+    expect(events[0].args.allowed).toBe(true)
+    expect(events[1].args.allowed).toBe(false)
+  })
+})
+
+describe('watchBlacklistUpdated', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    // create blacklist policy
+    const { policyId } = await policy.createSync(config, {
+      type: 'blacklist',
+    })
+
+    const events: any[] = []
+    const unwatch = policy.watchBlacklistUpdated(config, {
+      onBlacklistUpdated: (args, log) => {
+        events.push({ args, log })
+      },
+    })
+
+    // add address to blacklist
+    await policy.modifyBlacklistSync(config, {
+      policyId,
+      address: account2.address,
+      restricted: true,
+    })
+
+    // remove address from blacklist
+    await policy.modifyBlacklistSync(config, {
+      policyId,
+      address: account2.address,
+      restricted: false,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 500))
+    unwatch()
+
+    expect(events.length).toBe(2)
+    expect(events[0].args.policyId).toBe(policyId)
+    expect(events[0].args.updater).toBe(account.address)
+    expect(events[0].args.account).toBe(account2.address)
+    expect(events[0].args.restricted).toBe(true)
+    expect(events[1].args.restricted).toBe(false)
+  })
+})