@eco-incorp/sauce 0.99.6 → 0.99.8

package/dev-tools/src/svm-local.ts

@@ -1,305 +0,0 @@
-/**
- * Local SVM e2e for dev-tools: boot the REAL gated engine in-process and run a program through a
- * kitchen cook — the same orchestration the SDK's own suites use (sdk/test/svm/engine-harness.ts),
- * so a developer can execute SVM programs on their machine with no validator and no credentials.
- *
- * The engine + kitchen binaries come from the packaged resolver (`@eco-incorp/sauce/svm/engine-
- * artifacts`), so this works from an installed package: `eco-incorp/v12` is private, and the shipped
- * `.so` are the only way a consumer gets the engine. The cook is built by the SDK's own
- * `createSauceSvmClient`, so what runs here is exactly what the client would sign against a real
- * cluster — a released engine refuses anything that did not arrive through a kitchen cook.
- */
-import { readFileSync } from "node:fs";
-import {
-  address,
-  generateKeyPairSigner,
-  getAddressCodec,
-  getBase64Encoder,
-  getTransactionDecoder,
-  lamports,
-} from "@solana/kit";
-import type { Address, Instruction, KeyPairSigner } from "@solana/kit";
-import { Clock, FailedTransactionMetadata, FeatureSet, LiteSVM } from "litesvm";
-import {
-  buildCreatePotInstruction,
-  buildExecuteTransaction,
-  buildInitializeExecutionFeeInstruction,
-  buildSetExecutionFeeInstruction,
-  createSauceSvmClient,
-  deriveExecutionFeeConfigPda,
-  derivePotPda,
-  deriveProgramDataPda,
-  MAX_POT_LEN,
-} from "@eco-incorp/sauce-source/svm";
-import type { AccountResolution, SignedExecuteTransaction } from "@eco-incorp/sauce-source/svm";
-import {
-  svmEnginePath,
-  svmKitchenIdlPath,
-  svmKitchenPath,
-  type EngineCluster,
-  type SvmEngineArtifactPaths,
-} from "@eco-incorp/sauce-source/svm/engine-artifacts";
-import type { AccountManifest } from "sauce-compiler";
-
-/** Slot every local run sits at (must exceed a fabricated ALT's last_extended_slot 0). */
-const LOCAL_SLOT = 1000n;
-/** The salt the local Pot is minted under. One Pot is enough for a single-program local run. */
-const LOCAL_POT_SALT = new Uint8Array(32).fill(11);
-/** An unroutable URL: the client's RPC calls are answered by the LiteSVM fetch stub, never the net. */
-const LOCAL_RPC_URL = "http://127.0.0.1:65535/";
-
-export interface LocalEngine {
-  svm: LiteSVM;
-  /** The engine program id (random per boot — the gate keys off the kitchen, not this). */
-  programId: Address;
-  payer: KeyPairSigner;
-  kitchen: Address;
-  pot: Address;
-}
-
-export interface RunResult {
-  ok: boolean;
-  err: string | null;
-  logs: string[];
-  returnData: Uint8Array;
-}
-
-/** The kitchen's declared program id, read from the release IDL (a hardcoded id rotted once before). */
-const kitchenProgramId = (idlPath?: string): Address =>
-  address(
-    (JSON.parse(readFileSync(svmKitchenIdlPath(idlPath), "utf8")) as { address: string }).address,
-  );
-
-/**
- * Makes `authority` the kitchen's upgrade authority so the fee config can be initialized. LiteSVM
- * loads programs immutable (no recorded authority), and an uninitialized fee config is a failed cook.
- * Bincode ProgramData header: u32 variant(=3), u64 slot, u8 Option tag, then the 32-byte authority.
- */
-const grantUpgradeAuthority = (svm: LiteSVM, programData: Address, authority: Address): void => {
-  const account = svm.getAccount(programData) as {
-    data?: Uint8Array;
-    lamports?: bigint;
-    programAddress?: Address;
-    executable?: boolean;
-  } | null;
-  if (account?.data === undefined) {
-    throw new Error(`the loader recorded no ProgramData for the kitchen at ${programData}`);
-  }
-  const data = new Uint8Array(account.data);
-  const variant = new DataView(data.buffer, data.byteOffset).getUint32(0, true);
-  if (variant !== 3) {
-    throw new Error(`expected a ProgramData account (variant 3) at ${programData}, got ${variant}`);
-  }
-  data[12] = 1; // Option::Some
-  data.set(new Uint8Array(getAddressCodec().encode(authority)), 13);
-  svm.setAccount({
-    address: programData,
-    data,
-    executable: account.executable ?? false,
-    lamports: lamports(account.lamports ?? 0n),
-    programAddress: account.programAddress as Address,
-    space: BigInt(data.length),
-  });
-};
-
-const send = (svm: LiteSVM, transaction: SignedExecuteTransaction): RunResult => {
-  const result = svm.sendTransaction(transaction);
-  if (result instanceof FailedTransactionMetadata) {
-    return {
-      ok: false,
-      err: String(result.err()),
-      logs: result.meta().logs(),
-      returnData: result.meta().returnData().data(),
-    };
-  }
-  return { ok: true, err: null, logs: result.logs(), returnData: result.returnData().data() };
-};
-
-const sendInstructions = async (
-  engine: LocalEngine,
-  instructions: readonly Instruction[],
-): Promise<RunResult> => {
-  engine.svm.expireBlockhash();
-  return send(
-    engine.svm,
-    await buildExecuteTransaction({
-      payer: engine.payer,
-      instructions,
-      latestBlockhash: {
-        blockhash: engine.svm.latestBlockhash(),
-        lastValidBlockHeight: 1_000_000n,
-      },
-    }),
-  );
-};
-
-const mustSucceed = (result: RunResult, what: string): void => {
-  if (!result.ok)
-    throw new Error(`local engine setup: ${what} failed: ${result.err}\n${result.logs.join("\n")}`);
-};
-
-/**
- * Boots LiteSVM with the packaged engine + kitchen, a funded payer, a priced-then-freed execution
- * fee, and a Pot — the full gated set. `unixTimestamp` pins the cluster clock (venue fragments read
- * ctx.timestamp()); `cluster` picks which packaged engine `.so` to load; `artifacts` names binaries
- * to load instead of the packaged ones (an unreleased engine build, say).
- */
-export const bootLocalEngine = async (
-  unixTimestamp = 1_700_000_000n,
-  cluster: EngineCluster = "devnet",
-  artifacts: SvmEngineArtifactPaths = {},
-): Promise<LocalEngine> => {
-  const svm = new LiteSVM()
-    .withFeatureSet(FeatureSet.allEnabled())
-    .withBuiltins()
-    .withPrecompiles()
-    .withSysvars()
-    .withDefaultPrograms();
-
-  const programId = (await generateKeyPairSigner()).address;
-  svm.addProgramFromFile(programId, svmEnginePath(cluster, artifacts.engineSo));
-
-  const kitchen = kitchenProgramId(artifacts.kitchenIdlJson);
-  svm.addProgram(kitchen, new Uint8Array(readFileSync(svmKitchenPath(artifacts.kitchenSo))));
-
-  svm.warpToSlot(LOCAL_SLOT);
-  svm.setClock(new Clock(LOCAL_SLOT, 0n, 0n, 0n, unixTimestamp));
-
-  const payer = await generateKeyPairSigner();
-  svm.airdrop(payer.address, lamports(1_000_000_000_000n));
-
-  const { address: feeConfig } = await deriveExecutionFeeConfigPda(kitchen);
-  const { address: programData } = await deriveProgramDataPda(kitchen);
-  grantUpgradeAuthority(svm, programData, payer.address);
-
-  const { address: pot } = await derivePotPda(kitchen, payer.address, LOCAL_POT_SALT);
-  const engine: LocalEngine = { svm, programId, payer, kitchen, pot };
-
-  const admin = { kitchen, authority: payer.address, programData, feeConfig };
-  mustSucceed(
-    await sendInstructions(engine, [
-      buildInitializeExecutionFeeInstruction({ ...admin, initialFee: 25_000n }),
-    ]),
-    "initialize_execution_fee",
-  );
-  mustSucceed(
-    await sendInstructions(engine, [buildSetExecutionFeeInstruction({ ...admin, fee: 0n })]),
-    "set_execution_fee",
-  );
-  mustSucceed(
-    await sendInstructions(engine, [
-      buildCreatePotInstruction({
-        kitchen,
-        owner: payer.address,
-        engineProgram: programId,
-        pot,
-        salt: LOCAL_POT_SALT,
-        space: MAX_POT_LEN,
-      }),
-    ]),
-    "create_pot",
-  );
-
-  return engine;
-};
-
-/** Routes the `createSauceSvmClient` RPC calls (`getLatestBlockhash`, `simulateTransaction`) at the
- *  in-process LiteSVM, so the client's own signed wire bytes run exactly as sent. Swaps the process-
- *  wide `globalThis.fetch` for the duration, so calls must not overlap — see `runSvmProgramLocally`. */
-const withLiteSvmRpc = async <T>(engine: LocalEngine, body: () => Promise<T>): Promise<T> => {
-  const original = globalThis.fetch;
-  globalThis.fetch = (async (_url: unknown, init: { body: string }): Promise<unknown> => {
-    const { id, method, params } = JSON.parse(init.body) as {
-      id: number;
-      method: string;
-      params: unknown[];
-    };
-    if (method === "getLatestBlockhash") {
-      return Response.json({
-        id,
-        jsonrpc: "2.0",
-        result: {
-          context: { apiVersion: "2.0.0", slot: 100 },
-          value: { blockhash: engine.svm.latestBlockhash(), lastValidBlockHeight: 1_000_000 },
-        },
-      });
-    }
-    if (method === "simulateTransaction") {
-      const wire = getBase64Encoder().encode(params[0] as string);
-      const result = engine.svm.sendTransaction(
-        getTransactionDecoder().decode(new Uint8Array(wire)),
-      ) as { err?: () => unknown; logs?: () => string[] };
-      const failed = typeof result.err === "function" ? result.err.call(result) : undefined;
-      return Response.json({
-        id,
-        jsonrpc: "2.0",
-        result: {
-          context: { apiVersion: "2.0.0", slot: 100 },
-          value: {
-            accounts: null,
-            err: failed ? String(failed) : null,
-            logs: typeof result.logs === "function" ? result.logs.call(result) : [],
-            returnData: null,
-            unitsConsumed: 0,
-          },
-        },
-      });
-    }
-    throw new Error(`local engine: the client made an unexpected RPC call: ${method}`);
-  }) as unknown as typeof fetch;
-  try {
-    return await body();
-  } finally {
-    globalThis.fetch = original;
-  }
-};
-
-export interface RunProgramOptions {
-  /** Maps the manifest's account refs to real addresses (empty for a self-contained program). */
-  resolution?: AccountResolution;
-  /** Cluster engine to run against (default devnet). */
-  cluster?: EngineCluster;
-  /** Cluster clock, unix seconds (default 1_700_000_000). */
-  unixTimestamp?: bigint;
-  /** Engine/kitchen binaries to load instead of the packaged ones. */
-  artifacts?: SvmEngineArtifactPaths;
-}
-
-/**
- * One-shot: boot the local engine and run `bytecode` through a kitchen cook the gate accepts,
- * returning `{ err, logs }` (`err` is null on success). `bytecode` and `manifest` are exactly what
- * `@eco-incorp/sauce/compiler`'s `compile({ target: 'svm' })` returns; `options.resolution` maps the
- * manifest's account refs to addresses (empty for a self-contained program). This is the local e2e a
- * developer runs against a program they compiled — no validator, no credentials.
- *
- * Not concurrency-safe: it swaps `globalThis.fetch` for the length of the run to route the client's
- * RPC at the in-process LiteSVM, so run these one at a time (await each) rather than in parallel —
- * overlapping calls would clobber each other's fetch patch. Awaiting sequentially is the norm for the
- * per-program local e2e this is built for.
- */
-export const runSvmProgramLocally = async (
-  bytecode: Uint8Array,
-  manifest: AccountManifest,
-  options: RunProgramOptions = {},
-): Promise<{ err: string | null; logs: string[] }> => {
-  const engine = await bootLocalEngine(
-    options.unixTimestamp ?? 1_700_000_000n,
-    options.cluster,
-    options.artifacts,
-  );
-  return withLiteSvmRpc(engine, async () => {
-    const client = await createSauceSvmClient({
-      kitchen: engine.kitchen,
-      maxExecutionFee: 0n,
-      payer: engine.payer,
-      potSalt: LOCAL_POT_SALT,
-      programId: engine.programId,
-      rpcUrl: LOCAL_RPC_URL,
-    });
-    const result = (await client.simulate(bytecode, manifest, options.resolution ?? {}, {})) as {
-      err?: unknown;
-      logs?: string[];
-    };
-    return { err: (result.err as string | null) ?? null, logs: result.logs ?? [] };
-  });
-};

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

