@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/dist/adapters/mech/contracts.js

@@ -1,26 +1,185 @@
 import { encodeFunctionData, decodeEventLog, } from 'viem';
-import { MECH_MARKETPLACE_ABI, MECH_ABI, JINN_ROUTER_ABI, JINN_ROUTER_CLAIM_DELIVERY_V1_ABI, JINN_ROUTER_CLAIM_DELIVERY_V2_ABI, NATIVE_PAYMENT_TYPE, } from './types.js';
-import { CLAIM_REGISTRY_ABI } from '../claim-registry/abi.js';
+import { MECH_MARKETPLACE_ABI, MECH_ABI, JINN_ROUTER_ABI, JINN_ROUTER_CLAIM_DELIVERY_V1_ABI, JINN_ROUTER_CLAIM_DELIVERY_V2_ABI, } from './types.js';
+import { STAKING_ABI, STOLAS_DISTRIBUTOR_ABI } from '../../earning/contracts.js';
+import { isUnauthorizedAccountError } from '../../errors/unauthorized-account.js';
 import { executeSafeTransaction } from './safe.js';
-import { isRecoverableTransactionError, waitForTransactionReceiptWithRetry, backoffDelay, } from '../../tx-retry.js';
-export async function submitRestorationJob(publicClient, walletClient, safeAddress, routerAddress, mechAddress, requestDataHex, priceWei, responseTimeout) {
+import { formatKnownRevert } from './safe-revert.js';
+import { flattenErrorMessage, isRecoverableTransactionError, viemSendTransactionWithRetry, waitForTransactionReceiptWithRetry, backoffDelay, } from '../../tx-retry.js';
+const EVICTED_STAKING_STATE = 2;
+const restakeLocks = new Map();
+const TASK_COORDINATOR_ABI = [
+    {
+        name: 'getTask',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'taskId', type: 'uint256' }],
+        outputs: [
+            {
+                name: 'record',
+                type: 'tuple',
+                components: [
+                    { name: 'creator', type: 'address' },
+                    { name: 'taskCidDigest', type: 'bytes32' },
+                    { name: 'manifestDigest', type: 'bytes32' },
+                    { name: 'status', type: 'uint8' },
+                    {
+                        name: 'policy',
+                        type: 'tuple',
+                        components: [
+                            { name: 'claimWindowStart', type: 'uint64' },
+                            { name: 'claimWindowEnd', type: 'uint64' },
+                            { name: 'submissionDeadline', type: 'uint64' },
+                            { name: 'claimLeaseTtlSeconds', type: 'uint32' },
+                            { name: 'maxClaims', type: 'uint16' },
+                            { name: 'maxClaimsPerOperator', type: 'uint16' },
+                            { name: 'policyHook', type: 'address' },
+                            {
+                                name: 'evaluationPolicy',
+                                type: 'tuple',
+                                components: [
+                                    { name: 'requiredVerdicts', type: 'uint16' },
+                                    { name: 'passThreshold', type: 'uint16' },
+                                    { name: 'evaluationDeadline', type: 'uint64' },
+                                    { name: 'maxVerdictsPerEvaluator', type: 'uint16' },
+                                    { name: 'disallowSolverSelfEvaluation', type: 'bool' },
+                                ],
+                            },
+                        ],
+                    },
+                    { name: 'claimCount', type: 'uint32' },
+                    { name: 'submittedCount', type: 'uint32' },
+                    { name: 'finalizedAttemptCount', type: 'uint32' },
+                    { name: 'taskCreationCredited', type: 'bool' },
+                ],
+            },
+        ],
+    },
+];
+async function withRestakeLock(key, fn) {
+    const pending = restakeLocks.get(key) ?? Promise.resolve();
+    let releaseLock;
+    const newLock = new Promise(resolve => { releaseLock = resolve; });
+    restakeLocks.set(key, newLock);
+    await pending;
+    try {
+        await fn();
+    }
+    finally {
+        releaseLock();
+        if (restakeLocks.get(key) === newLock) {
+            restakeLocks.delete(key);
+        }
+    }
+}
+async function readStakingState(publicClient, recovery) {
+    return Number(await publicClient.readContract({
+        address: recovery.stakingProxyAddress,
+        abi: STAKING_ABI,
+        functionName: 'getStakingState',
+        args: [BigInt(recovery.serviceId)],
+    }));
+}
+async function restakeEvictedService(publicClient, recovery, label) {
+    const lockKey = `${recovery.stakingProxyAddress.toLowerCase()}:${recovery.serviceId}`;
+    await withRestakeLock(lockKey, async () => {
+        const latestState = await readStakingState(publicClient, recovery);
+        if (latestState !== EVICTED_STAKING_STATE) {
+            console.error(`[staking-recovery] ${label}: service ${recovery.serviceId} no longer evicted ` +
+                `(state=${latestState}); retrying original action`);
+            return;
+        }
+        const account = recovery.masterWalletClient.account;
+        if (!account) {
+            throw new Error('Eviction recovery cannot reStake: master wallet client has no account');
+        }
+        const data = encodeFunctionData({
+            abi: STOLAS_DISTRIBUTOR_ABI,
+            functionName: 'reStake',
+            args: [recovery.stakingProxyAddress, BigInt(recovery.serviceId)],
+        });
+        console.error(`[staking-recovery] ${label}: service ${recovery.serviceId} is evicted; ` +
+            `calling distributor.reStake()`);
+        let txHash;
+        try {
+            txHash = await viemSendTransactionWithRetry(recovery.masterWalletClient, publicClient, {
+                account,
+                to: recovery.distributorAddress,
+                data,
+                gas: 1500000n,
+            });
+        }
+        catch (err) {
+            const message = flattenErrorMessage(err);
+            if (isUnauthorizedAccountError(message)) {
+                throw new Error(`Service ${recovery.serviceId} is evicted, but the configured master EOA is not authorized to reStake it. ` +
+                    `Verify JINN_EARNING_DIR and JINN_PASSWORD derive the original master EOA for this service; otherwise request owner / managing-agent recovery. ` +
+                    `reStake revert: ${message}`);
+            }
+            throw err;
+        }
+        const receipt = await waitForTransactionReceiptWithRetry(publicClient, txHash, {
+            onRetry: ({ attempt, message }) => {
+                console.error(`[staking-recovery] wait reStake receipt retry ${attempt}: ${message}`);
+            },
+        });
+        if (receipt.status !== 'success') {
+            throw new Error(`reStake failed for service ${recovery.serviceId}: ${txHash}`);
+        }
+        console.error(`[staking-recovery] ${label}: reStake confirmed for service ${recovery.serviceId} ` +
+            `(tx=${txHash}); retrying original action`);
+    });
+}
+export async function withEvictionRecovery(publicClient, recovery, label, action) {
+    try {
+        return await action();
+    }
+    catch (err) {
+        if (!recovery)
+            throw err;
+        let stakingState;
+        try {
+            stakingState = await readStakingState(publicClient, recovery);
+        }
+        catch (stateErr) {
+            console.error(`[staking-recovery] ${label}: could not check staking state after failed action; ` +
+                `preserving original error. state check error: ${flattenErrorMessage(stateErr)}`);
+            throw err;
+        }
+        if (stakingState !== EVICTED_STAKING_STATE) {
+            throw err;
+        }
+        await restakeEvictedService(publicClient, recovery, label);
+        return action();
+    }
+}
+export async function submitTask(publicClient, walletClient, safeAddress, routerAddress, taskCidDigest, manifestDigest, policy, solutionMaxDeliveryRateWei, verdictMaxDeliveryRateWei, responseTimeout, evictionRecovery) {
     const calldata = encodeFunctionData({
         abi: JINN_ROUTER_ABI,
-        functionName: 'createRestorationJob',
-        args: [requestDataHex, mechAddress, priceWei, responseTimeout, NATIVE_PAYMENT_TYPE, '0x'],
+        functionName: 'createTask',
+        args: [
+            taskCidDigest,
+            manifestDigest,
+            policy,
+            solutionMaxDeliveryRateWei,
+            verdictMaxDeliveryRateWei,
+            responseTimeout,
+        ],
     });
-    const txHash = await executeSafeTransaction(publicClient, walletClient, {
+    const taskBudget = solutionMaxDeliveryRateWei * BigInt(policy.maxClaims) +
+        verdictMaxDeliveryRateWei * BigInt(policy.maxClaims) * BigInt(policy.evaluationPolicy.requiredVerdicts || 1);
+    const txHash = await withEvictionRecovery(publicClient, evictionRecovery, 'createTask', () => executeSafeTransaction(publicClient, walletClient, {
         safeAddress,
         to: routerAddress,
-        value: priceWei,
+        value: taskBudget,
         data: calldata,
-    });
+    }));
     const receipt = await waitForTransactionReceiptWithRetry(publicClient, txHash, {
         onRetry: ({ attempt, message }) => {
             console.error(`[router] wait restoration receipt retry ${attempt}: ${message}`);
         },
     });
-    const requestIds = [];
+    let taskId;
+    let blockNumber;
     for (const log of receipt.logs) {
         try {
             const decoded = decodeEventLog({
@@ -28,35 +187,39 @@ export async function submitRestorationJob(publicClient, walletClient, safeAddre
                 data: log.data,
                 topics: log.topics,
             });
-            if (decoded.eventName === 'RestorationJobCreated') {
+            if (decoded.eventName === 'TaskCreated') {
                 const args = decoded.args;
-                requestIds.push(String(args.requestId));
+                taskId = String(args.taskId);
+                blockNumber = log.blockNumber != null ? Number(log.blockNumber) : undefined;
             }
         }
         catch {
             // Not our event
         }
     }
-    return { requestIds, txHash, receiptLogCount: receipt.logs.length };
+    if (!taskId) {
+        throw new Error(`No TaskCreated event returned from router tx=${txHash}`);
+    }
+    return { taskId, txHash, receiptLogCount: receipt.logs.length, blockNumber };
 }
-export async function submitEvaluationJob(publicClient, walletClient, safeAddress, routerAddress, restorationRequestId, mechAddress, requestDataHex, priceWei, responseTimeout) {
+export async function claimTask(publicClient, walletClient, safeAddress, routerAddress, taskId, priorityMech, evictionRecovery) {
+    const taskIdBigInt = typeof taskId === 'bigint' ? taskId : BigInt(taskId);
     const calldata = encodeFunctionData({
         abi: JINN_ROUTER_ABI,
-        functionName: 'createEvaluationJob',
-        args: [restorationRequestId, requestDataHex, mechAddress, priceWei, responseTimeout, NATIVE_PAYMENT_TYPE, '0x'],
+        functionName: 'claimTask',
+        args: [taskIdBigInt, priorityMech],
     });
-    const txHash = await executeSafeTransaction(publicClient, walletClient, {
+    const txHash = await withEvictionRecovery(publicClient, evictionRecovery, 'claimTask', () => executeSafeTransaction(publicClient, walletClient, {
         safeAddress,
         to: routerAddress,
-        value: priceWei,
+        value: 0n,
         data: calldata,
-    });
+    }));
     const receipt = await waitForTransactionReceiptWithRetry(publicClient, txHash, {
         onRetry: ({ attempt, message }) => {
-            console.error(`[router] wait evaluation receipt retry ${attempt}: ${message}`);
+            console.error(`[router] wait claim task receipt retry ${attempt}: ${message}`);
         },
     });
-    const requestIds = [];
     for (const log of receipt.logs) {
         try {
             const decoded = decodeEventLog({
@@ -64,16 +227,55 @@ export async function submitEvaluationJob(publicClient, walletClient, safeAddres
                 data: log.data,
                 topics: log.topics,
             });
-            if (decoded.eventName === 'EvaluationJobCreated') {
+            if (decoded.eventName === 'TaskAttemptCreated') {
                 const args = decoded.args;
-                requestIds.push(String(args.requestId));
+                return {
+                    taskId: String(args.taskId),
+                    attemptIndex: Number(args.attemptIndex),
+                    requestId: String(args.requestId),
+                    txHash,
+                    blockNumber: log.blockNumber != null ? Number(log.blockNumber) : undefined,
+                };
             }
         }
         catch {
             // Not our event
         }
     }
-    return requestIds;
+    throw new Error(`No TaskAttemptCreated event returned from router tx=${txHash}`);
+}
+export async function canClaimTask(publicClient, safeAddress, routerAddress, taskId, priorityMech) {
+    const taskIdBigInt = typeof taskId === 'bigint' ? taskId : BigInt(taskId);
+    try {
+        await publicClient.simulateContract({
+            account: safeAddress,
+            address: routerAddress,
+            abi: JINN_ROUTER_ABI,
+            functionName: 'claimTask',
+            args: [taskIdBigInt, priorityMech],
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, reason: formatKnownRevert(err) ?? flattenErrorMessage(err) };
+    }
+}
+const DUMMY_EVALUATION_TASK_CID_DIGEST = '0x1111111111111111111111111111111111111111111111111111111111111111';
+export async function canClaimEvaluation(publicClient, safeAddress, routerAddress, taskId, attemptIndex, evaluatorMech, evaluationTaskCidDigest = DUMMY_EVALUATION_TASK_CID_DIGEST) {
+    const taskIdBigInt = typeof taskId === 'bigint' ? taskId : BigInt(taskId);
+    try {
+        await publicClient.simulateContract({
+            account: safeAddress,
+            address: routerAddress,
+            abi: JINN_ROUTER_ABI,
+            functionName: 'claimEvaluation',
+            args: [taskIdBigInt, attemptIndex, evaluatorMech, evaluationTaskCidDigest],
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, reason: formatKnownRevert(err) ?? flattenErrorMessage(err) };
+    }
 }
 const CLAIM_RETRY_ATTEMPTS = 6;
 const CLAIM_RETRY_DELAY_MS = 2000;
@@ -95,30 +297,41 @@ async function isDeliveryAlreadyClaimed(publicClient, routerAddress, requestId)
         args: [requestId],
     }));
 }
-export async function claimDelivery(publicClient, walletClient, safeAddress, routerAddress, requestId, options) {
+export async function claimDelivery(publicClient, walletClient, safeAddress, routerAddress, requestId, options, evictionRecovery) {
     if (await isDeliveryAlreadyClaimed(publicClient, routerAddress, requestId)) {
         console.error(`[router] claimDelivery: already claimed ${requestId}`);
         return '0x';
     }
-    const calldata = options.variant === 'v2'
+    if ((options.variant === 'v2' || options.variant === 'v3') && !options.evidenceHash) {
+        throw new Error(`claimDelivery(${options.variant}): evidenceHash is required — refusing to write ZERO_EVIDENCE for requestId ${requestId}`);
+    }
+    const calldata = options.variant === 'v3'
         ? encodeFunctionData({
-            abi: JINN_ROUTER_CLAIM_DELIVERY_V2_ABI,
-            functionName: 'claimDelivery',
-            args: [requestId, options.evidenceHash ?? ZERO_EVIDENCE],
+            abi: JINN_ROUTER_ABI,
+            functionName: options.kind === 'verdict' ? 'claimVerdictDelivery' : 'claimSolutionDelivery',
+            args: options.kind === 'verdict'
+                ? [requestId, options.evidenceHash, options.verdictCode ?? 1]
+                : [requestId, options.evidenceHash],
         })
-        : encodeFunctionData({
-            abi: JINN_ROUTER_CLAIM_DELIVERY_V1_ABI,
-            functionName: 'claimDelivery',
-            args: [requestId],
-        });
+        : options.variant === 'v2'
+            ? encodeFunctionData({
+                abi: JINN_ROUTER_CLAIM_DELIVERY_V2_ABI,
+                functionName: 'claimDelivery',
+                args: [requestId, options.evidenceHash],
+            })
+            : encodeFunctionData({
+                abi: JINN_ROUTER_CLAIM_DELIVERY_V1_ABI,
+                functionName: 'claimDelivery',
+                args: [requestId],
+            });
     for (let attempt = 1; attempt <= CLAIM_RETRY_ATTEMPTS; attempt++) {
         try {
-            return await executeSafeTransaction(publicClient, walletClient, {
+            return await withEvictionRecovery(publicClient, evictionRecovery, 'claimDelivery', () => executeSafeTransaction(publicClient, walletClient, {
                 safeAddress,
                 to: routerAddress,
                 value: 0n,
                 data: calldata,
-            });
+            }));
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -151,45 +364,78 @@ export async function claimDelivery(publicClient, walletClient, safeAddress, rou
     }
     throw new Error(`claimDelivery failed after ${CLAIM_RETRY_ATTEMPTS} attempts for ${requestId}`);
 }
-// ── ClaimRegistry helpers ──────────────────────────────────────────────────
-export async function claimJob(publicClient, walletClient, safeAddress, claimRegistryAddress, requestId) {
-    const data = encodeFunctionData({
-        abi: CLAIM_REGISTRY_ABI,
-        functionName: 'claimJob',
-        args: [requestId],
+export async function claimEvaluation(publicClient, walletClient, safeAddress, routerAddress, taskId, attemptIndex, evaluatorMech, evaluationTaskCidDigest, evictionRecovery) {
+    const taskIdBigInt = typeof taskId === 'bigint' ? taskId : BigInt(taskId);
+    const calldata = encodeFunctionData({
+        abi: JINN_ROUTER_ABI,
+        functionName: 'claimEvaluation',
+        args: [taskIdBigInt, attemptIndex, evaluatorMech, evaluationTaskCidDigest],
     });
-    try {
-        const txHash = await executeSafeTransaction(publicClient, walletClient, { safeAddress, to: claimRegistryAddress, value: 0n, data });
-        await waitForTransactionReceiptWithRetry(publicClient, txHash, {
-            onRetry: ({ attempt, message }) => {
-                console.error(`[claim-registry] wait receipt retry ${attempt}: ${message}`);
-            },
-        });
-        return txHash;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (message.includes('JobAlreadyClaimed')) {
-            return ''; // Already claimed by someone else
-        }
-        if (message.includes('IneligibleToClaim')) {
-            return ''; // Not eligible
+    const txHash = await withEvictionRecovery(publicClient, evictionRecovery, 'claimEvaluation', () => executeSafeTransaction(publicClient, walletClient, {
+        safeAddress,
+        to: routerAddress,
+        value: 0n,
+        data: calldata,
+    }));
+    const receipt = await waitForTransactionReceiptWithRetry(publicClient, txHash, {
+        onRetry: ({ attempt, message }) => {
+            console.error(`[router] wait claim evaluation receipt retry ${attempt}: ${message}`);
+        },
+    });
+    for (const log of receipt.logs) {
+        try {
+            const decoded = decodeEventLog({
+                abi: JINN_ROUTER_ABI,
+                data: log.data,
+                topics: log.topics,
+            });
+            if (decoded.eventName === 'EvaluationAttemptCreated') {
+                const args = decoded.args;
+                return {
+                    taskId: String(args.taskId),
+                    attemptIndex: Number(args.attemptIndex),
+                    verdictIndex: Number(args.verdictIndex),
+                    requestId: String(args.requestId),
+                    txHash,
+                    blockNumber: log.blockNumber != null ? Number(log.blockNumber) : undefined,
+                };
+            }
         }
-        if (message.includes('GS013') || message.includes('execution reverted')) {
-            // Safe execution failed (inner call reverted) — treat as claim failure
-            return '';
+        catch {
+            // Not our event
         }
-        throw err;
     }
+    throw new Error(`No EvaluationAttemptCreated event returned from router tx=${txHash}`);
+}
+export async function getTaskCidDigest(publicClient, routerAddress, taskId) {
+    const coordinatorAddress = await publicClient.readContract({
+        address: routerAddress,
+        abi: JINN_ROUTER_ABI,
+        functionName: 'taskCoordinator',
+    });
+    const taskIdBigInt = typeof taskId === 'bigint' ? taskId : BigInt(taskId);
+    const task = await publicClient.readContract({
+        address: coordinatorAddress,
+        abi: TASK_COORDINATOR_ABI,
+        functionName: 'getTask',
+        args: [taskIdBigInt],
+    });
+    if (Array.isArray(task)) {
+        return task[1];
+    }
+    return task.taskCidDigest;
 }
-export async function getJobClaim(publicClient, claimRegistryAddress, requestId) {
-    const result = await publicClient.readContract({
-        address: claimRegistryAddress,
-        abi: CLAIM_REGISTRY_ABI,
-        functionName: 'getJobClaim',
+export async function getMarketplaceRequestDeliveryMech(publicClient, marketplaceAddress, requestId) {
+    const info = await publicClient.readContract({
+        address: marketplaceAddress,
+        abi: MECH_MARKETPLACE_ABI,
+        functionName: 'mapRequestIdInfos',
         args: [requestId],
     });
-    return { claimer: result[0], expiresAt: result[1] };
+    if (Array.isArray(info)) {
+        return info[1];
+    }
+    return info.deliveryMech;
 }
 export async function getMechDeliveryRate(publicClient, mechAddress) {
     return publicClient.readContract({
@@ -220,7 +466,7 @@ export async function pollDeliverEvents(publicClient, mechAddress, fromBlock, to
         toBlock,
     });
 }
-export async function scanRestorationJobs(publicClient, routerAddress, creator, fromBlock, toBlock) {
+export async function scanTasks(publicClient, routerAddress, creator, fromBlock, toBlock) {
     const results = [];
     const chunkSize = 9999n;
     for (let start = fromBlock; start <= toBlock; start += chunkSize + 1n) {
@@ -237,10 +483,16 @@ export async function scanRestorationJobs(publicClient, routerAddress, creator,
                     data: log.data,
                     topics: log.topics,
                 });
-                if (decoded.eventName === 'RestorationJobCreated') {
+                if (decoded.eventName === 'TaskCreated') {
                     const args = decoded.args;
                     if (args.creator.toLowerCase() === creator.toLowerCase()) {
-                        results.push({ requestId: String(args.requestId), creator: String(args.creator) });
+                        results.push({
+                            taskId: String(args.taskId),
+                            taskCidDigest: String(args.taskCidDigest),
+                            creator: String(args.creator),
+                            transactionHash: log.transactionHash ?? undefined,
+                            blockNumber: log.blockNumber != null ? Number(log.blockNumber) : undefined,
+                        });
                     }
                 }
             }
@@ -249,35 +501,55 @@ export async function scanRestorationJobs(publicClient, routerAddress, creator,
     }
     return results;
 }
-export async function scanEvaluationJobs(publicClient, routerAddress, creator, fromBlock, toBlock) {
+export function decodeTaskCreatedLogs(logs) {
     const results = [];
-    const chunkSize = 9999n;
-    for (let start = fromBlock; start <= toBlock; start += chunkSize + 1n) {
-        const end = start + chunkSize > toBlock ? toBlock : start + chunkSize;
-        const logs = await publicClient.getLogs({
-            address: routerAddress,
-            fromBlock: start,
-            toBlock: end,
-        });
-        for (const log of logs) {
-            try {
-                const decoded = decodeEventLog({
-                    abi: JINN_ROUTER_ABI,
-                    data: log.data,
-                    topics: log.topics,
+    for (const log of logs) {
+        try {
+            const decoded = decodeEventLog({
+                abi: JINN_ROUTER_ABI,
+                data: log.data,
+                topics: log.topics,
+            });
+            if (decoded.eventName === 'TaskCreated') {
+                const args = decoded.args;
+                results.push({
+                    taskId: String(args.taskId),
+                    taskCidDigest: String(args.taskCidDigest),
+                    creator: String(args.creator),
+                    transactionHash: log.transactionHash ?? undefined,
+                    blockNumber: log.blockNumber != null ? Number(log.blockNumber) : undefined,
                 });
-                if (decoded.eventName === 'EvaluationJobCreated') {
-                    const args = decoded.args;
-                    if (args.creator.toLowerCase() === creator.toLowerCase()) {
-                        results.push({
-                            requestId: String(args.requestId),
-                            restorationRequestId: String(args.restorationRequestId),
-                            creator: String(args.creator),
-                        });
-                    }
-                }
             }
-            catch { }
+        }
+        catch {
+            // Not a TaskCreated event — skip
+        }
+    }
+    return results;
+}
+export function decodeSolutionDeliveryClaimedLogs(logs) {
+    const results = [];
+    for (const log of logs) {
+        try {
+            const decoded = decodeEventLog({
+                abi: JINN_ROUTER_ABI,
+                data: log.data,
+                topics: log.topics,
+            });
+            if (decoded.eventName === 'SolutionDeliveryClaimed') {
+                const args = decoded.args;
+                results.push({
+                    taskId: String(args.taskId),
+                    attemptIndex: Number(args.attemptIndex),
+                    requestId: String(args.requestId),
+                    operator: String(args.operator),
+                    transactionHash: log.transactionHash ?? undefined,
+                    blockNumber: log.blockNumber != null ? Number(log.blockNumber) : undefined,
+                });
+            }
+        }
+        catch {
+            // Not a SolutionDeliveryClaimed event — skip
         }
     }
     return results;
@@ -397,19 +669,19 @@ const ALREADY_DELIVERED_PATTERNS = [
     'JobAlreadyDelivered',
     'RequestAlreadyDelivered',
 ];
-export async function callDeliverToMarketplace(publicClient, walletClient, safeAddress, mechContractAddress, requestIds, datas) {
+export async function callDeliverToMarketplace(publicClient, walletClient, safeAddress, mechContractAddress, requestIds, datas, evictionRecovery) {
     const calldata = encodeFunctionData({
         abi: MECH_ABI,
         functionName: 'deliverToMarketplace',
         args: [requestIds, datas],
     });
     try {
-        return await executeSafeTransaction(publicClient, walletClient, {
+        return await withEvictionRecovery(publicClient, evictionRecovery, 'deliverToMarketplace', () => executeSafeTransaction(publicClient, walletClient, {
             safeAddress,
             to: mechContractAddress,
             value: 0n,
             data: calldata,
-        });
+        }));
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);