@reptilianhq/uniswap-sdk 0.2.2

package/examples/read-only-consumer.mjs

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict';
+import {
+  readV4Pool,
+  readV4TickWindow,
+} from '@reptilianhq/uniswap-sdk/v4';
+import { isUniswapSdkError } from '@reptilianhq/uniswap-sdk/errors';
+
+const address = number => `0x${number.toString(16).padStart(40, '0')}`;
+const deployment = {
+  chainId: 4663,
+  poolManager: address(1),
+  stateView: address(2),
+  quoter: address(3),
+};
+const poolKey = {
+  currency0: address(0),
+  currency1: address(4),
+  fee: 3_000,
+  tickSpacing: 32_767,
+  hooks: address(0),
+};
+
+// Replace this deterministic client with a configured viem PublicClient.
+const publicClient = {
+  async getChainId() { return deployment.chainId; },
+  async getBlockNumber() { return 100n; },
+  async readContract({ functionName, args }) {
+    if (functionName === 'poolManager') return deployment.poolManager;
+    if (functionName === 'getSlot0') return [1n << 96n, 0, 0, 3_000];
+    if (functionName === 'getLiquidity') return 500n;
+    if (functionName === 'getTickBitmap') {
+      if (args[1] === -1) throw new Error('fixture: bitmap unavailable');
+      return 0n;
+    }
+    throw new Error(`fixture: unexpected ${functionName}`);
+  },
+};
+
+const pool = await readV4Pool(publicClient, deployment, poolKey);
+assert.equal(pool.blockNumber, 100n);
+assert.equal(pool.liquidity, 500n);
+
+const ticks = await readV4TickWindow(publicClient, deployment, poolKey, {
+  fromWord: -1,
+  toWord: 0,
+  blockNumber: pool.blockNumber,
+});
+assert.equal(ticks.partial, true);
+assert.deepEqual(ticks.failedWords, [-1]);
+
+try {
+  await readV4Pool(publicClient, { ...deployment, chainId: 1 }, poolKey);
+  assert.fail('the wrong chain must be rejected');
+} catch (error) {
+  assert.equal(isUniswapSdkError(error), true);
+  assert.equal(error.code, 'CHAIN_MISMATCH');
+}
+
+console.log('Read-only consumer example passed.');

package/fixtures/receipts/robinhood-mainnet-v3-lifecycle.json

@@ -0,0 +1,84 @@
+{
+  "schemaVersion": 1,
+  "deploymentId": "robinhood-mainnet-v3",
+  "chainId": 4663,
+  "abiRevision": "uniswap-v3-core-periphery-1.0.0",
+  "recordedHead": 60266150,
+  "minimumFinalityDepth": 5000,
+  "transactionHash": "0x011845afe62d555d6667a6f8e3b5cf4d60152bac613d04853d879f58b60e1e15",
+  "blockHash": "0x53bab62a1495b95392570d5fb20aa1c1d5fa9f868839f71ed080b82b1d68b6df",
+  "blockNumber": 60175962,
+  "status": "success",
+  "manager": "0x73991a25C818Bf1f1128dEAaB1492D45638DE0D3",
+  "recipient": "0x62c327a39c84ca646044B28Aa169cAeCDE318960",
+  "closedTokenId": "1127306",
+  "mintedTokenId": "1130874",
+  "logSelection": "position-manager lifecycle evidence",
+  "logs": [
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0x40d0efd1a53d60ecbf40971b9daf7dc90178c3aadc7aab1765632738fa8b8f01",
+        "0x000000000000000000000000000000000000000000000000000000000011338a"
+      ],
+      "data": "0x00000000000000000000000062c327a39c84ca646044b28aa169caecde31896000000000000000000000000000000000000000000000000000001b965f671e4c0000000000000000000000000000000000000000000000001cf0c05cf94e63e4"
+    },
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0x26f6a048ee9138f2c0ce266f322cb99228e8d619ae2bff30c67f8dcf9d2377b4",
+        "0x000000000000000000000000000000000000000000000000000000000011338a"
+      ],
+      "data": "0x00000000000000000000000000000000000000000000000082e986b70fbead3100000000000000000000000000000000000000000000000000007b508432fee100000000000000000000000000000000000000000000000d719e0d747b720be3"
+    },
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0x40d0efd1a53d60ecbf40971b9daf7dc90178c3aadc7aab1765632738fa8b8f01",
+        "0x000000000000000000000000000000000000000000000000000000000011338a"
+      ],
+      "data": "0x00000000000000000000000062c327a39c84ca646044b28aa169caecde31896000000000000000000000000000000000000000000000000000007b508432fee100000000000000000000000000000000000000000000000d719e0d747b720be3"
+    },
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+        "0x00000000000000000000000062c327a39c84ca646044b28aa169caecde318960",
+        "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "0x000000000000000000000000000000000000000000000000000000000011338a"
+      ],
+      "data": "0x"
+    },
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+        "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "0x00000000000000000000000062c327a39c84ca646044b28aa169caecde318960",
+        "0x000000000000000000000000000000000000000000000000000000000011417a"
+      ],
+      "data": "0x"
+    },
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0x3067048beee31b25b2f1681f88dac838c8bba36af25bfb2b7cf7473a5847e35f",
+        "0x000000000000000000000000000000000000000000000000000000000011417a"
+      ],
+      "data": "0x00000000000000000000000000000000000000000000000083813d777a4bdacb000000000000000000000000000000000000000000000000000754af9a0c47ff000000000000000000000000000000000000000000000007e76839352a9495ae"
+    }
+  ],
+  "expected": {
+    "closed": {
+      "liquidityRemoved": "9433219015305506097",
+      "amount0Collected": "165918405172525",
+      "amount1Collected": "250080047057793478599",
+      "burned": true
+    },
+    "minted": {
+      "liquidityAdded": "9475922674326428363",
+      "amount0Added": "2063438017480703",
+      "amount1Added": "145801849036816553390"
+    }
+  }
+}