@@ -1,217 +0,0 @@
-/**
- * Sync a Uniswap V3 pool's price and token balances on a fork to match mainnet.
- *
- * Uses hardhat_setStorageAt to copy:
- * - slot0 (sqrtPriceX96, tick, etc.)
- * - Token balances held by the pool
- */
-
-import {
-  createPublicClient,
-  http,
-  parseAbi,
-  type Hex,
-  keccak256,
-  encodePacked,
-  pad,
-  numberToHex,
-} from "viem";
-
-const poolAbi = parseAbi([
-  "function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)",
-  "function token0() view returns (address)",
-  "function token1() view returns (address)",
-  "function fee() view returns (uint24)",
-]);
-
-const erc20Abi = parseAbi(["function balanceOf(address) view returns (uint256)"]);
-
-const SLOT0_POSITION: Hex = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
-export function formatSqrtPrice(sqrtPriceX96: bigint): string {
-  const Q96 = 2n ** 96n;
-  const priceNum = Number(sqrtPriceX96) / Number(Q96);
-  return (priceNum * priceNum).toExponential(6);
-}
-
-async function rpc(url: string, method: string, params: unknown[]) {
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ jsonrpc: "2.0", method, params, id: 1 }),
-  });
-  const json = (await res.json()) as { result?: unknown; error?: { message: string } };
-  if (json.error) throw new Error(json.error.message);
-  return json.result;
-}
-
-function balanceKey(holder: Hex, slot: number): Hex {
-  return keccak256(
-    encodePacked(
-      ["bytes32", "bytes32"],
-      [pad(holder, { size: 32 }), pad(numberToHex(slot), { size: 32 })],
-    ),
-  );
-}
-
-/**
- * Find the storage slot used for an ERC20 balance mapping.
- * Tries Solidity-style (keccak256(addr . slot)) for slots 0-20.
- */
-export async function findBalanceSlot(
-  token: Hex,
-  holder: Hex,
-  forkRpc: string,
-): Promise<number | null> {
-  const forkClient = createPublicClient({ transport: http(forkRpc) });
-  const balance = (await forkClient.readContract({
-    address: token,
-    abi: erc20Abi,
-    functionName: "balanceOf",
-    args: [holder],
-  } as any)) as bigint;
-
-  if (balance === 0n) return null;
-
-  const balanceHex = pad(numberToHex(balance), { size: 32 });
-
-  for (let slot = 0; slot <= 20; slot++) {
-    const key = balanceKey(holder, slot);
-    const reading = (await rpc(forkRpc, "eth_getStorageAt", [token, key, "latest"])) as Hex;
-    if (reading === balanceHex) return slot;
-  }
-  return null;
-}
-
-/**
- * Set an ERC20 token balance for an address on a Hardhat fork.
- */
-export async function setBalance(
-  token: Hex,
-  holder: Hex,
-  amount: bigint,
-  balanceSlot: number,
-  forkRpc: string,
-) {
-  const key = balanceKey(holder, balanceSlot);
-  await rpc(forkRpc, "hardhat_setStorageAt", [token, key, pad(numberToHex(amount), { size: 32 })]);
-}
-
-export interface SyncPriceOptions {
-  poolAddress: Hex;
-  forkRpc: string;
-  mainnetRpc: string;
-}
-
-export interface SyncPriceResult {
-  token0: Hex;
-  token1: Hex;
-  fee: number;
-  before: { sqrtPriceX96: bigint; balance0: bigint; balance1: bigint };
-  after: { sqrtPriceX96: bigint; balance0: bigint; balance1: bigint };
-}
-
-/**
- * Sync a Uniswap V3 pool's slot0 and token balances from mainnet to a fork.
- */
-export async function syncPrice(options: SyncPriceOptions): Promise<SyncPriceResult> {
-  const { poolAddress, forkRpc, mainnetRpc } = options;
-
-  const mainnetClient = createPublicClient({ transport: http(mainnetRpc) });
-  const forkClient = createPublicClient({ transport: http(forkRpc) });
-
-  // Read pool info
-  const [token0, token1, fee] = (await Promise.all([
-    forkClient.readContract({ address: poolAddress, abi: poolAbi, functionName: "token0" } as any),
-    forkClient.readContract({ address: poolAddress, abi: poolAbi, functionName: "token1" } as any),
-    forkClient.readContract({ address: poolAddress, abi: poolAbi, functionName: "fee" } as any),
-  ])) as [Hex, Hex, number];
-
-  // Read slot0 and balances from both
-  const [_mainnetSlot0, forkSlot0] = (await Promise.all([
-    mainnetClient.readContract({
-      address: poolAddress,
-      abi: poolAbi,
-      functionName: "slot0",
-    } as any),
-    forkClient.readContract({ address: poolAddress, abi: poolAbi, functionName: "slot0" } as any),
-  ])) as [any, any];
-
-  const [mainnetBal0, mainnetBal1, forkBal0, forkBal1] = (await Promise.all([
-    mainnetClient.readContract({
-      address: token0,
-      abi: erc20Abi,
-      functionName: "balanceOf",
-      args: [poolAddress],
-    } as any),
-    mainnetClient.readContract({
-      address: token1,
-      abi: erc20Abi,
-      functionName: "balanceOf",
-      args: [poolAddress],
-    } as any),
-    forkClient.readContract({
-      address: token0,
-      abi: erc20Abi,
-      functionName: "balanceOf",
-      args: [poolAddress],
-    } as any),
-    forkClient.readContract({
-      address: token1,
-      abi: erc20Abi,
-      functionName: "balanceOf",
-      args: [poolAddress],
-    } as any),
-  ])) as [bigint, bigint, bigint, bigint];
-
-  const before = { sqrtPriceX96: forkSlot0[0] as bigint, balance0: forkBal0, balance1: forkBal1 };
-
-  // Sync slot0
-  const mainnetRawSlot0 = (await rpc(mainnetRpc, "eth_getStorageAt", [
-    poolAddress,
-    SLOT0_POSITION,
-    "latest",
-  ])) as Hex;
-  await rpc(forkRpc, "hardhat_setStorageAt", [poolAddress, SLOT0_POSITION, mainnetRawSlot0]);
-
-  // Sync token balances
-  for (const [token, target] of [
-    [token0, mainnetBal0],
-    [token1, mainnetBal1],
-  ] as [Hex, bigint][]) {
-    const slot = await findBalanceSlot(token, poolAddress, forkRpc);
-    if (slot !== null) {
-      await setBalance(token, poolAddress, target, slot, forkRpc);
-    }
-  }
-
-  // Read final state
-  const newSlot0 = (await forkClient.readContract({
-    address: poolAddress,
-    abi: poolAbi,
-    functionName: "slot0",
-  } as any)) as any;
-
-  const [newBal0, newBal1] = (await Promise.all([
-    forkClient.readContract({
-      address: token0,
-      abi: erc20Abi,
-      functionName: "balanceOf",
-      args: [poolAddress],
-    } as any),
-    forkClient.readContract({
-      address: token1,
-      abi: erc20Abi,
-      functionName: "balanceOf",
-      args: [poolAddress],
-    } as any),
-  ])) as [bigint, bigint];
-
-  return {
-    token0,
-    token1,
-    fee,
-    before,
-    after: { sqrtPriceX96: newSlot0[0] as bigint, balance0: newBal0, balance1: newBal1 },
-  };
-}

