EIP-5559 with getDeferralHandler

packages/client/package.json

@@ -4,6 +4,7 @@
     "test": "npm-run-all test:**",
     "test:l1": "hardhat test ./test/arb.e2e.spec.ts --network localhost",
     "test:db": "hardhat test ./test/db.e2e.spec.ts --network localhost",
+    "test:metadata": "hardhat test ./test/metadata.e2e.spec.ts --network localhost",
     "start:read": "ts-node src/read.ts",
     "start:write": "ts-node src/write.ts",
     "lint": "eslint . --ext .ts --fix"

packages/client/src/client.ts

@@ -56,7 +56,7 @@ export async function handleDBStorage({
     message,
     types: {
       Message: [
-        { name: 'callData', type: 'bytes' },
+        { name: 'data', type: 'bytes' },
         { name: 'sender', type: 'address' },
         { name: 'expirationTimestamp', type: 'uint256' },
       ],
@@ -65,7 +65,7 @@ export async function handleDBStorage({
   })
   return await ccipRequest({
     body: {
-      data: message.callData,
+      data: message.data,
       signature: { message, domain, signature },
       sender: message.sender,
     },

packages/client/src/read.ts

@@ -15,6 +15,7 @@ import {
 import { normalize } from 'viem/ens'
 import { getChain } from './client'
 import { abi as l1Abi } from '@blockful/contracts/out/L1Resolver.sol/L1Resolver.json'
+
 config({
   path: process.env.ENV_FILE || '../.env',
 })

packages/client/src/write.ts

@@ -7,6 +7,7 @@ import { config } from 'dotenv'
 import {
   Hex,
   createPublicClient,
+  decodeErrorResult,
   encodeFunctionData,
   http,
   namehash,
@@ -18,7 +19,9 @@ import {
 import { normalize, packetToBytes } from 'viem/ens'
 import { privateKeyToAccount } from 'viem/accounts'
 
-import { abi as l1Abi } from '@blockful/contracts/out/L1Resolver.sol/L1Resolver.json'
+import { abi } from '@blockful/contracts/out/DatabaseResolver.sol/DatabaseResolver.json'
+import { abi as universalResolverResolveAbi } from '@blockful/contracts/out/UniversalResolver.sol/UniversalResolver.json'
+import { abi as scAbi } from '@blockful/contracts/out/SubdomainController.sol/SubdomainController.json'
 import { MessageData, DomainData } from '@blockful/gateway/src/types'
 import { getRevertErrorData, getChain, handleDBStorage } from './client'
 
@@ -57,50 +60,25 @@ const _ = (async () => {
   const node = namehash(name)
   const signer = privateKeyToAccount(privateKey as Hex)
 
-  const duration = 31556952000n
-
-  const resolverAddr = await client.getEnsResolver({
-    name,
-    universalResolverAddress: universalResolver as Hex,
-  })
-
-  // SUBDOMAIN PRICING
-
-  let value = 0n
-  try {
-    const [_value /* commitTime */ /* extraData */, ,] =
-      (await client.readContract({
-        address: resolverAddr,
-        abi: l1Abi,
-        functionName: 'registerParams',
-        args: [toHex(name), duration],
-      })) as [bigint, bigint, Hex]
-    value = _value
-  } catch {
-    // interface not implemented by the resolver
-  }
-
-  // REGISTER NEW SUBDOMAIN
-
   const data: Hex[] = [
     encodeFunctionData({
       functionName: 'setText',
-      abi: l1Abi,
+      abi,
       args: [node, 'com.twitter', `@${name}`],
     }),
     encodeFunctionData({
       functionName: 'setAddr',
-      abi: l1Abi,
+      abi,
       args: [node, '0x3a872f8FED4421E7d5BE5c98Ab5Ea0e0245169A0'],
     }),
     encodeFunctionData({
       functionName: 'setAddr',
-      abi: l1Abi,
+      abi,
       args: [node, 1n, '0x3a872f8FED4421E7d5BE5c98Ab5Ea0e0245169A0'],
     }),
     encodeFunctionData({
       functionName: 'setContenthash',
-      abi: l1Abi,
+      abi,
       args: [
         node,
         stringToHex(
@@ -110,9 +88,10 @@ const _ = (async () => {
     }),
   ]
 
+  const duration = 31556952000n
   const calldata = {
     functionName: 'register',
-    abi: l1Abi,
+    abi: scAbi,
     args: [
       encodedName,
       signer.address, // owner
@@ -124,18 +103,35 @@ const _ = (async () => {
       0, // fuses
       zeroHash,
     ],
-    address: resolverAddr,
     account: signer,
-    value,
   }
 
   try {
-    await client.simulateContract(calldata)
+    await client.readContract({
+      address: universalResolver as Hex,
+      abi: universalResolverResolveAbi,
+      functionName: 'resolve',
+      args: [
+        encodedName,
+        encodeFunctionData({
+          functionName: 'getDeferralHandler',
+          abi,
+          args: [encodeFunctionData(calldata)],
+        }),
+      ],
+    })
   } catch (err) {
     const data = getRevertErrorData(err)
-    switch (data?.errorName) {
+    if (!data || !data.args || data.args?.length === 0) return
+
+    const [params] = data.args
+    const errorResult = decodeErrorResult({
+      abi,
+      data: params as Hex,
+    })
+    switch (errorResult?.errorName) {
       case 'StorageHandledByOffChainDatabase': {
-        const [domain, url, message] = data.args as [
+        const [domain, url, message] = errorResult.args as [
           DomainData,
           string,
           MessageData,
@@ -144,17 +140,37 @@ const _ = (async () => {
         return
       }
       case 'StorageHandledByL2': {
-        const [chainId, contractAddress] = data.args as [bigint, `0x${string}`]
+        const [chainId, contractAddress] = errorResult.args as [
+          bigint,
+          `0x${string}`,
+        ]
 
         const l2Client = createPublicClient({
           chain: getChain(Number(chainId)),
           transport: http(providerL2),
         }).extend(walletActions)
 
+        // SUBDOMAIN PRICING
+
+        let value = 0n
+        try {
+          const [_value /* commitTime */ /* extraData */, ,] =
+            (await client.readContract({
+              address: contractAddress,
+              abi: scAbi,
+              functionName: 'registerParams',
+              args: [encodedName, duration],
+            })) as [bigint, bigint, Hex]
+          value = _value
+        } catch {
+          // interface not implemented by the resolver
+        }
+
         try {
           const { request } = await l2Client.simulateContract({
             ...calldata,
             address: contractAddress,
+            value,
           })
           await l2Client.writeContract(request)
         } catch (err) {