package/fixtures/receipts/robinhood-mainnet-v3-mint.json

@@ -0,0 +1,42 @@
+{
+  "schemaVersion": 1,
+  "deploymentId": "robinhood-mainnet-v3",
+  "chainId": 4663,
+  "abiRevision": "uniswap-v3-core-periphery-1.0.0",
+  "recordedHead": 60266150,
+  "minimumFinalityDepth": 5000,
+  "transactionHash": "0x010857a8063c93493bfd3fb010ef8af77b0ac64a0866f86ee542396c2eefe105",
+  "blockHash": "0xa9bcdc3119d06bee5949915e974d0f33163fa30782ce0a3f6b238c683f50f239",
+  "blockNumber": 60183858,
+  "status": "success",
+  "manager": "0x73991a25C818Bf1f1128dEAaB1492D45638DE0D3",
+  "recipient": "0xB4AcBc082b5E7DEd571c98eE4257778A9d784B36",
+  "tokenId": "1131007",
+  "logSelection": "position-manager mint and liquidity evidence",
+  "logs": [
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+        "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "0x000000000000000000000000b4acbc082b5e7ded571c98ee4257778a9d784b36",
+        "0x00000000000000000000000000000000000000000000000000000000001141ff"
+      ],
+      "data": "0x"
+    },
+    {
+      "address": "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+      "topics": [
+        "0x3067048beee31b25b2f1681f88dac838c8bba36af25bfb2b7cf7473a5847e35f",
+        "0x00000000000000000000000000000000000000000000000000000000001141ff"
+      ],
+      "data": "0x0000000000000000000000000000000000000000000000007e059550b2ea9d4c00000000000000000000000000000000000000000000000552d668a9c55f844b000000000000000000000000000000000000000000000000001bc9d7505123ac"
+    }
+  ],
+  "expected": {
+    "mintedTokenId": "1131007",
+    "liquidityAdded": "9080828397494115660",
+    "amount0Added": "98202793803044062283",
+    "amount1Added": "7821750973834156"
+  }
+}

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@reptilianhq/uniswap-sdk",
+  "version": "0.2.2",
+  "description": "Deployment-explicit Uniswap observations and reviewed transaction material.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "docs",
+    "examples",
+    "fixtures",
+    "provenance",
+    "scripts/check-conformance.mjs",
+    "scripts/verify-v3-deployments.mjs",
+    "README.md",
+    "RELEASING.md",
+    "NOTICE",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./v4": {
+      "types": "./dist/v4.d.ts",
+      "import": "./dist/v4.js"
+    },
+    "./v3": {
+      "types": "./dist/v3.d.ts",
+      "import": "./dist/v3.js"
+    },
+    "./deployments": {
+      "types": "./dist/deployments.d.ts",
+      "import": "./dist/deployments.js"
+    },
+    "./compatibility": {
+      "types": "./dist/compatibility.d.ts",
+      "import": "./dist/compatibility.js"
+    },
+    "./transactions": {
+      "types": "./dist/transactions.d.ts",
+      "import": "./dist/transactions.js"
+    },
+    "./receipts": {
+      "types": "./dist/receipts.d.ts",
+      "import": "./dist/receipts.js"
+    },
+    "./batch": {
+      "types": "./dist/batch.d.ts",
+      "import": "./dist/batch.js"
+    },
+    "./abis": {
+      "types": "./dist/abis.d.ts",
+      "import": "./dist/abis.js"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js"
+    },
+    "./providers": {
+      "types": "./dist/providers.d.ts",
+      "import": "./dist/providers.js"
+    },
+    "./provenance/mainnet.json": "./provenance/mainnet.json",
+    "./provenance/testnet.json": "./provenance/testnet.json"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "npm run build && npm run typecheck && npm run lint && npm run test:run && npm run test:runtime && npm run test:consumer && npm run check:conformance && npm run check:publisher && npm run test:release && npm run check:package",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --max-warnings 0",
+    "test:run": "vitest run src",
+    "test:runtime": "node scripts/runtime-smoke.mjs",
+    "test:fork": "vitest run src/v3-mainnet.fork.test.ts",
+    "test:live-compatibility": "npm run build && node scripts/verify-v3-deployments.mjs",
+    "test:consumer": "node examples/read-only-consumer.mjs",
+    "check:conformance": "node scripts/check-conformance.mjs . && node --test scripts/check-conformance.node-test.mjs",
+    "check:publisher": "node scripts/artifacts/check.mjs",
+    "test:release": "node --test scripts/artifacts/publisher.test.mjs scripts/release.test.mjs",
+    "check:package": "publint && attw --pack . --profile esm-only",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@uniswap/sdk-core": "7.19.2",
+    "@uniswap/v4-sdk": "2.3.3"
+  },
+  "peerDependencies": {
+    "viem": ">=2.55.0 <3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@eslint/js": "10.0.1",
+    "@hegeldev/hegel": "0.4.3",
+    "@types/node": "24.13.2",
+    "eslint": "10.6.0",
+    "globals": "17.7.0",
+    "publint": "0.3.23",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.62.0",
+    "viem": "2.55.2",
+    "vitest": "4.1.9"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReptilianHQ/uniswap-sdk.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "packageManager": "npm@11.5.2",
+  "reptilianRelease": {
+    "schemaVersion": 1,
+    "group": "uniswap-sdk",
+    "sourceSha": "d02bfdd8f80b6f95c7fc573ccd4eb17e6de6a0cf"
+  }
+}