package/sdk/dist/deployments/v12.generated.d.ts

@@ -1,95 +0,0 @@
-/** CREATE2 salt the stack was deployed with. */
-export declare const V12_SALT: "0x0000000000000000000000000000000000000000000000000000000000000001";
-/** Which tool in the engine repo produced the underlying record. */
-export declare const V12_GENERATED_BY: "dev-tools/scripts/deploy-v12.ts";
-/** @deprecated Legacy EVM addresses. Use v12EngineAddress/v12RouterAddress/v12KitchenAddress. */
-export declare const V12_EVM_CONTRACTS: {
-    readonly router: "0x20BbEc03eE401B26938880cd23Aac00Cf927F06a";
-    readonly v12Runtime: "0x3dfE79fBB6C62D00986F476c3F86E7D19E0cabeD";
-    readonly v12Kitchen: "0xd57b452634c653D80A85160fea895BB07Ac41D8F";
-};
-/** Historical per-chain deploy outcome; does not establish current release liveness. */
-export declare const V12_EVM_CHAINS: {
-    readonly 1: {
-        readonly name: "ethereum";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 10: {
-        readonly name: "optimism";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 56: {
-        readonly name: "bsc";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 130: {
-        readonly name: "unichain";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 137: {
-        readonly name: "polygon";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 143: {
-        readonly name: "monad";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 146: {
-        readonly name: "sonic";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 2020: {
-        readonly name: "ronin";
-        readonly live: false;
-        readonly status: "failed";
-        readonly error: "Contracts deployed with a Solidity version equal or higher than 0.8.20 might not work properly. For more information, please see https://eips.ethereum.org/EIPS/eip-3855 Error: Failed to send transacti";
-    };
-    readonly 8453: {
-        readonly name: "base";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 9745: {
-        readonly name: "plasma";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 42161: {
-        readonly name: "arbitrum";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 42220: {
-        readonly name: "celo";
-        readonly live: true;
-        readonly status: "live";
-    };
-    readonly 57073: {
-        readonly name: "ink";
-        readonly live: true;
-        readonly status: "live";
-    };
-};
-/** @deprecated Historical SVM deployment. Use v12SvmEngineProgramId for the pinned release. */
-export declare const V12_SVM: {
-    readonly programId: "CuHCniNMWLSkZWBQKon9tudGujZeXJRUwG2PCLDq4ipJ";
-    readonly upgradeable: false;
-    readonly clusters: {
-        readonly devnet: {
-            readonly cluster: "devnet";
-            readonly status: "already-deployed";
-        };
-        readonly 'mainnet-beta': {
-            readonly cluster: "mainnet-beta";
-            readonly status: "already-deployed";
-        };
-    };
-};
-//# sourceMappingURL=v12.generated.d.ts.map

package/sdk/dist/deployments/v12.generated.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"v12.generated.d.ts","sourceRoot":"","sources":["../../src/deployments/v12.generated.ts"],"names":[],"mappings":"AAeA,gDAAgD;AAChD,eAAO,MAAM,QAAQ,EAAG,oEAA6E,CAAC;AAEtG,oEAAoE;AACpE,eAAO,MAAM,gBAAgB,EAAG,iCAA0C,CAAC;AAE3E,iGAAiG;AACjG,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAC;AAEX,wFAAwF;AACxF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcjB,CAAC;AAEX,+FAA+F;AAC/F,eAAO,MAAM,OAAO;;;;;;;;;;;;;CAOV,CAAC"}

package/sdk/dist/deployments/v12.generated.js

@@ -1,50 +0,0 @@
-// NOT GENERATED — hand-maintained, and nothing checks it.
-//
-// It was written by sdk/scripts/sync-engine-artifacts.mjs from the engine dep's deployments/v12.json.
-// That dep is gone. **These addresses describe the stack deployed BEFORE the engine became a `cook`
-// argument**: every pinned release now publishes an `addresses.json`, and the Kitchen and Router it
-// names are not these. In particular `v12Runtime` is an interpreter of the older lineage, which is
-// why nothing defaults to it (see routes/sauce-route.ts#SauceEvmExecutionInput.engine).
-//
-// These addresses are chain-invariant — verified identical on every chain they were deployed to —
-// which is why this is one flat address set plus per-chain liveness rather than the same three
-// addresses repeated per chain. (The mechanism is not asserted here: the current stack is CREATE3
-// per `addresses.json`, and the script that produced THIS set is gone. Determinism is the part that
-// matters.) It is also why a stale entry is dangerous rather than merely wrong: a deterministic
-// address resolves on chains where the contract it names was never deployed.
-/** CREATE2 salt the stack was deployed with. */
-export const V12_SALT = '0x0000000000000000000000000000000000000000000000000000000000000001';
-/** Which tool in the engine repo produced the underlying record. */
-export const V12_GENERATED_BY = 'dev-tools/scripts/deploy-v12.ts';
-/** @deprecated Legacy EVM addresses. Use v12EngineAddress/v12RouterAddress/v12KitchenAddress. */
-export const V12_EVM_CONTRACTS = {
-    router: '0x20BbEc03eE401B26938880cd23Aac00Cf927F06a',
-    v12Runtime: '0x3dfE79fBB6C62D00986F476c3F86E7D19E0cabeD',
-    v12Kitchen: '0xd57b452634c653D80A85160fea895BB07Ac41D8F',
-};
-/** Historical per-chain deploy outcome; does not establish current release liveness. */
-export const V12_EVM_CHAINS = {
-    1: { name: 'ethereum', live: true, status: 'live' },
-    10: { name: 'optimism', live: true, status: 'live' },
-    56: { name: 'bsc', live: true, status: 'live' },
-    130: { name: 'unichain', live: true, status: 'live' },
-    137: { name: 'polygon', live: true, status: 'live' },
-    143: { name: 'monad', live: true, status: 'live' },
-    146: { name: 'sonic', live: true, status: 'live' },
-    2020: { name: 'ronin', live: false, status: 'failed', error: 'Contracts deployed with a Solidity version equal or higher than 0.8.20 might not work properly. For more information, please see https://eips.ethereum.org/EIPS/eip-3855 Error: Failed to send transacti' },
-    8453: { name: 'base', live: true, status: 'live' },
-    9745: { name: 'plasma', live: true, status: 'live' },
-    42161: { name: 'arbitrum', live: true, status: 'live' },
-    42220: { name: 'celo', live: true, status: 'live' },
-    57073: { name: 'ink', live: true, status: 'live' },
-};
-/** @deprecated Historical SVM deployment. Use v12SvmEngineProgramId for the pinned release. */
-export const V12_SVM = {
-    programId: 'CuHCniNMWLSkZWBQKon9tudGujZeXJRUwG2PCLDq4ipJ',
-    upgradeable: false,
-    clusters: {
-        'devnet': { cluster: 'devnet', status: 'already-deployed' },
-        'mainnet-beta': { cluster: 'mainnet-beta', status: 'already-deployed' },
-    },
-};
-//# sourceMappingURL=v12.generated.js.map

package/sdk/dist/deployments/v12.generated.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"v12.generated.js","sourceRoot":"","sources":["../../src/deployments/v12.generated.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,EAAE;AACF,sGAAsG;AACtG,oGAAoG;AACpG,oGAAoG;AACpG,mGAAmG;AACnG,wFAAwF;AACxF,EAAE;AACF,kGAAkG;AAClG,+FAA+F;AAC/F,kGAAkG;AAClG,oGAAoG;AACpG,gGAAgG;AAChG,6EAA6E;AAE7E,gDAAgD;AAChD,MAAM,CAAC,MAAM,QAAQ,GAAG,oEAA6E,CAAC;AAEtG,oEAAoE;AACpE,MAAM,CAAC,MAAM,gBAAgB,GAAG,iCAA0C,CAAC;AAE3E,iGAAiG;AACjG,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,MAAM,EAAE,4CAA4C;IACpD,UAAU,EAAE,4CAA4C;IACxD,UAAU,EAAE,4CAA4C;CAChD,CAAC;AAEX,wFAAwF;AACxF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,CAAC,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IACnD,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IACpD,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IAC/C,GAAG,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IACrD,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IACpD,GAAG,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IAClD,GAAG,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IAClD,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,0MAA0M,EAAE;IACzQ,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IAClD,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IACpD,KAAK,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IACvD,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;IACnD,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;CAC1C,CAAC;AAEX,+FAA+F;AAC/F,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,SAAS,EAAE,8CAA8C;IACzD,WAAW,EAAE,KAAK;IAClB,QAAQ,EAAE;QACR,QAAQ,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,kBAAkB,EAAE;QAC3D,cAAc,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,kBAAkB,EAAE;KACxE;CACO,CAAC"}