@eco-incorp/sauce 0.99.0

package/dev-tools/scripts/deploy.ts

@@ -0,0 +1,107 @@
+/**
+ * Deploy script for SauceRouter contract using pre-compiled artifact.
+ * SauceRouter inherits Sauce, so cook() works identically.
+ *
+ * BLOCKED: it needs `artifacts/SauceRouter.json`, and no such artifact exists any more. SauceRouter
+ * was a v1 contract in the engine repo's Solidity tree; the v12 releases the SDK now consumes
+ * publish only Router/IRouter/Pot/Kitchen, so `sync-artifacts` cannot produce it and this deploy
+ * fails on a missing file. The local stack has to move to the v12 Pot/Kitchen model — a Pot is
+ * deployed by `V12Kitchen.deployPot(owner, salt)` and cooked with `cook(address engine, bytes
+ * program)` — which is a rewrite of this flow, not a rename.
+ */
+
+import { createWalletClient, createPublicClient, http, Hex, defineChain } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function main() {
+  // Hardhat default pre-funded account private key
+  const privateKey = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+  const account = privateKeyToAccount(privateKey);
+
+  // Load artifacts from local artifacts/ directory
+  const routerImplArtifact = JSON.parse(
+    readFileSync(join(__dirname, "../artifacts/Router.json"), "utf-8"),
+  );
+  const sauceRouterArtifact = JSON.parse(
+    readFileSync(join(__dirname, "../artifacts/SauceRouter.json"), "utf-8"),
+  );
+
+  // Get the actual chain ID from the RPC (may be mainnet when forking)
+  const tempClient = createPublicClient({
+    transport: http("http://127.0.0.1:8545"),
+  });
+  const chainId = await tempClient.getChainId();
+
+  const chain = defineChain({
+    id: chainId,
+    name: "Local",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: ["http://127.0.0.1:8545"] } },
+  });
+
+  // Create clients
+  const publicClient = createPublicClient({
+    chain,
+    transport: http("http://127.0.0.1:8545"),
+  });
+
+  const walletClient = createWalletClient({
+    account,
+    chain,
+    transport: http("http://127.0.0.1:8545"),
+  });
+
+  console.log("Deployer:", account.address);
+
+  // Deploy Router
+  console.log("Deploying Router...");
+  // @ts-expect-error - viem types require kzg for blob transactions, but we're not using blobs
+  const routerHash = await walletClient.deployContract({
+    abi: routerImplArtifact.abi,
+    bytecode: routerImplArtifact.bytecode.object as Hex,
+    account,
+    chain,
+  });
+  const routerReceipt = await publicClient.waitForTransactionReceipt({
+    hash: routerHash,
+  });
+  if (!routerReceipt.contractAddress) {
+    throw new Error("Router deployment failed");
+  }
+  console.log("Router deployed at:", routerReceipt.contractAddress);
+
+  // Deploy SauceRouter with Router address
+  console.log("Deploying SauceRouter...");
+  // @ts-expect-error - viem types require kzg for blob transactions, but we're not using blobs
+  const hash = await walletClient.deployContract({
+    abi: sauceRouterArtifact.abi,
+    bytecode: sauceRouterArtifact.bytecode.object as Hex,
+    args: [routerReceipt.contractAddress],
+    account,
+    chain,
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  if (!receipt.contractAddress) {
+    throw new Error("SauceRouter deployment failed");
+  }
+
+  console.log("SauceRouter deployed at:", receipt.contractAddress);
+  return receipt.contractAddress;
+}
+
+main()
+  .then((address) => {
+    // Output just the address for shell script to capture
+    console.log(`SAUCE_ADDRESS=${address}`);
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error("Deployment failed:", error);
+    process.exit(1);
+  });

package/dev-tools/scripts/init.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, cpSync, writeFileSync, chmodSync, readFileSync } from "fs";
+import { resolve, join, basename } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const packageRoot = resolve(__dirname, "..");
+
+// Parse arguments
+const args = process.argv.slice(2);
+let targetName = ".";
+
+if (args[0] === "init") {
+  targetName = args[1] || ".";
+} else if (args[0] && !args[0].startsWith("-")) {
+  targetName = args[0];
+}
+
+const targetDir = resolve(process.cwd(), targetName);
+const projectName = targetName === "." ? basename(process.cwd()) : basename(targetName);
+
+// Read own package.json to get the compiler version
+const ownPkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf-8"));
+const compilerVersion = ownPkg.version;
+
+// Create target directory if needed
+if (targetName !== ".") {
+  if (existsSync(targetDir)) {
+    console.error(`Error: directory "${targetName}" already exists.`);
+    process.exit(1);
+  }
+  mkdirSync(targetDir, { recursive: true });
+}
+
+// Copy template directories and files
+const templateItems = [
+  "scripts",
+  "src",
+  "sauce",
+  "artifacts",
+  "hardhat.config.cjs",
+  "tsconfig.json",
+  "README.md",
+];
+
+for (const item of templateItems) {
+  const src = join(packageRoot, item);
+  const dest = join(targetDir, item);
+  if (!existsSync(src)) continue;
+  cpSync(src, dest, { recursive: true });
+}
+
+// Make shell scripts executable
+const shellScripts = ["scripts/start-local.sh", "scripts/start-fork.sh", "scripts/stop-local.sh"];
+for (const script of shellScripts) {
+  const scriptPath = join(targetDir, script);
+  if (existsSync(scriptPath)) {
+    chmodSync(scriptPath, 0o755);
+  }
+}
+
+// Generate package.json
+const pkg = {
+  name: projectName,
+  version: "0.0.1",
+  private: true,
+  type: "module",
+  scripts: {
+    sauce: "npx tsx scripts/run.ts",
+    "start:local": "./scripts/start-local.sh",
+    "start:fork": "./scripts/start-fork.sh",
+    stop: "./scripts/stop-local.sh",
+  },
+  dependencies: {
+    "@eco-incorp/sauce-compiler": `^${compilerVersion}`,
+    "@uniswap/v3-core": "^1.0.1",
+    viem: "^2.45.1",
+  },
+  devDependencies: {
+    "@types/node": "^22.0.0",
+    hardhat: "^2.22.0",
+    tsx: "^4.7.0",
+    typescript: "^5.7.0",
+  },
+};
+
+writeFileSync(join(targetDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+
+// Generate .npmrc
+writeFileSync(join(targetDir, ".npmrc"), "@eco:registry=https://npm.pkg.github.com\n");
+
+// Generate .gitignore
+const gitignore = `# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+out/
+cache/
+artifacts/
+
+# Local deployment state
+.deployment.json
+
+# Logs
+*.log
+npm-debug.log*
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# TypeScript
+*.tsbuildinfo
+`;
+
+writeFileSync(join(targetDir, ".gitignore"), gitignore);
+
+// Print next steps
+console.log(`
+Sauce project created in ${targetName === "." ? "current directory" : targetName}!
+
+Next steps:
+
+  ${targetName !== "." ? `cd ${targetName}\n  ` : ""}npm install
+  npm run start:local
+  npm run sauce sauce/js/example.js
+`);

package/dev-tools/scripts/run.ts

@@ -0,0 +1,67 @@
+/**
+ * CLI entry point for SauceScript runner
+ *
+ * Usage: npm run sauce <path-to-file.js> [VALUE ...] [NAME=VALUE ...]
+ *
+ * A `NAME=VALUE` operand is a compile-time define; a bare value is a positional RUNTIME arg for
+ * `main`'s next parameter. The two are told apart by shape — a define's name is an identifier, and
+ * no integer or hex literal can look like one — so they may be interleaved freely, and the
+ * positional args keep the order they were given in.
+ *
+ * Prerequisites: Run `npm run start:local` first to start Anvil and deploy Sauce
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { executeScript, parseArg, parseDefine } from "../src/runner";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const DEFINE = /^[A-Za-z_$][A-Za-z0-9_$]*=/;
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error("Usage: npm run sauce <path-to-file.js> [VALUE ...] [NAME=VALUE ...]");
+    console.error("Example: npm run sauce sauce/js/add.js 5 10");
+    console.error("Example: npm run sauce test/fixtures/defined.js AMOUNT=4242");
+    process.exit(1);
+  }
+
+  const scriptPath = resolve(args[0]);
+  const operands = args.slice(1);
+  const defines = Object.fromEntries(operands.filter((o) => DEFINE.test(o)).map(parseDefine));
+  const scriptArgs = operands.filter((o) => !DEFINE.test(o)).map(parseArg);
+
+  if (!existsSync(scriptPath)) {
+    console.error(`Error: File not found: ${scriptPath}`);
+    process.exit(1);
+  }
+
+  const repoRoot = join(__dirname, "..");
+
+  // Check if deployment exists
+  const deploymentPath = join(repoRoot, ".deployment.json");
+  if (!existsSync(deploymentPath)) {
+    console.error("Error: No deployment found. Run `npm run start:local` first.");
+    process.exit(1);
+  }
+
+  const deployment = JSON.parse(readFileSync(deploymentPath, "utf-8"));
+  const { sauceAddress, rpcUrl, forkUrl } = deployment;
+
+  await executeScript({
+    scriptPath,
+    defines,
+    args: scriptArgs,
+    sauceAddress,
+    rpcUrl,
+    forkUrl,
+    baseDir: repoRoot,
+  });
+}
+
+main().catch(console.error);

package/dev-tools/scripts/start-fork.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+set -e
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+if [ -z "$1" ]; then
+    echo "Usage: npm run start:fork <rpc-url>"
+    echo "Example: npm run start:fork https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"
+    exit 1
+fi
+
+FORK_URL="$1"
+
+# Check for Sauce artifact
+if [ ! -f "$REPO_ROOT/artifacts/ISauceRouter.json" ]; then
+    echo "Error: artifacts/ISauceRouter.json not found."
+    echo "Run './engine/export-artifact.sh' from the repo root to generate it."
+    exit 1
+fi
+
+echo -e "${YELLOW}Starting Hardhat (forking $FORK_URL)...${NC}"
+
+# Kill any existing process on port 8545
+if lsof -i :8545 > /dev/null 2>&1; then
+    echo "Port 8545 in use. Killing existing process..."
+    lsof -ti :8545 | xargs kill -9 2>/dev/null || true
+    sleep 1
+fi
+
+# Start Hardhat node with forking in background
+cd "$REPO_ROOT"
+npx hardhat node --fork "$FORK_URL" > "$REPO_ROOT/.hardhat.log" 2>&1 &
+HARDHAT_PID=$!
+
+# Wait for hardhat to be ready
+echo "Waiting for Hardhat..."
+for i in {1..60}; do
+    if curl -s -X POST -H 'Content-Type: application/json' \
+        --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
+        http://127.0.0.1:8545 > /dev/null 2>&1; then
+        break
+    fi
+    if ! kill -0 $HARDHAT_PID 2>/dev/null; then
+        echo "Failed to start Hardhat. Check .hardhat.log for details."
+        cat "$REPO_ROOT/.hardhat.log"
+        exit 1
+    fi
+    sleep 1
+done
+
+if ! curl -s -X POST -H 'Content-Type: application/json' \
+    --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
+    http://127.0.0.1:8545 > /dev/null 2>&1; then
+    echo "Hardhat failed to respond. Check .hardhat.log for details."
+    kill $HARDHAT_PID 2>/dev/null
+    exit 1
+fi
+
+echo -e "${GREEN}Hardhat running (PID: $HARDHAT_PID)${NC}"
+
+# Deploy Sauce
+echo -e "${YELLOW}Deploying Sauce...${NC}"
+DEPLOY_OUTPUT=$(npx tsx scripts/deploy.ts 2>&1)
+
+SAUCE_ADDRESS=$(echo "$DEPLOY_OUTPUT" | grep "SAUCE_ADDRESS=" | cut -d'=' -f2)
+
+if [ -z "$SAUCE_ADDRESS" ]; then
+    echo "Failed to deploy Sauce contract:"
+    echo "$DEPLOY_OUTPUT"
+    kill $HARDHAT_PID 2>/dev/null
+    exit 1
+fi
+
+# Write deployment info
+cat > "$REPO_ROOT/.deployment.json" << EOF
+{"sauceAddress":"$SAUCE_ADDRESS","rpcUrl":"http://127.0.0.1:8545","forkUrl":"$FORK_URL","hardhatPid":$HARDHAT_PID}
+EOF
+
+echo ""
+echo -e "${GREEN}========================================${NC}"
+echo -e "${GREEN}       Ready!${NC}"
+echo -e "${GREEN}========================================${NC}"
+echo -e "${CYAN}Sauce:${NC}    $SAUCE_ADDRESS"
+echo -e "${CYAN}RPC:${NC}      http://127.0.0.1:8545"
+echo -e "${CYAN}Fork:${NC}     $FORK_URL"
+echo ""
+echo -e "Stop with: ${YELLOW}npm run stop${NC}"

package/dev-tools/scripts/start-local.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+set -e
+
+# Get the repo root directory
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Check for Sauce artifact
+if [ ! -f "$REPO_ROOT/artifacts/ISauceRouter.json" ]; then
+    echo "Error: artifacts/ISauceRouter.json not found."
+    echo "Run './engine/export-artifact.sh' from the repo root to generate it."
+    exit 1
+fi
+
+echo -e "${YELLOW}Starting Hardhat local network...${NC}"
+
+# Check if something is already running on port 8545
+if lsof -i :8545 > /dev/null 2>&1; then
+    echo "Port 8545 is already in use. Killing existing process..."
+    lsof -ti :8545 | xargs kill -9 2>/dev/null || true
+    sleep 1
+fi
+
+# Start hardhat node in the background
+cd "$REPO_ROOT"
+
+# Support forking via FORK_URL environment variable
+if [ -n "$FORK_URL" ]; then
+    echo -e "${CYAN}Forking from: $FORK_URL${NC}"
+    npx hardhat node --fork "$FORK_URL" > "$REPO_ROOT/.hardhat.log" 2>&1 &
+else
+    npx hardhat node > "$REPO_ROOT/.hardhat.log" 2>&1 &
+fi
+HARDHAT_PID=$!
+
+# Wait for hardhat to be ready
+echo "Waiting for Hardhat to start..."
+for i in {1..30}; do
+    if curl -s -X POST -H 'Content-Type: application/json' \
+        --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
+        http://127.0.0.1:8545 > /dev/null 2>&1; then
+        break
+    fi
+    if ! kill -0 $HARDHAT_PID 2>/dev/null; then
+        echo "Failed to start Hardhat. Check .hardhat.log for details."
+        exit 1
+    fi
+    sleep 1
+done
+
+# Final check
+if ! curl -s -X POST -H 'Content-Type: application/json' \
+    --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
+    http://127.0.0.1:8545 > /dev/null 2>&1; then
+    echo "Hardhat failed to respond. Check .hardhat.log for details."
+    kill $HARDHAT_PID 2>/dev/null
+    exit 1
+fi
+
+echo -e "${GREEN}Hardhat running (PID: $HARDHAT_PID)${NC}"
+echo ""
+
+# Deploy Sauce contract
+echo -e "${YELLOW}Deploying Sauce contract...${NC}"
+DEPLOY_OUTPUT=$(npx tsx scripts/deploy.ts 2>&1)
+
+# Extract the Sauce address from the output
+SAUCE_ADDRESS=$(echo "$DEPLOY_OUTPUT" | grep "SAUCE_ADDRESS=" | cut -d'=' -f2)
+
+if [ -z "$SAUCE_ADDRESS" ]; then
+    echo "Failed to deploy Sauce contract:"
+    echo "$DEPLOY_OUTPUT"
+    kill $HARDHAT_PID 2>/dev/null
+    exit 1
+fi
+
+echo ""
+echo -e "${GREEN}========================================${NC}"
+echo -e "${GREEN}       Deployment complete!${NC}"
+echo -e "${GREEN}========================================${NC}"
+echo ""
+echo -e "${CYAN}Sauce Address:${NC} $SAUCE_ADDRESS"
+echo ""
+echo -e "Hardhat PID:    $HARDHAT_PID"
+echo -e "RPC URL:        http://127.0.0.1:8545"
+echo -e "Chain ID:       31337"
+echo ""
+echo -e "To stop:        ${YELLOW}npm run stop${NC}"
+
+# Write deployment info to a file for other scripts to use
+if [ -n "$FORK_URL" ]; then
+cat > "$REPO_ROOT/.deployment.json" << EOF
+{
+  "sauceAddress": "$SAUCE_ADDRESS",
+  "rpcUrl": "http://127.0.0.1:8545",
+  "forkUrl": "$FORK_URL",
+  "hardhatPid": $HARDHAT_PID
+}
+EOF
+else
+cat > "$REPO_ROOT/.deployment.json" << EOF
+{
+  "sauceAddress": "$SAUCE_ADDRESS",
+  "rpcUrl": "http://127.0.0.1:8545",
+  "hardhatPid": $HARDHAT_PID
+}
+EOF
+fi
+
+echo ""
+echo -e "Deployment info saved to ${CYAN}.deployment.json${NC}"

package/dev-tools/scripts/stop-local.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+DEPLOYMENT_FILE="$REPO_ROOT/.deployment.json"
+
+# Try to get PID from deployment file
+if [ -f "$DEPLOYMENT_FILE" ]; then
+    HARDHAT_PID=$(grep -o '"hardhatPid":[0-9]*' "$DEPLOYMENT_FILE" | grep -o '[0-9]*')
+fi
+
+# Also check if anything is running on port 8545
+PORT_PID=$(lsof -ti :8545 2>/dev/null)
+
+if [ -n "$HARDHAT_PID" ] && kill -0 "$HARDHAT_PID" 2>/dev/null; then
+    echo -e "${YELLOW}Stopping Hardhat (PID: $HARDHAT_PID)...${NC}"
+    kill "$HARDHAT_PID"
+    echo -e "${GREEN}Hardhat stopped.${NC}"
+elif [ -n "$PORT_PID" ]; then
+    echo -e "${YELLOW}Stopping process on port 8545 (PID: $PORT_PID)...${NC}"
+    kill "$PORT_PID"
+    echo -e "${GREEN}Process stopped.${NC}"
+else
+    echo -e "${YELLOW}No Hardhat process found running.${NC}"
+fi
+
+# Clean up files
+if [ -f "$DEPLOYMENT_FILE" ]; then
+    rm "$DEPLOYMENT_FILE"
+    echo "Removed .deployment.json"
+fi
+
+if [ -f "$REPO_ROOT/.hardhat.log" ]; then
+    rm "$REPO_ROOT/.hardhat.log"
+    echo "Removed .hardhat.log"
+fi

package/dev-tools/scripts/sync-artifacts.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Copies the contract artifacts the dev-tools recipes and deploy.ts read at runtime
+// into dev-tools/artifacts/. That directory is gitignored (build output) but ships in
+// the published package (root package.json `files`), so this runs at `prepack` — and
+// on demand via `pnpm sync-artifacts` for local recipe runs / fork tests.
+//
+// Source: sdk/src/artifacts/, produced by sdk/scripts/sync-engine-artifacts.mjs — which now takes
+// the ABIs from a pinned v12 release rather than compiling anything. Reading the sdk's synced copy
+// leaves ONE place that knows where engine artifacts come from.
+//
+// Ordering holds in both flows that matter: `pnpm build` builds the sdk (whose build runs the sync)
+// before `pnpm publish` fires `prepack`, and `pnpm --filter './sdk' sync-engine-artifacts` is the
+// documented step for a local run. Fails loudly rather than silently shipping empty artifacts.
+import { existsSync, mkdirSync, copyFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const DEV_TOOLS_DIR = resolve(SCRIPT_DIR, "..");
+const REPO_ROOT = resolve(DEV_TOOLS_DIR, "..");
+const ARTIFACTS_DIR = resolve(DEV_TOOLS_DIR, "artifacts");
+const SOURCE_DIR = resolve(REPO_ROOT, "sdk", "src", "artifacts");
+
+// Contracts the recipes (`import … from "./artifacts/X.json"`, quoting.ts) and the deploy/fork-test
+// flow read. `SauceRouter` is NOT among them any more: it was a v1 contract from the engine repo's
+// deleted Solidity tree, and the v12 releases publish only Router/IRouter/Pot/Kitchen, so no source
+// for it exists. `deploy.ts` and `test/e2e.test.ts` still want it — see their headers.
+const ARTIFACTS = ["IERC20", "ISauceRouter", "IUniswapV3Pool", "Router"];
+
+const missing = ARTIFACTS.filter((name) => !existsSync(resolve(SOURCE_DIR, `${name}.json`)));
+
+if (missing.length) {
+  console.error(
+    `[sync-artifacts] missing from ${SOURCE_DIR}: ${missing.join(", ")}. Run ` +
+      "`pnpm --filter './sdk' sync-engine-artifacts` first (with Foundry installed, so it can " +
+      "build the pinned sauce engine).",
+  );
+  process.exit(1);
+}
+
+mkdirSync(ARTIFACTS_DIR, { recursive: true });
+for (const name of ARTIFACTS) {
+  copyFileSync(resolve(SOURCE_DIR, `${name}.json`), resolve(ARTIFACTS_DIR, `${name}.json`));
+}
+
+console.log(`[sync-artifacts] copied ${ARTIFACTS.length} artifacts -> dev-tools/artifacts/`);

package/dev-tools/scripts/sync-price.ts

@@ -0,0 +1,58 @@
+/**
+ * CLI entry point for Uniswap V3 price sync.
+ *
+ * Usage: npm run sync-price <pool-address>
+ *
+ * Prerequisites: Run `npm run start:fork <rpc-url>` first
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { type Hex } from "viem";
+import { syncPrice, formatSqrtPrice } from "../src/sync-price";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error("Usage: npm run sync-price <pool-address>");
+    console.error("\nSyncs a Uniswap V3 pool's price and balances on the fork to match mainnet.");
+    console.error("Prerequisites: npm run start:fork <rpc-url>");
+    process.exit(1);
+  }
+
+  const poolAddress = args[0] as Hex;
+
+  const deploymentPath = join(__dirname, "../.deployment.json");
+  if (!existsSync(deploymentPath)) {
+    console.error("Error: No deployment found. Run `npm run start:fork` first.");
+    process.exit(1);
+  }
+
+  const deployment = JSON.parse(readFileSync(deploymentPath, "utf-8"));
+  const { rpcUrl, forkUrl } = deployment;
+
+  if (!forkUrl) {
+    console.error("Error: No fork URL found. Run `npm run start:fork <rpc-url>` first.");
+    process.exit(1);
+  }
+
+  console.log("=== Uniswap V3 Price Sync ===\n");
+  console.log("Pool:", poolAddress);
+
+  const result = await syncPrice({ poolAddress, forkRpc: rpcUrl, mainnetRpc: forkUrl });
+
+  console.log(`Token0: ${result.token0}`);
+  console.log(`Token1: ${result.token1}`);
+  console.log(`Fee: ${result.fee} (${result.fee / 10000}%)`);
+  console.log(
+    `\nPrice (t1/t0): ${formatSqrtPrice(result.before.sqrtPriceX96)} → ${formatSqrtPrice(result.after.sqrtPriceX96)}`,
+  );
+  console.log(`Token0 balance: ${result.before.balance0} → ${result.after.balance0}`);
+  console.log(`Token1 balance: ${result.before.balance1} → ${result.after.balance1}`);
+  console.log("\nDone!");
+}
+
+main().catch(console.error);