package/provenance/mainnet.json

@@ -0,0 +1,33 @@
+{
+  "schemaVersion": 1,
+  "deploymentId": "robinhood-mainnet-v3",
+  "chainId": 4663,
+  "reviewedAt": "2026-09-11",
+  "abiRevision": "uniswap-v3-core-periphery-1.0.0",
+  "provenance": "official",
+  "explorerVerification": "official",
+  "contracts": {
+    "factory": "0x1f7d7550B1b028f7571E69A784071F0205FD2EfA",
+    "nonfungiblePositionManager": "0x73991a25C818Bf1f1128dEAaB1492D45638DE0D3",
+    "quoterV2": "0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7",
+    "swapRouter02": "0xcaf681a66d020601342297493863e78c959e5cb2",
+    "wrappedNative": "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
+    "multicall3": "0xca11bde05977b3631167028862be2a173976ca11"
+  },
+  "runtimeCodeHashes": {
+    "factory": "0xec72b1abd1f2faee020cfea9c646bd8994f9fb389054f6e574f103a895091739",
+    "nonfungiblePositionManager": "0x0a493d1af3d0f25fed8efa205244ebee14114267a08647fc38c515c7cd6ead4f",
+    "quoterV2": "0x3db0868d945e9304c9bc6a8b2181948109ea617647142f3c4083e14393496a28",
+    "swapRouter02": "0x6f36c378e272c6324c48f045182bcb54bd8ad654cf9ebd42e8893d52c4cb25dc",
+    "wrappedNative": "0x5706be52f64875fee65a2cec0d80e47a23d8793cbe85d214b48445e2d05f5353",
+    "multicall3": "0xd5c15df687b16f2ff992fc8d767b4216323184a2bbc6ee2f9c398c318e770891"
+  },
+  "runtimeCodeHashPin": {
+    "blockNumber": 60266150,
+    "rpc": "https://rpc.mainnet.chain.robinhood.com"
+  },
+  "limitations": [
+    "Compatibility checks chain identity, exact runtime code hashes, and position-manager factory/WETH9 wiring.",
+    "Runtime code hashes establish deployed-code identity; they do not establish source verification or custom-hook compatibility."
+  ]
+}

