otto-intel-mcp 0.1.2 → 0.1.4

package/dist/vendor/lp-v3/lp-v3-atomic-settlement.js

@@ -0,0 +1,162 @@
+import { decodeEventLog, decodeFunctionData, parseAbi } from 'viem';
+import { z } from 'zod';
+import { canonicalJson, deepFreeze, lpAddress, lpHash, lpUint, LP_V3_BASE as B } from './lp-v3-contract.js';
+import { LP_V3_COLLECT_GUARD_ABI, lpV3AtomicChainEvidenceSchema } from './lp-v3-atomic-contract.js';
+import { requireLpV3AtomicSettlementContext } from './lp-v3-atomic-plan.js';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const NPM_EVENTS = parseAbi([
+    'event Approval(address indexed owner,address indexed approved,uint256 indexed tokenId)',
+    'event Transfer(address indexed from,address indexed to,uint256 indexed tokenId)',
+    'event IncreaseLiquidity(uint256 indexed tokenId,uint128 liquidity,uint256 amount0,uint256 amount1)',
+    'event Collect(uint256 indexed tokenId,address recipient,uint256 amount0,uint256 amount1)',
+]);
+const TOKEN_ABI = parseAbi([
+    'function approve(address spender,uint256 amount) returns (bool)',
+    'event Approval(address indexed owner,address indexed spender,uint256 value)',
+    'event Transfer(address indexed from,address indexed to,uint256 value)',
+]);
+const logSchema = z.object({ address: lpAddress, topics: z.array(z.string().regex(/^0x[0-9a-f]{64}$/)).min(1).max(4), data: z.string().regex(/^0x(?:[0-9a-f]{2})*$/), logIndex: z.number().int().nonnegative() }).strict();
+const receiptSchema = z.object({
+    chainId: z.literal(8453), transactionHash: lpHash, blockHash: lpHash, blockNumber: lpUint(),
+    blockTimestamp: z.number().int().positive().safe(), transactionIndex: z.number().int().nonnegative(),
+    canonical: z.literal(true), status: z.literal('success'), from: lpAddress, to: lpAddress,
+    input: z.string().regex(/^0x[0-9a-f]+$/), value: z.literal('0'), logs: z.array(logSchema),
+}).strict();
+export const lpV3AtomicSettlementEvidenceSchema = z.object({
+    schemaVersion: z.literal(2), planCommitment: lpHash,
+    receipts: z.array(receiptSchema).min(2).max(5), post: lpV3AtomicChainEvidenceSchema,
+}).strict();
+const decodeNpm = (l) => decodeEventLog({ abi: NPM_EVENTS, topics: l.topics, data: l.data, strict: true });
+const decodeToken = (l) => decodeEventLog({ abi: TOKEN_ABI, topics: l.topics, data: l.data, strict: true });
+const raw = (pair) => [pair[0].toString(), pair[1].toString()];
+/** The protected host supplies independently collected, journal-bound transactions
+ * and canonical logs/post-state. No client assertion is a receipt or finality proof.
+ */
+export function verifyLpV3AtomicSettlement(context, input, policy, options = {}) {
+    requireLpV3AtomicSettlementContext(context, policy);
+    const evidence = lpV3AtomicSettlementEvidenceSchema.parse(input), { plan, evidence: before } = context;
+    const intent = plan.intent, post = evidence.post, now = (options.now ?? (() => Math.floor(Date.now() / 1000)))();
+    if (!Number.isSafeInteger(now) || now <= 0)
+        throw new Error('LP_ATOMIC_INVALID_CLOCK');
+    if (evidence.planCommitment !== plan.planCommitment || evidence.receipts.length !== plan.calls.length)
+        throw new Error('LP_ATOMIC_INCOMPLETE_OPERATION');
+    // Historical reconciliation may read a finalized historical post-block today.
+    // Its canonical observation must still be fresh, and the context cannot sign.
+    if (post.observedAt > now || now - post.observedAt > 30 || post.blockTimestamp > post.observedAt || (context.purpose === 'execute' && now - post.blockTimestamp > 60))
+        throw new Error('LP_ATOMIC_STALE_SETTLEMENT');
+    const p = post.position;
+    if (post.account !== intent.account || post.pool !== intent.pool || post.factoryPool !== intent.pool || post.fee !== intent.fee || post.allowances.some(v => v !== '0') || p.tokenId !== intent.tokenId || p.owner !== intent.account || p.token0 !== intent.token0 || p.token1 !== intent.token1 || p.fee !== intent.fee || p.tickLower !== intent.tickLower || p.tickUpper !== intent.tickUpper || p.approved !== ZERO)
+        throw new Error('LP_ATOMIC_POST_IDENTITY_OR_APPROVAL_MISMATCH');
+    if (intent.action === 'increase') {
+        if (post.guard !== null)
+            throw new Error('LP_ATOMIC_UNEXPECTED_GUARD');
+    }
+    else {
+        const a = before.guard, b = post.guard, deployment = plan.guardDeployment;
+        if (!a || !b || !deployment || b.address !== deployment.address || b.runtimeCodeHash !== deployment.runtimeCodeHash || b.configurationHash !== deployment.configurationHash || canonicalJson(b.tokenBalances) !== canonicalJson(a.tokenBalances))
+            throw new Error('LP_ATOMIC_GUARD_POST_STATE_MISMATCH');
+    }
+    const hashes = new Set();
+    let previous;
+    for (const [index, r] of evidence.receipts.entries()) {
+        const call = plan.calls[index];
+        if (r.from !== call.from || r.to !== call.to || r.input !== call.data || r.value !== call.value || hashes.has(r.transactionHash))
+            throw new Error('LP_ATOMIC_RECEIPT_CALL_MISMATCH');
+        hashes.add(r.transactionHash);
+        if (r.blockTimestamp < context.verifiedAt || r.blockTimestamp > post.blockTimestamp || BigInt(r.blockNumber) < BigInt(before.blockNumber) || BigInt(r.blockNumber) > BigInt(post.blockNumber))
+            throw new Error('LP_ATOMIC_RECEIPT_BLOCK_MISMATCH');
+        if ((r.blockNumber === before.blockNumber && r.blockHash !== before.blockHash) || (r.blockNumber === post.blockNumber && r.blockHash !== post.blockHash))
+            throw new Error('LP_ATOMIC_RECEIPT_BLOCK_MISMATCH');
+        if (previous && (BigInt(r.blockNumber) < BigInt(previous.blockNumber) || (r.blockNumber === previous.blockNumber && (r.blockHash !== previous.blockHash || r.transactionIndex <= previous.transactionIndex))))
+            throw new Error('LP_ATOMIC_RECEIPT_ORDER_MISMATCH');
+        previous = r;
+        if (call.step !== 'erc20-cleanup' && r.blockTimestamp > intent.deadline)
+            throw new Error('LP_ATOMIC_LATE_OPERATION');
+        if (r.logs.some((l, i) => i > 0 && l.logIndex <= r.logs[i - 1].logIndex))
+            throw new Error('LP_ATOMIC_LOG_ORDER_MISMATCH');
+        if (call.step !== 'mutation') {
+            const npm = r.logs.filter(l => l.address === B.manager).map(decodeNpm);
+            const tokens = r.logs.filter(l => l.address === B.token0 || l.address === B.token1).map(l => ({ log: l, event: decodeToken(l) }));
+            if (tokens.some(t => t.event.eventName === 'Transfer') || r.logs.some(l => l.address === plan.guardDeployment?.address))
+                throw new Error('LP_ATOMIC_UNEXPECTED_APPROVAL_TRANSFER');
+            if (call.step === 'nft-approve') {
+                if (npm.length !== 1 || npm[0].eventName !== 'Approval' || npm[0].args.owner.toLowerCase() !== intent.account || npm[0].args.approved.toLowerCase() !== plan.guardDeployment.address || npm[0].args.tokenId.toString() !== intent.tokenId || tokens.length !== 0)
+                    throw new Error('LP_ATOMIC_NFT_APPROVAL_RECEIPT_MISMATCH');
+            }
+            else {
+                const decoded = decodeFunctionData({ abi: TOKEN_ABI, data: call.data });
+                if (npm.length || tokens.length !== 1 || tokens[0].log.address !== call.to || tokens[0].event.eventName !== 'Approval' || tokens[0].event.args.owner.toLowerCase() !== intent.account || tokens[0].event.args.spender.toLowerCase() !== B.manager || tokens[0].event.args.value !== decoded.args[1])
+                    throw new Error('LP_ATOMIC_ERC20_APPROVAL_RECEIPT_MISMATCH');
+            }
+        }
+    }
+    const receipt = evidence.receipts[plan.calls.findIndex(c => c.step === 'mutation')];
+    const npmLogs = receipt.logs.filter(l => l.address === B.manager), npm = npmLogs.map(decodeNpm);
+    const names = npm.map(e => e.eventName);
+    const expected = intent.action === 'increase' ? ['Approval', 'Transfer', 'IncreaseLiquidity', 'Approval', 'Transfer'] : ['Collect', 'Approval', 'Transfer'];
+    if (canonicalJson(names) !== canonicalJson(expected))
+        throw new Error('LP_ATOMIC_NFT_GUARD_EVENT_SEQUENCE_MISMATCH');
+    for (const e of npm) {
+        if (e.args.tokenId.toString() !== intent.tokenId)
+            throw new Error('LP_ATOMIC_EVENT_NFT_MISMATCH');
+        if (e.eventName === 'Approval' && (e.args.owner.toLowerCase() !== intent.account || e.args.approved !== ZERO))
+            throw new Error('LP_ATOMIC_NFT_CLEANUP_UNPROVEN');
+        if (e.eventName === 'Transfer' && (e.args.from.toLowerCase() !== intent.account || e.args.to.toLowerCase() !== intent.account))
+            throw new Error('LP_ATOMIC_OWNER_GUARD_UNPROVEN');
+    }
+    const spent = [0n, 0n], received = [0n, 0n];
+    for (const l of receipt.logs) {
+        const i = l.address === B.token0 ? 0 : l.address === B.token1 ? 1 : null;
+        if (i === null)
+            continue;
+        const e = decodeToken(l);
+        if (e.eventName !== 'Transfer')
+            throw new Error('LP_ATOMIC_UNEXPECTED_TOKEN_APPROVAL');
+        const from = e.args.from.toLowerCase(), to = e.args.to.toLowerCase();
+        if (from === intent.account) {
+            if (to !== intent.pool)
+                throw new Error('LP_ATOMIC_UNEXPECTED_TOKEN_DESTINATION');
+            spent[i] += e.args.value;
+        }
+        if (to === intent.account) {
+            if (from !== intent.pool)
+                throw new Error('LP_ATOMIC_UNEXPECTED_TOKEN_SOURCE');
+            received[i] += e.args.value;
+        }
+    }
+    let liquidityDelta = 0n;
+    if (intent.action === 'increase') {
+        const e = npm[2];
+        if (e.eventName !== 'IncreaseLiquidity' || e.args.liquidity <= 0n)
+            throw new Error('LP_ATOMIC_LIQUIDITY_INCREASE_UNPROVEN');
+        liquidityDelta = e.args.liquidity;
+        const amounts = [e.args.amount0, e.args.amount1];
+        for (const i of [0, 1])
+            if (amounts[i] !== spent[i] || received[i] !== 0n || spent[i] < BigInt(intent.amountMin[i]) || spent[i] > BigInt(intent.amountDesired[i]) || BigInt(p.tokensOwed[i]) < BigInt(before.position.tokensOwed[i]))
+                throw new Error('LP_ATOMIC_DEPOSIT_RECONCILIATION_FAILED');
+    }
+    else {
+        const e = npm[0];
+        const guards = receipt.logs.filter(l => l.address === plan.guardDeployment.address);
+        if (e.eventName !== 'Collect' || e.args.recipient.toLowerCase() !== intent.account || guards.length !== 1 || guards[0].logIndex <= npmLogs.at(-1).logIndex)
+            throw new Error('LP_ATOMIC_COLLECTION_EVENT_MISMATCH');
+        const g = decodeEventLog({ abi: LP_V3_COLLECT_GUARD_ABI, topics: guards[0].topics, data: guards[0].data, strict: true });
+        if (g.args.owner.toLowerCase() !== intent.account || g.args.pool.toLowerCase() !== intent.pool || g.args.tokenId.toString() !== intent.tokenId)
+            throw new Error('LP_ATOMIC_COLLECTION_BINDING_MISMATCH');
+        const actual = [g.args.amount0, g.args.amount1], owedCollection = [e.args.amount0, e.args.amount1];
+        for (const i of [0, 1]) {
+            if (spent[i] !== 0n || received[i] !== actual[i] || actual[i] < BigInt(intent.amountMin[i]) || actual[i] > BigInt(intent.amountMax[i]) || owedCollection[i] < actual[i] || owedCollection[i] > BigInt(intent.amountMax[i]))
+                throw new Error('LP_ATOMIC_COLLECTION_RECONCILIATION_FAILED');
+            const priorOwed = BigInt(before.position.tokensOwed[i]), remaining = priorOwed - owedCollection[i];
+            if (before.position.liquidity === '0' ? remaining < 0n || BigInt(p.tokensOwed[i]) !== remaining : BigInt(p.tokensOwed[i]) < (remaining > 0n ? remaining : 0n))
+                throw new Error('LP_ATOMIC_OWED_BALANCE_MISMATCH');
+        }
+    }
+    if (BigInt(p.liquidity) !== BigInt(before.position.liquidity) + liquidityDelta)
+        throw new Error('LP_ATOMIC_POST_LIQUIDITY_MISMATCH');
+    for (const i of [0, 1])
+        if (BigInt(post.balances[i]) !== BigInt(before.balances[i]) - spent[i] + received[i])
+            throw new Error('LP_ATOMIC_POST_BALANCE_MISMATCH');
+    return deepFreeze({ status: 'SETTLED', action: intent.action, planCommitment: plan.planCommitment, tokenId: intent.tokenId, depositedRaw: raw(spent), collectedRaw: raw(received), liquidityDelta: liquidityDelta.toString(), erc20AllowancesCleared: true, nftTokenApprovalCleared: true, profitClassification: 'UNKNOWN', distributableProfitRaw: null });
+}
+//# sourceMappingURL=lp-v3-atomic-settlement.js.map