@cofhe/sdk 0.0.0-alpha-20260409113701

package/permits/onchain-utils.ts

@@ -0,0 +1,221 @@
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  type Hex,
+  type PublicClient,
+  decodeErrorResult,
+  parseAbi,
+} from 'viem';
+import type { EIP712Domain, Permission } from './types';
+import { TASK_MANAGER_ADDRESS } from '../core/consts.js';
+
+export const getAclAddress = async (publicClient: PublicClient): Promise<Hex> => {
+  const ACL_IFACE = 'function acl() view returns (address)';
+
+  // Parse the ABI for the ACL function
+  const aclAbi = parseAbi([ACL_IFACE]);
+
+  // Get the ACL address
+  return (await publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS as `0x${string}`,
+    abi: aclAbi,
+    functionName: 'acl',
+  })) as `0x${string}`;
+};
+
+export const getAclEIP712Domain = async (publicClient: PublicClient): Promise<EIP712Domain> => {
+  const aclAddress = await getAclAddress(publicClient);
+  const EIP712_DOMAIN_IFACE =
+    'function eip712Domain() public view returns (bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions)';
+
+  // Parse the ABI for the EIP712 domain function
+  const domainAbi = parseAbi([EIP712_DOMAIN_IFACE]);
+
+  // Get the EIP712 domain
+  const domain = await publicClient.readContract({
+    address: aclAddress,
+    abi: domainAbi,
+    functionName: 'eip712Domain',
+  });
+
+  // eslint-disable-next-line no-unused-vars
+  const [_fields, name, version, chainId, verifyingContract, _salt, _extensions] = domain;
+
+  return {
+    name,
+    version,
+    chainId: Number(chainId),
+    verifyingContract,
+  };
+};
+
+export const checkPermitValidityOnChain = async (
+  permission: Permission,
+  publicClient: PublicClient
+): Promise<boolean> => {
+  const aclAddress = await getAclAddress(publicClient);
+
+  // Check if the permit is valid
+  try {
+    await publicClient.simulateContract({
+      address: aclAddress,
+      abi: checkPermitValidityAbi,
+      functionName: 'checkPermitValidity',
+      args: [
+        {
+          issuer: permission.issuer,
+          expiration: BigInt(permission.expiration),
+          recipient: permission.recipient,
+          validatorId: BigInt(permission.validatorId),
+          validatorContract: permission.validatorContract,
+          sealingKey: permission.sealingKey,
+          issuerSignature: permission.issuerSignature,
+          recipientSignature: permission.recipientSignature,
+        },
+      ],
+    });
+    return true;
+  } catch (err: any) {
+    // Viem default handling
+    if (err instanceof BaseError) {
+      const revertError = err.walk((err: any) => err instanceof ContractFunctionRevertedError);
+      if (revertError instanceof ContractFunctionRevertedError) {
+        const errorName = revertError.data?.errorName ?? '';
+        throw new Error(errorName);
+      }
+    }
+
+    // Check details field for custom error names (e.g., from Hardhat test nodes)
+    const customErrorName = extractCustomErrorFromDetails(err, checkPermitValidityAbi);
+    if (customErrorName) {
+      throw new Error(customErrorName);
+    }
+
+    // Hardhat wrapped error will need to be unwrapped to get the return data
+    const hhDetailsData = extractReturnData(err);
+    if (hhDetailsData != null) {
+      const decoded = decodeErrorResult({
+        abi: checkPermitValidityAbi,
+        data: hhDetailsData,
+      });
+
+      throw new Error(decoded.errorName);
+    }
+
+    // Fallback throw the original error
+    throw err;
+  }
+};
+
+function extractCustomErrorFromDetails(err: unknown, abi: readonly any[]): string | undefined {
+  // Check details field for custom error names (e.g., from Hardhat test nodes)
+  const anyErr = err as any;
+  const details = anyErr?.details ?? anyErr?.cause?.details;
+
+  if (typeof details === 'string') {
+    // Match pattern: "reverted with custom error 'ErrorName()'"
+    const customErrorMatch = details.match(/reverted with custom error '(\w+)\(\)'/);
+    if (customErrorMatch) {
+      const errorName = customErrorMatch[1];
+      // Check if this error exists in our ABI
+      const errorExists = abi.some((item) => item.type === 'error' && item.name === errorName);
+      if (errorExists) {
+        return errorName;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function extractReturnData(err: unknown): `0x${string}` | undefined {
+  // viem BaseError has `details`, but fall back to any message-like string we can find
+  const anyErr = err as any;
+  const s = anyErr?.details ?? anyErr?.cause?.details ?? anyErr?.shortMessage ?? anyErr?.message ?? String(err);
+
+  return s.match(/return data:\s*(0x[a-fA-F0-9]+)/)?.[1] as `0x${string}` | undefined;
+}
+
+const checkPermitValidityAbi = [
+  {
+    type: 'function',
+    name: 'checkPermitValidity',
+    inputs: [
+      {
+        name: 'permission',
+        type: 'tuple',
+        internalType: 'struct Permission',
+        components: [
+          {
+            name: 'issuer',
+            type: 'address',
+            internalType: 'address',
+          },
+          {
+            name: 'expiration',
+            type: 'uint64',
+            internalType: 'uint64',
+          },
+          {
+            name: 'recipient',
+            type: 'address',
+            internalType: 'address',
+          },
+          {
+            name: 'validatorId',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+          {
+            name: 'validatorContract',
+            type: 'address',
+            internalType: 'address',
+          },
+          {
+            name: 'sealingKey',
+            type: 'bytes32',
+            internalType: 'bytes32',
+          },
+          {
+            name: 'issuerSignature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+          {
+            name: 'recipientSignature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+        ],
+      },
+    ],
+    outputs: [
+      {
+        name: '',
+        type: 'bool',
+        internalType: 'bool',
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_Disabled',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_Expired',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_IssuerSignature',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_RecipientSignature',
+    inputs: [],
+  },
+] as const;