package/provenance/testnet.json

@@ -0,0 +1,33 @@
+{
+  "schemaVersion": 1,
+  "deploymentId": "robinhood-testnet-v3",
+  "chainId": 46630,
+  "reviewedAt": "2026-09-11",
+  "abiRevision": "uniswap-v3-core-periphery-1.0.0",
+  "provenance": "reviewed-testnet",
+  "explorerVerification": "partial",
+  "contracts": {
+    "factory": "0xdf9e3D6ffaC4513dD7b053212bbECcbCD15ec932",
+    "nonfungiblePositionManager": "0xFFe6CFc4f759b65f9B62c9D05A9E21a78cE93e12",
+    "quoterV2": "0xDDcBe4989C8171F721c5e683C9C6339B59718213",
+    "swapRouter02": "0xb79cB26e90EBBD9bC02c75267c9a86dBa1AFedB7",
+    "wrappedNative": "0x7943e237c7F95DA44E0301572D358911207852Fa",
+    "multicall3": "0xca11bde05977b3631167028862be2a173976ca11"
+  },
+  "runtimeCodeHashes": {
+    "factory": "0x75c5bbc7989daa85188d9e4c9f989271d8bcb2abad3d47e6e47d3c0c5bff02c2",
+    "nonfungiblePositionManager": "0xe40cd590528ac8b67b428579035fe391e502c38271623777692c50834688e9d5",
+    "quoterV2": "0x724c4956e1c61fd13285a92685337df60254bc67f775e7268da2fc5cc79d5343",
+    "swapRouter02": "0xdce781dc17d5f98e3ea0b72d88639a5995ccbba6e11bc01f2057a9409dc8c724",
+    "wrappedNative": "0x5706be52f64875fee65a2cec0d80e47a23d8793cbe85d214b48445e2d05f5353",
+    "multicall3": "0xd5c15df687b16f2ff992fc8d767b4216323184a2bbc6ee2f9c398c318e770891"
+  },
+  "runtimeCodeHashPin": {
+    "blockNumber": 117449391,
+    "rpc": "https://rpc.testnet.chain.robinhood.com"
+  },
+  "limitations": [
+    "The factory and position manager were reviewed against pinned Uniswap v3 source artifacts; the remaining addresses have partial explorer verification.",
+    "Runtime code hashes establish deployed-code identity; they do not establish source verification or custom-hook compatibility."
+  ]
+}

