feat(BA-2133): ENSIP-19 updates for registration flow for EOAs

apps/web/src/hooks/useRegisterNameCallback.ts

@@ -25,6 +25,8 @@ import { encodeFunctionData, namehash } from 'viem';
 import { useAccount } from 'wagmi';
 import { secondsInYears } from 'apps/web/src/utils/secondsInYears';
 import L2ReverseRegistrarAbi from 'apps/web/src/abis/L2ReverseRegistrarAbi';
+import { encodePacked, getFunctionSelector, keccak256, type AbiFunction } from 'viem';
+import { usePublicClient, useSignMessage } from 'wagmi';
 
 type UseRegisterNameCallbackReturnType = {
   callback: () => Promise<void>;
@@ -35,6 +37,11 @@ type UseRegisterNameCallbackReturnType = {
   hasExistingBasename: boolean;
   batchCallsStatus: BatchCallsStatus;
   registerNameStatus: WriteTransactionWithReceiptStatus;
+  prepareReverseRecordSignature: () => Promise<{
+    coinTypes: readonly bigint[];
+    signatureExpiry: bigint;
+    signature: `0x${string}`;
+  }>;
 };
 
 export function useRegisterNameCallback(
@@ -50,6 +57,8 @@ export function useRegisterNameCallback(
   const { paymasterService: paymasterServiceEnabled } = useCapabilitiesSafe({
     chainId: basenameChain.id,
   });
+  const publicClient = usePublicClient({ chainId: basenameChain.id });
+  const { signMessageAsync } = useSignMessage();
 
   // If user has a basename, reverse record is set to false
   const { data: baseEnsName, isLoading: baseEnsNameIsLoading } = useBaseEnsName({
@@ -62,6 +71,11 @@ export function useRegisterNameCallback(
   );
 
   const [reverseRecord, setReverseRecord] = useState<boolean>(!hasExistingBasename);
+  const [reverseSigPayload, setReverseSigPayload] = useState<{
+    coinTypes: readonly bigint[];
+    signatureExpiry: bigint;
+    signature: `0x${string}`;
+  } | null>(null);
 
   // Transaction with paymaster enabled
   const { initiateBatchCalls, batchCallsStatus, batchCallsIsLoading, batchCallsError } =
@@ -85,6 +99,35 @@ export function useRegisterNameCallback(
   const normalizedName = normalizeEnsDomainName(name);
   const isDiscounted = Boolean(discountKey && validationData);
 
+  const prepareReverseRecordSignature = useCallback(async () => {
+    if (!address) throw new Error('No address');
+    if (!publicClient) throw new Error('No public client');
+
+    // Use the L2 Reverse Registrar address configured for this chain.
+    const reverseRegistrar = USERNAME_L2_REVERSE_REGISTRAR_ADDRESSES[basenameChain.id];
+
+    const functionAbi = L2ReverseRegistrarAbi.find(
+      (f) => f.type === 'function' && f.name === 'setNameForAddrWithSignature',
+    ) as unknown as AbiFunction;
+    const selector = getFunctionSelector(functionAbi);
+
+    const signatureExpiry = BigInt(Math.floor(Date.now() / 1000) + 5 * 60);
+    const coinTypes = [BigInt(convertChainIdToCoinTypeUint(basenameChain.id))] as const;
+    const fullName = formatBaseEthDomain(name, basenameChain.id);
+
+    const preimage = encodePacked(
+      ['address', 'bytes4', 'address', 'uint256', 'string', 'uint256[]'],
+      [reverseRegistrar, selector, address, signatureExpiry, fullName, coinTypes],
+    );
+
+    const digest = keccak256(preimage);
+    const signature = await signMessageAsync({ message: { raw: digest } });
+
+    const payload = { coinTypes, signatureExpiry, signature } as const;
+    setReverseSigPayload(payload);
+    return payload;
+  }, [address, basenameChain.id, name, publicClient, signMessageAsync]);
+
   // Callback
   const registerName = useCallback(async () => {
     if (!address) return;
@@ -114,16 +157,35 @@ export function useRegisterNameCallback(
       ],
     });
 
+    let coinTypesForRequest: readonly bigint[] = [];
+    let signatureExpiryForRequest: bigint = 0n;
+    let signatureForRequest: `0x${string}` = '0x';
+
+    if (!paymasterServiceEnabled && reverseRecord) {
+      const payload =
+        reverseSigPayload ??
+        (await prepareReverseRecordSignature().catch((e) => {
+          logError(e, 'Reverse record signature step failed');
+          return null;
+        }));
+      if (!payload) return;
+      coinTypesForRequest = payload.coinTypes;
+      signatureExpiryForRequest = payload.signatureExpiry;
+      signatureForRequest = payload.signature;
+    }
+
+    const reverseRecordForRequest = paymasterServiceEnabled ? false : reverseRecord;
+
     const registerRequest = {
       name: normalizedName, // The name being registered.
       owner: address, // The address of the owner for the name.
       duration: secondsInYears(years), // The duration of the registration in seconds.
       resolver: UPGRADEABLE_L2_RESOLVER_ADDRESSES[basenameChain.id], // The address of the resolver to set for this name.
       data: [addressData, baseCointypeData, nameData], //  Multicallable data bytes for setting records in the associated resolver upon registration.
-      reverseRecord, // Bool to decide whether to set this name as the "primary" name for the `owner`.
-      coinTypes: [],
-      signatureExpiry: 0,
-      signature: '0x',
+      reverseRecord: reverseRecordForRequest, // When using paymaster (atomic batch), set via separate call instead of signature flow.
+      coinTypes: coinTypesForRequest,
+      signatureExpiry: signatureExpiryForRequest,
+      signature: signatureForRequest,
     };
 
     try {
@@ -191,5 +253,6 @@ export function useRegisterNameCallback(
     hasExistingBasename,
     batchCallsStatus,
     registerNameStatus,
+    prepareReverseRecordSignature,
   };
 }