@ethlimo/ens-hooks-release-testing 0.1.11

package/src/dataurl/index.ts

@@ -0,0 +1,164 @@
+import { Contract, Provider, AbiCoder } from "ethers";
+import { 
+    DecodedEIP8121Hook, 
+    extractFunctionName,
+    parseParameterTypes,
+    parseFunctionCallValues,
+    isEIP8121Hook,
+    decodeHook
+} from "./encoding.js";
+import { TrustedTargets, verifyTrustedTarget } from "./trust.js";
+
+export type ProviderMap = Map<number, Provider>;
+
+export interface HookExecutionResult {
+    _tag: "HookExecutionResult";
+    data: string;
+}
+
+export interface HookExecutionError {
+    _tag: "HookExecutionError";
+    error: true;
+    message: string;
+    cause?: unknown;
+}
+
+export type ExecutionResult = HookExecutionResult | HookExecutionError;
+
+export interface HookValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+
+/**
+ * Validates an EIP-8121 hook.
+ * Checks: 0-2 fixed-size primitive parameters, (bytes) return type.
+ */
+export function validateHook(hook: DecodedEIP8121Hook): HookValidationResult {
+    try {
+        // Validate function signature and parameters
+        const params = parseParameterTypes(hook.functionSignature);
+        
+        // Validate parameter count (0-2 allowed)
+        if (params.length > 2) {
+            return {
+                isValid: false,
+                error: `Too many parameters: expected 0-2, got ${params.length}`
+            };
+        }
+        
+        // Validate return type
+        if (hook.returnType !== '(bytes)') {
+            return {
+                isValid: false,
+                error: `Invalid return type: expected (bytes), got ${hook.returnType}`
+            };
+        }
+        
+        return { isValid: true };
+    } catch (error) {
+        return {
+            isValid: false,
+            error: `Validation failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+
+/**
+ * Decodes result from hook execution.
+ * Note: ethers already ABI-decodes the return value, so we just validate and return.
+ */
+export function decodeResult(resultBytes: string, returnType: string): string {
+    if (returnType !== '(bytes)') {
+        throw new Error(`Invalid return type: expected (bytes), got ${returnType}`);
+    }
+    
+    // ethers already decoded the bytes return value
+    return resultBytes;
+}
+
+export interface ExecuteHookOptions {
+    providerMap: ProviderMap;
+    trustedTargets?: TrustedTargets;
+    throwOnUntrusted?: boolean;
+}
+
+export async function executeHook(
+    hook: DecodedEIP8121Hook,
+    options: ExecuteHookOptions
+): Promise<ExecutionResult> {
+    try {
+        const validation = validateHook(hook);
+        if (!validation.isValid) {
+            return {
+                _tag: "HookExecutionError",
+                error: true,
+                message: `Hook validation failed: ${validation.error}`
+            };
+        }
+        
+        if (options.trustedTargets) {
+            const isTrusted = verifyTrustedTarget(hook.target, options.trustedTargets);
+            if (!isTrusted) {
+                const errorMsg = `Untrusted target: ${hook.target.address} on chain ${hook.target.chainId}`;
+                if (options.throwOnUntrusted) {
+                    throw new Error(errorMsg);
+                }
+                return {
+                    _tag: "HookExecutionError",
+                    error: true,
+                    message: errorMsg
+                };
+            }
+        }
+        
+        const provider = options.providerMap.get(hook.target.chainId);
+        if (!provider) {
+            return {
+                _tag: "HookExecutionError",
+                error: true,
+                message: `No provider available for chain ID ${hook.target.chainId}`
+            };
+        }
+        
+        // Parse parameter values from functionCall (with generic error messages for security)
+        const paramValues = parseFunctionCallValues(hook.functionCall, hook.functionSignature, false);
+        
+        const functionName = extractFunctionName(hook.functionSignature);
+        
+        const abi = [`function ${hook.functionSignature} view returns (bytes)`];
+        
+        const contract = new Contract(
+            hook.target.address,
+            abi,
+            provider
+        );
+        
+        const resultBytes = await contract[functionName](...paramValues);
+        const result = decodeResult(resultBytes, hook.returnType);
+        
+        return {
+            _tag: "HookExecutionResult",
+            data: result
+        };
+    } catch (error) {
+        return {
+            _tag: "HookExecutionError",
+            error: true,
+            message: `Hook execution failed: ${error instanceof Error ? error.message : String(error)}`,
+            cause: error
+        };
+    }
+}
+
+export async function detectAndDecodeHook(data: string): Promise<DecodedEIP8121Hook | null> {
+    if (!isEIP8121Hook(data)) {
+        return null;
+    }
+    
+    const { tryDecodeEIP8121HookFromContenthash } = await import("./encoding.js");
+    const stripped = tryDecodeEIP8121HookFromContenthash(data);
+    const hookData = stripped ?? data;
+    
+    return await decodeHook(hookData);
+}

package/src/dataurl/trust.ts

@@ -0,0 +1,39 @@
+import { EIP8121Target } from "./encoding.js";
+
+export interface TrustedTarget {
+    chainId: number;
+    address: string;
+    description?: string;
+}
+
+export type TrustedTargets = 
+    | TrustedTarget[] 
+    | Set<string> 
+    | ((target: EIP8121Target) => boolean);
+
+export function verifyTrustedTarget(
+    target: EIP8121Target,
+    trustedTargets: TrustedTargets
+): boolean {
+    if (typeof trustedTargets === 'function') {
+        return trustedTargets(target);
+    }
+    
+    if (trustedTargets instanceof Set) {
+        const key = createTargetKey(target.chainId, target.address);
+        return trustedTargets.has(key);
+    }
+    
+    return trustedTargets.some(trusted => 
+        trusted.chainId === target.chainId && 
+        trusted.address.toLowerCase() === target.address.toLowerCase()
+    );
+}
+
+export function createTargetKey(chainId: number, address: string): string {
+    return `${chainId}:${address.toLowerCase()}`;
+}
+
+export function createTrustedTargets(targets: TrustedTarget[]): Set<string> {
+    return new Set(targets.map(t => createTargetKey(t.chainId, t.address)));
+}

package/src/index.ts

@@ -0,0 +1,49 @@
+export { 
+    executeHook,
+    validateHook,
+    decodeResult,
+    detectAndDecodeHook,
+    type ProviderMap,
+    type HookExecutionResult,
+    type HookExecutionError,
+    type ExecutionResult,
+    type HookValidationResult,
+    type ExecuteHookOptions,
+} from "./dataurl/index.js";
+
+export {
+    encodeHook,
+    decodeHook,
+    computeSelector,
+    extractFunctionName,
+    parseParameterTypes,
+    parseFunctionCallValues,
+    encodeERC7930Target,
+    decodeERC7930Target,
+    isEIP8121Hook,
+    isAllowedParameterType,
+    validateFunctionCallMatchesSignature,
+    MAX_STRING_LENGTH,
+    type DecodedEIP8121Hook,
+    type EIP8121Target,
+    type HookParameter
+} from "./dataurl/encoding.js";
+
+export {
+    HOOK_SELECTOR
+} from "./dataurl/constants.js";
+
+export {
+    verifyTrustedTarget,
+    createTrustedTargets,
+    createTargetKey,
+    type TrustedTarget,
+    type TrustedTargets
+} from "./dataurl/trust.js";
+
+export {
+    encodeDataUri,
+    tryDecodeDataUri,
+    encodeEIP8121HookForContenthash,
+    tryDecodeEIP8121HookFromContenthash
+} from "./dataurl/encoding.js";