package/scripts/check-conformance.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+// Vendored copy of ReptilianHQ/reptilian scripts/check-sdk-conformance.mjs, the shared Protocol SDK
+// Standard's conformance script (docs/SDK_STANDARDS.md there). This standalone package
+// cannot read the private source, so the source repository checks this copy against its
+// own on every change. Do not edit the body below; the adjacent self-test fails if it no
+// longer matches the recorded hash. Invoked as `node scripts/check-conformance.mjs .`.
+// Canonical body sha256: e03bec3ea1db3451f3306ca5dd48f432dd061db02a3c9dd445c1f557e6408bb4
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const requiredCapabilityExports = [
+  './deployments',
+  './compatibility',
+  './errors',
+  './transactions',
+  './receipts',
+];
+
+// Property-based invariant suites required per exported capability. See
+// docs/SDK_STANDARDS.md, "Invariant testing for capital-moving flows".
+export const requiredInvariantSuites = [
+  ['./transactions', 'transactions.hegel.test.ts'],
+  ['./receipts', 'receipts.hegel.test.ts'],
+  ['./math', 'math.hegel.test.ts'],
+  ['./economics', 'economics.hegel.test.ts'],
+  ['./swap', 'swap.hegel.test.ts'],
+  ['./fees', 'fees.hegel.test.ts'],
+];
+
+// Invariant suites a package has not adopted yet, keyed by repository-relative
+// root. Only the listed suites downgrade to warnings; any other missing suite
+// fails. Remove a suite once the package adopts it.
+export const invariantAdoptionPending = new Map([
+  // Every governed package in this repository has adopted its suites. Add a
+  // [root, Set(suites)] entry only for a new package that has not yet.
+]);
+
+// Returns [{ suite, issue }] so callers can decide per suite whether a gap is
+// pending adoption or a failure.
+export function invariantSuiteFindings(manifest, sourceFiles = new Map()) {
+  if (sourceFiles.size === 0) return [];
+  const findings = [];
+  for (const [exportPath, suite] of requiredInvariantSuites) {
+    if (!manifest.exports?.[exportPath]) continue;
+    const source = sourceFiles.get(suite);
+    if (!source) {
+      findings.push({ suite, missing: true, issue: `${exportPath} is exported but src/${suite} is missing (property-based invariant suite)` });
+    } else if (!source.includes('@hegeldev/hegel')) {
+      findings.push({ suite, missing: false, issue: `src/${suite} must use @hegeldev/hegel for its invariant properties` });
+    }
+  }
+  return findings;
+}
+
+export function invariantSuiteIssues(manifest, sourceFiles = new Map()) {
+  return invariantSuiteFindings(manifest, sourceFiles).map(({ issue }) => issue);
+}
+
+export function sdkConformanceIssues(manifest, sourceFiles = new Map(), options = {}) {
+  const issues = [];
+  if (manifest.type !== 'module') issues.push('package must use ESM (`type: module`)');
+  if (manifest.sideEffects !== false) issues.push('package must declare `sideEffects: false`');
+  if (!Array.isArray(manifest.files) || !manifest.files.includes('dist') || !manifest.files.includes('README.md')) {
+    issues.push('published files must include `dist` and `README.md`');
+  }
+
+  for (const exportPath of requiredCapabilityExports) {
+    const entry = manifest.exports?.[exportPath];
+    if (!entry) {
+      issues.push(`missing required capability export ${exportPath}`);
+      continue;
+    }
+    if (typeof entry.types !== 'string' || !entry.types.startsWith('./dist/') || !entry.types.endsWith('.d.ts')) {
+      issues.push(`${exportPath} types must resolve to a declaration under ./dist`);
+    }
+    if (typeof entry.import !== 'string' || !entry.import.startsWith('./dist/') || !entry.import.endsWith('.js')) {
+      issues.push(`${exportPath} import must resolve to ESM JavaScript under ./dist`);
+    }
+  }
+
+  if (!manifest.exports?.['./abis'] && !manifest.exports?.['./idl']) {
+    issues.push('missing chain artifact export (`./abis` for EVM or `./idl` for Solana)');
+  }
+  if (!manifest.exports?.['./provenance/mainnet.json'] && !manifest.exports?.['./provenance/testnet.json']) {
+    issues.push('missing an exported deployment provenance document');
+  }
+
+  if (sourceFiles.size > 0) {
+    const errorsSource = sourceFiles.get('errors.ts');
+    if (!errorsSource) {
+      issues.push('missing src/errors.ts for the exported SDK error contract');
+    } else {
+      const errorContractChecks = [
+        [/export\s+type\s+\w*ErrorCode/u, 'a public error-code union'],
+        [/export\s+class\s+\w+\s+extends\s+Error/u, 'an exported Error subclass'],
+        [/readonly\s+code/u, 'a readonly error code'],
+        [/\btoJSON\s*\(/u, 'a JSON representation'],
+        [/export\s+function\s+is\w*Error\s*\(/u, 'an exported error type guard'],
+      ];
+      for (const [pattern, label] of errorContractChecks) {
+        if (!pattern.test(errorsSource)) issues.push(`src/errors.ts must expose ${label}`);
+      }
+    }
+  }
+
+  for (const [path, source] of sourceFiles) {
+    if (path.endsWith('.test.ts') || path.endsWith('.spec.ts')) continue;
+    if (/throw\s+new\s+Error\s*\(/u.test(source)) {
+      issues.push(`${path} throws an untyped Error instead of the SDK error contract`);
+    }
+  }
+  if (options.requireInvariantSuites !== false) {
+    issues.push(...invariantSuiteIssues(manifest, sourceFiles));
+  }
+  return issues;
+}
+
+function collectTypeScriptSources(directory, base = directory, result = new Map()) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) collectTypeScriptSources(path, base, result);
+    else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      result.set(relative(base, path), readFileSync(path, 'utf8'));
+    }
+  }
+  return result;
+}
+
+function loadSdkPackage(packageRoot) {
+  const manifestPath = join(packageRoot, 'package.json');
+  const sourceRoot = join(packageRoot, 'src');
+  if (!existsSync(manifestPath)) return { error: `missing package manifest at ${manifestPath}` };
+  if (!existsSync(sourceRoot)) return { error: `missing SDK source directory at ${sourceRoot}` };
+  return {
+    manifest: JSON.parse(readFileSync(manifestPath, 'utf8')),
+    sourceFiles: collectTypeScriptSources(sourceRoot),
+  };
+}
+
+export function checkSdkPackage(packageRoot, options = {}) {
+  const loaded = loadSdkPackage(packageRoot);
+  if (loaded.error) return [loaded.error];
+  return sdkConformanceIssues(loaded.manifest, loaded.sourceFiles, options);
+}
+
+const repositoryRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+
+// Repository-relative, forward-slash form used as the pending-adoption key,
+// anchored on this script's location so the key is the same from any cwd.
+export function pendingAdoptionKey(packageRoot) {
+  return relative(repositoryRoot, resolve(packageRoot)).split(sep).join('/');
+}
+
+// Splits a package's issues into failures and pending-adoption warnings in one pass.
+export function classifySdkPackage(packageRoot) {
+  const loaded = loadSdkPackage(packageRoot);
+  if (loaded.error) return { failures: [loaded.error], warnings: [] };
+  const base = sdkConformanceIssues(loaded.manifest, loaded.sourceFiles, { requireInvariantSuites: false });
+  const pendingSuites = invariantAdoptionPending.get(pendingAdoptionKey(packageRoot)) ?? new Set();
+  const failures = [...base];
+  const warnings = [];
+  for (const { suite, issue, missing } of invariantSuiteFindings(loaded.manifest, loaded.sourceFiles)) {
+    // Pending adoption means "not written yet": only a missing file is
+    // downgraded. A file that exists without Hegel is a failure everywhere.
+    (missing && pendingSuites.has(suite) ? warnings : failures).push(issue);
+  }
+  return { failures, warnings };
+}
+
+const invokedPath = process.argv[1] ? resolve(process.argv[1]) : null;
+if (invokedPath === fileURLToPath(import.meta.url)) {
+  const packageRoots = process.argv.slice(2);
+  if (packageRoots.length === 0) {
+    console.error('Usage: node scripts/check-sdk-conformance.mjs <package-root> [...]');
+    process.exitCode = 2;
+  } else {
+    const results = packageRoots.map((packageRoot) => [packageRoot, classifySdkPackage(packageRoot)]);
+    const failures = results.flatMap(([root, { failures: f }]) => f.map((issue) => `${root}: ${issue}`));
+    const warnings = results.flatMap(([root, { warnings: w }]) => w.map((issue) => `${root}: pending adoption: ${issue}`));
+    if (warnings.length > 0) console.warn(warnings.join('\n'));
+    if (failures.length > 0) {
+      console.error(failures.join('\n'));
+      process.exitCode = 1;
+    } else {
+      console.log(`SDK conformance passed for ${packageRoots.join(', ')}`);
+    }
+  }
+}

package/scripts/verify-v3-deployments.mjs

@@ -0,0 +1,23 @@
+import { createPublicClient, http } from 'viem';
+import {
+  robinhoodUniswapV3Mainnet,
+  robinhoodUniswapV3Testnet,
+  verifyUniswapV3Compatibility,
+} from '../dist/v3.js';
+
+const targets = [
+  {
+    deployment: robinhoodUniswapV3Mainnet,
+    rpcUrl: process.env.UNISWAP_MAINNET_RPC_URL?.trim() || 'https://rpc.mainnet.chain.robinhood.com',
+  },
+  {
+    deployment: robinhoodUniswapV3Testnet,
+    rpcUrl: process.env.UNISWAP_TESTNET_RPC_URL?.trim() || 'https://rpc.testnet.chain.robinhood.com',
+  },
+];
+
+for (const { deployment, rpcUrl } of targets) {
+  const client = createPublicClient({ transport: http(rpcUrl) });
+  const report = await verifyUniswapV3Compatibility(client, deployment);
+  process.stdout.write(`ok - ${deployment.id}: ${Object.keys(report.runtimeCodeHashes).length} runtime hashes and manager wiring verified\n`);
+}