@black-market/sdk 0.4.0 → 0.5.1

package/examples/launch-lifecycle-smoke.mjs

@@ -0,0 +1,180 @@
+// Deliberately executing proof on an owned disposable loopback fixture only.
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { decodeEventLog, decodeFunctionResult, encodeFunctionData, toHex, zeroHash } from "viem";
+import {
+  buildClaimDeveloperFeesPageTransaction, buildNextTransaction, buildPoolBoundHookDeploymentTransaction,
+  createControlledLifecycleFork, decodeDeveloperClaimReceipt, decodePoolBoundV4LifecycleMarketConfig,
+  encodeLaunchPlan, encodePoolBoundV4LifecycleMarketConfig, hashLaunchIdentity, hashLaunchPlan,
+  launchLifecycleAbi, lifecycleAdapterAbi, lifecycleDirectoryAbi, lifecycleErc20Abi, lifecycleFeeHubAbi,
+  LifecyclePhase, parseLaunchPlan, planLaunch, predictLifecycleToken, preparePoolBoundLifecyclePlan,
+  readAuthorHubs, readDeveloperFees, readLaunchProgress, readLifecycleProfiles, readPoolBoundHookDeployment,
+  simulateLaunchPlan,
+} from "../dist/lifecycle/index.js";
+const [manifestFile, plansFile] = process.argv.slice(2);
+if (!manifestFile || !plansFile) throw new Error("Usage: node examples/launch-lifecycle-smoke.mjs manifest.json sdk-plans.json");
+const manifest = JSON.parse(await readFile(manifestFile, "utf8"));
+const exported = JSON.parse(await readFile(plansFile, "utf8"));
+const rpcUrl = process.env.LAUNCH_LIFECYCLE_RPC_URL;
+const forkRpcUrl = process.env.LAUNCH_LIFECYCLE_FORK_RPC_URL;
+if (!rpcUrl || !forkRpcUrl || !["127.0.0.1", "localhost", "[::1]"].includes(new URL(rpcUrl).hostname) || process.env.LAUNCH_LIFECYCLE_ALLOW_LOCAL_EXECUTION !== "1" || manifest.fixtureOnly !== true) throw new Error("Smoke requires explicitly authorized owned loopback fixture execution and a separate disposable fork");
+if (!Array.isArray(exported.plans) || exported.plans.length === 0) throw new Error("Current Solidity-exported reviewed plans are required");
+let requestId = 0;
+const client = { async request({ method, params = [] }) {
+  const response = await fetch(rpcUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: ++requestId, method, params }) });
+  if (!response.ok) throw new Error(`RPC HTTP ${response.status}`);
+  const body = await response.json();
+  if (body.error) throw Object.assign(new Error(`${method}: ${body.error.message}`), { data: body.error.data });
+  return body.result;
+} };
+const chainId = BigInt(await client.request({ method: "eth_chainId" }));
+assert.equal(chainId, BigInt(manifest.chainId));
+const policy = manifest.executionLimits;
+assert.equal(policy?.provenance?.scope, "controlled-local-measurement", "Operator policy must not invent live RPC/account limits");
+const limits = async ({ block, chainId, account, orchestrator }) => ({
+  chainId, account, orchestrator, observedBlockNumber: block.number, observedBlockHash: block.hash,
+  chainGasLimit: BigInt(policy.chainTransactionGasLimit), rpcGasLimit: BigInt(policy.rpcTransactionGasLimit),
+  accountGasLimit: BigInt(policy.accountTransactionGasLimit), maxCalldataBytes: Number(policy.maxCalldataBytes), headroomBps: Number(policy.headroomBps),
+});
+const fork = createControlledLifecycleFork({ sourceRpcUrl: rpcUrl, forkRpcUrl, allowTransactions: true, impersonation: "anvil" });
+async function readContract(to, abi, functionName, args = []) {
+  return decodeFunctionResult({ abi, functionName, data: await client.request({ method: "eth_call", params: [{ to, data: encodeFunctionData({ abi, functionName, args }) }, "latest"] }) });
+}
+async function send(transaction) {
+  assert.equal(BigInt(transaction.chainId), chainId);
+  const gasPrice = transaction.gasPrice ?? BigInt(await client.request({ method: "eth_gasPrice" }));
+  const head = await client.request({ method: "eth_getBlockByNumber", params: ["latest", false] });
+  const ceiling = [BigInt(head.gasLimit), BigInt(policy.chainTransactionGasLimit), BigInt(policy.rpcTransactionGasLimit), BigInt(policy.accountTransactionGasLimit)].reduce((a, b) => a < b ? a : b);
+  const wire = { from: transaction.from, to: transaction.to, data: transaction.data, value: toHex(transaction.value), gasPrice: toHex(gasPrice) };
+  const estimated = transaction.gas ?? ((BigInt(await client.request({ method: "eth_estimateGas", params: [{ ...wire, gas: toHex(ceiling) }] })) * BigInt(10000 + Number(policy.headroomBps)) + 9999n) / 10000n);
+  assert.ok(estimated <= ceiling, "Unsigned helper must still fit explicit local execution admission");
+  const transactionHash = await client.request({ method: "eth_sendTransaction", params: [{ ...wire, gas: toHex(estimated) }] });
+  let receipt;
+  for (const deadline = Date.now() + 30000; Date.now() < deadline;) {
+    receipt = await client.request({ method: "eth_getTransactionReceipt", params: [transactionHash] });
+    if (receipt) break;
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  assert.equal(receipt?.status, "0x1", `Actual local transaction must succeed: ${transactionHash}`);
+  return { receipt, reference: { transactionHash, observedBlockNumber: BigInt(receipt.blockNumber), observedBlockHash: receipt.blockHash, confirmations: 1 } };
+}
+function events(receipt, address, abi, name) {
+  return receipt.logs.filter((log) => log.address.toLowerCase() === address.toLowerCase()).flatMap((log) => {
+    try { const decoded = decodeEventLog({ abi, data: log.data, topics: log.topics, strict: true }); return decoded.eventName === name ? [decoded.args] : []; } catch { return []; }
+  });
+}
+const profiles = await readLifecycleProfiles({ client, orchestrator: manifest.addresses.orchestrator });
+for (const row of exported.plans) for (const market of parseLaunchPlan(JSON.stringify(row.plan)).markets) {
+  const profile = profiles.find((profile) => profile.id.toLowerCase() === market.profileId.toLowerCase());
+  assert.equal(profile?.admitted, true, profile?.reason);
+}
+const results = [];
+for (const row of exported.plans) for (const mode of ["atomic", "staged"]) {
+  const snapshot = await client.request({ method: "evm_snapshot" });
+  try {
+    let plan = parseLaunchPlan(JSON.stringify(row.plan));
+    assert.equal(encodeLaunchPlan(plan).toLowerCase(), row.encodedPlan.toLowerCase());
+    assert.equal(hashLaunchPlan(plan).toLowerCase(), row.planHash.toLowerCase());
+    assert.equal(hashLaunchIdentity(plan).toLowerCase(), row.launchId.toLowerCase());
+    assert.equal((await predictLifecycleToken({ client, plan })).toLowerCase(), row.predictedToken.toLowerCase());
+    const draft = { ...plan, markets: plan.markets.map((market) => market.configVersion === 5 ? {
+      ...market, config: encodePoolBoundV4LifecycleMarketConfig({ ...decodePoolBoundV4LifecycleMarketConfig(market.config), hookSalt: zeroHash }),
+    } : market) };
+    const prepared = await preparePoolBoundLifecyclePlan({ client, plan: draft });
+    plan = prepared.plan;
+    assert.equal(hashLaunchPlan(plan).toLowerCase(), row.planHash.toLowerCase(), "Offchain mining reproduces the independent constructor/salt vector");
+    if (mode === "staged") for (const deployment of prepared.deployments) {
+      const unsigned = await buildPoolBoundHookDeploymentTransaction({ client, plan, marketIndex: deployment.marketIndex });
+      await send({ chainId: Number(chainId), from: plan.creator, ...unsigned });
+      const actual = await readPoolBoundHookDeployment({ client, plan, marketIndex: deployment.marketIndex });
+      assert.equal(actual.predictedHook.toLowerCase(), deployment.predictedHook.toLowerCase());
+    }
+    const planned = await planLaunch({ client, account: plan.creator, plan, mode, limits, fork });
+    assert.equal(planned.simulation.admitted, true, planned.simulation.reason);
+    const atomicReceipt = planned.atomicAttempt.steps.find((step) => step.transactionId === "atomic")?.returnData;
+    if (atomicReceipt) {
+      const decoded = decodeFunctionResult({ abi: launchLifecycleAbi, functionName: "launchAtomic", data: atomicReceipt });
+      assert.equal(decoded.planHash.toLowerCase(), planned.planHash.toLowerCase());
+      for (let i = 0; i < plan.buys.length; ++i) assert.ok(decoded.tokenOut[i] >= plan.buys[i].minTokenOut);
+    }
+    const replay = await simulateLaunchPlan({ client, planned, limits, fork });
+    assert.equal(replay.admitted, true, replay.reason);
+    const receipts = [];
+    let activationReceipt;
+    for (let guard = 0; guard < 64; ++guard) {
+      const next = await buildNextTransaction({ client, planned, receipts, limits, fork });
+      if (!next) break;
+      const submitted = await send(next);
+      receipts.push(submitted.reference);
+      if (["atomic", "activate"].includes(next.kind)) activationReceipt = submitted.receipt;
+    }
+    const progress = await readLaunchProgress({ client, planned, receipts });
+    assert.equal(progress.canonical.phase, LifecyclePhase.Active);
+    assert.equal(progress.token.toLowerCase(), row.predictedToken.toLowerCase());
+    assert.equal(progress.canonical.marketCount, plan.markets.length);
+    const buys = events(activationReceipt, plan.orchestrator, launchLifecycleAbi, "InitialBuyExecuted");
+    assert.equal(buys.length, plan.buys.length);
+    for (let i = 0; i < buys.length; ++i) {
+      assert.equal(buys[i].buyIndex, i); assert.equal(buys[i].marketIndex, plan.buys[i].marketIndex);
+      assert.ok(buys[i].tokenOut >= plan.buys[i].minTokenOut); assert.ok(buys[i].quoteSpent <= plan.buys[i].quoteAmountIn);
+    }
+    const directory = await readContract(plan.orchestrator, launchLifecycleAbi, "directory");
+    for (const market of progress.markets) {
+      assert.equal(market.live.publicTrading, true);
+      const positions = await readContract(directory, lifecycleDirectoryAbi, "positions", [planned.launchId, market.index, 0n, 32n]);
+      const profile = profiles.find((profile) => profile.id.toLowerCase() === market.prepared.identity.profileId.toLowerCase());
+      for (const position of positions) {
+        const [liquidity, custody] = await readContract(profile.adapter.implementation, lifecycleAdapterAbi, "readPosition", [position]);
+        assert.equal(liquidity, position.liquidity); assert.equal(custody.toLowerCase(), market.prepared.custody.toLowerCase());
+      }
+    }
+    assert.equal(await buildNextTransaction({ client, planned, receipts, limits, fork }), undefined);
+    const hub = progress.canonical.feeHub;
+    assert.equal(await readContract(hub, lifecycleFeeHubAbi, "economicVersion"), 3);
+    const authors = new Map();
+    for (const source of await readContract(hub, lifecycleFeeHubAbi, "sources")) {
+      const terms = await readContract(hub, lifecycleFeeHubAbi, "sourceTerms", [source]);
+      if (terms.developerFeeBps > 0) authors.set(terms.beneficiary.toLowerCase(), terms.beneficiary);
+    }
+    const ownerBefore = await Promise.all(plan.feeAssets.map((policy) => readContract(hub, lifecycleFeeHubAbi, "claimableOwnerFees", [plan.creator, policy.asset])));
+    const harvestData = encodeFunctionData({ abi: lifecycleFeeHubAbi, functionName: "claimAndSplit", args: [] });
+    const preview = decodeFunctionResult({ abi: lifecycleFeeHubAbi, functionName: "claimAndSplit", data: await client.request({ method: "eth_call", params: [{ from: plan.creator, to: hub, data: harvestData }, "latest"] }) });
+    const harvest = await send({ chainId: Number(chainId), from: plan.creator, to: hub, data: harvestData, value: 0n });
+    const distributions = events(harvest.receipt, hub, lifecycleFeeHubAbi, "Distributed");
+    assert.ok(distributions.some((event) => event.newlyCollected > 0n), "Real opening swaps produce actual source fees");
+    for (let i = 0; i < plan.feeAssets.length; ++i) {
+      const policy = plan.feeAssets[i];
+      const distribution = distributions.find((event) => event.asset.toLowerCase() === policy.asset.toLowerCase());
+      assert.equal(distribution.ownerAmount + distribution.developerAmount + distribution.executorAmount + distribution.rewardsAmount + distribution.burnAmount, distribution.newlyCollected);
+      assert.equal(preview.find((payment) => payment.asset.toLowerCase() === policy.asset.toLowerCase()).amount, distribution.executorAmount);
+      assert.equal(await readContract(hub, lifecycleFeeHubAbi, "claimableOwnerFees", [plan.creator, policy.asset]) - ownerBefore[i], distribution.ownerAmount);
+      assert.equal(await readContract(policy.asset, lifecycleErc20Abi, "balanceOf", [hub]),
+        await readContract(hub, lifecycleFeeHubAbi, "reservedOwnerFees", [policy.asset]) + await readContract(hub, lifecycleFeeHubAbi, "reservedDeveloperFees", [policy.asset]));
+    }
+    const claims = [];
+    for (const authorId of authors.values()) {
+      const discovered = await readAuthorHubs({ client, registry: manifest.addresses.implementationRegistry, authorId });
+      assert.ok(discovered.hubs.some((value) => value.toLowerCase() === hub.toLowerCase()));
+      const fees = await readDeveloperFees({ client, registry: discovered.registry, authorId, hub });
+      const balancesBefore = await Promise.all(fees.assets.map((asset) => readContract(asset, lifecycleErc20Abi, "balanceOf", [fees.payout])));
+      const unsigned = await buildClaimDeveloperFeesPageTransaction({ client, registry: discovered.registry, authorId, offset: 0n, limit: 10n, assets: [], account: plan.creator, chainId });
+      // Bound every page child call with the explicit owned-fixture operator ceiling;
+      // eth_estimateGas may otherwise succeed after reporting gas-starved failed rows.
+      const head = await client.request({ method: "eth_getBlockByNumber", params: ["latest", false] });
+      const pageGas = [BigInt(head.gasLimit), BigInt(policy.chainTransactionGasLimit), BigInt(policy.rpcTransactionGasLimit), BigInt(policy.accountTransactionGasLimit)].reduce((a, b) => a < b ? a : b);
+      const claim = await send({ ...unsigned, gas: pageGas });
+      const result = decodeDeveloperClaimReceipt({ receipt: claim.receipt, transaction: unsigned });
+      assert.equal(result.cursorComplete, true); assert.equal(result.paymentsSucceeded, true);
+      for (let i = 0; i < fees.assets.length; ++i) {
+        const amount = result.results.filter((row) => row.asset.toLowerCase() === fees.assets[i].toLowerCase()).reduce((total, row) => total + row.amount, 0n);
+        assert.equal(await readContract(fees.assets[i], lifecycleErc20Abi, "balanceOf", [fees.payout]) - balancesBefore[i], amount);
+      }
+      claims.push({ authorId, transactionHash: claim.reference.transactionHash, result });
+    }
+    results.push({ name: row.name, mode, phase: "Active", planHash: planned.planHash, token: progress.token, backend: replay.backend, receipts, buys, distributions, claims });
+  } finally {
+    assert.equal(await client.request({ method: "evm_revert", params: [snapshot] }), true);
+    await client.request({ method: "evm_mine" });
+  }
+}
+console.log(JSON.stringify({ schema: "black-market.node-sdk-smoke.v1", results }, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2));

package/examples/launch.mjs

@@ -0,0 +1,38 @@
+// Reviewed launch planning only: no signatures, source-chain writes, uploads or publication.
+import { readFile } from "node:fs/promises";
+import { createPublicClient, http } from "viem";
+import {
+  buildNextTransaction, createControlledLifecycleFork, parseLaunchPlan, planLaunch,
+  preparePoolBoundLifecyclePlan, readLaunchProgress, readLifecycleProfiles, serializeLaunchPlan,
+} from "../dist/index.js";
+const args = process.argv.slice(2);
+const option = (name) => { const index = args.indexOf(name); return index === -1 ? undefined : args[index + 1]; };
+const planFile = option("--plan"), rpcUrl = option("--rpc"), mode = option("--mode");
+if (!planFile || !rpcUrl || !["atomic", "staged"].includes(mode)) {
+  throw new Error("Usage: node examples/launch.mjs --plan plan.json --rpc RPC_URL --mode atomic|staged [--limits current-limits.json] [--receipts receipts.json] [--confirmations N] [--fork-rpc LOOPBACK_RPC_URL] [--mine]");
+}
+const client = createPublicClient({ transport: http(rpcUrl) });
+let plan = parseLaunchPlan(await readFile(planFile, "utf8"));
+const profiles = await readLifecycleProfiles({ client, orchestrator: plan.orchestrator, profileIds: [...new Set(plan.markets.map((market) => market.profileId))] });
+for (const profile of profiles) console.log(profile.id, profile.venueKind, profile.topology, profile.admitted ? "admitted" : profile.reason);
+if (args.includes("--mine")) plan = (await preparePoolBoundLifecyclePlan({ client, plan,
+  onProgress: ({ marketIndex, attempts }) => console.error("salt mining", marketIndex, attempts.toString()),
+})).plan;
+const limitsFile = option("--limits");
+const limits = limitsFile ? JSON.parse(await readFile(limitsFile, "utf8")) : undefined;
+if (limits) for (const key of ["chainId", "observedBlockNumber", "chainGasLimit", "rpcGasLimit", "accountGasLimit", "maxSimulationGas"]) {
+  if (limits[key] !== undefined) limits[key] = BigInt(limits[key]);
+}
+const receiptsFile = option("--receipts");
+const receipts = receiptsFile ? JSON.parse(await readFile(receiptsFile, "utf8"), (key, value) => key === "observedBlockNumber" ? BigInt(value) : value) : [];
+const confirmations = Number(option("--confirmations") ?? "1");
+const forkRpcUrl = option("--fork-rpc");
+const fork = forkRpcUrl ? createControlledLifecycleFork({ sourceRpcUrl: rpcUrl, forkRpcUrl, allowTransactions: true, impersonation: "anvil" }) : undefined;
+const planned = await planLaunch({ client, account: plan.creator, plan, mode, limits, fork, receipts, confirmations });
+const progress = await readLaunchProgress({ client, planned, receipts });
+const next = planned.simulation.admitted ? await buildNextTransaction({ client, planned, limits, fork, receipts }) : undefined;
+console.log(JSON.stringify({ plan: JSON.parse(serializeLaunchPlan(plan)), mode,
+  simulation: planned.simulation, atomicAttempt: planned.atomicAttempt, progress, next },
+  (_key, value) => typeof value === "bigint" ? value.toString() : value, 2));
+// Persist the returned plan/mode/confirmation policy and receipt references. An application
+// must separately review, authenticate its wallet chain and sign exactly `next` if admitted.

package/examples/quickstart.mjs

@@ -0,0 +1,37 @@
+// Read-only deployed graph discovery. No signatures, transactions, uploads, or publication.
+import { zeroAddress } from "viem";
+import {
+  createProtocolPublicClient, getAddresses, isSupportedChainId,
+  launchLifecycleAbi, readLifecycleProfiles,
+} from "../dist/index.js";
+
+const chainId = Number(process.env.CHAIN_ID ?? "4663");
+if (!isSupportedChainId(chainId)) throw new Error("CHAIN_ID must be 4663, 46631, or 31337");
+const infrastructure = getAddresses(chainId);
+if (infrastructure.launchOrchestrator === zeroAddress) {
+  throw new Error("Set LAUNCH_ORCHESTRATOR and the matching deployment addresses for this local chain; no mainnet launch address is assumed locally.");
+}
+const client = createProtocolPublicClient({ chainId });
+if (await client.getChainId() !== chainId) throw new Error("RPC chain ID differs from CHAIN_ID");
+const registry = await client.readContract({
+  address: infrastructure.launchOrchestrator,
+  abi: launchLifecycleAbi,
+  functionName: "registry",
+});
+if (registry.toLowerCase() !== infrastructure.launchImplementationRegistry.toLowerCase()) {
+  throw new Error("The selected orchestrator and LAUNCH_IMPLEMENTATION_REGISTRY are not the same deployment graph");
+}
+const profiles = await readLifecycleProfiles({ client, orchestrator: infrastructure.launchOrchestrator });
+console.log("chain:", chainId);
+console.log("orchestrator:", infrastructure.launchOrchestrator);
+console.log("registry:", registry);
+console.table(profiles.map((profile) => ({
+  profile: profile.id,
+  venue: profile.venueKind,
+  configVersion: profile.topology.configVersion,
+  admitted: profile.admitted,
+  reason: profile.reason ?? "",
+})));
+console.log("Abyss router:", infrastructure.abyssRouter);
+console.log("lending pool:", infrastructure.lendingPool);
+if (!profiles.some((profile) => profile.admitted)) throw new Error("No current profile was admitted by the selected deployment");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@black-market/sdk",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Canonical TypeScript SDK for Black Market on Robinhood Chain (reviewed multi-market launches, Abyss DEX, lending).",
   "license": "MIT",
   "repository": {
@@ -23,7 +23,9 @@
   "files": [
     "dist",
     "src",
-    "docs"
+    "docs",
+    "assets",
+    "examples"
   ],
   "sideEffects": false,
   "engines": {
@@ -40,7 +42,10 @@
     "examples": "pnpm build && node examples/quickstart.mjs",
     "lint": "tsc -p tsconfig.json --noEmit",
     "prepublishOnly": "pnpm build",
-    "test": "pnpm build && node --test test/*.test.mjs",
+    "test": "pnpm test:unit",
+    "test:unit": "pnpm build && node --test test/*.test.mjs",
+    "test:api": "pnpm build && node --test test/integration/launch-api.read.test.mjs",
+    "test:api:write": "pnpm build && node --test test/integration/launch-api.sessions.test.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {

package/src/addresses.ts

@@ -20,7 +20,7 @@ export type AbyssInfrastructureAddresses = {
 };
 
 export type LaunchApplicationAddresses = {
-  /** No reviewed deployment is selected implicitly; set these from exact deployment evidence. */
+  /** Mined mainnet deployment; local chains require explicit environment configuration. */
   launchOrchestrator: Address;
   launchImplementationRegistry: Address;
   launchFeeOwnerRegistry: Address;
@@ -177,19 +177,26 @@ export const robinhoodAbyssInfrastructure: AbyssInfrastructureAddresses = {
   abyssFeeRouter: "0x2c3B1b6fe0EDa8e10C0445567b47e66E825B34cd",
 };
 
+/** Mined pool-launch-v1 deployment, 20261005T053747Z-b5a7b88 (manifest.json). */
+export const robinhoodLaunchApplication: LaunchApplicationAddresses = {
+  launchOrchestrator: "0xb75CBD17b9aecb7305B4DFcDa69595F783341c0E",
+  launchImplementationRegistry: "0xaa8a410709B79cBA6F118F1be1FF568877A3B8Ee",
+  launchFeeOwnerRegistry: "0x15778Aad08e12D458B2848F035860e2a8c2a0725",
+};
+
 
-/** Workbench deployment snapshot — override via env when redeploying. */
+/** Robinhood-mainnet fork lending defaults; launch deployment remains explicit. */
 const workbenchDefaults: ProtocolAddresses = {
   ...robinhoodAbyssInfrastructure,
   ...launchApplicationFromEnv(zeroLaunchApplication),
-  lendingPool: "0xe1576c5CF12F670911BEd5Cc0AEDBcD4E5E9550c",
-  addressesProvider: "0x9Fcca440F19c62CDF7f973eB6DDF218B15d4C71D",
-  dataProvider: "0x79E8AB29Ff79805025c9462a2f2F12e9A496f81d",
+  lendingPool: "0x5D8878b145904425C598f12EB8eD550985369a82",
+  addressesProvider: "0x892faB533E8D04135D902F94974e45dB48C17697",
+  dataProvider: "0x1f3faA42C1D5cC330f6BD0242B9a56d611bdC78a",
   uiPoolDataProvider: zero,
   walletBalanceProvider: zero,
-  aaveOracle: "0x9c65f85425c619A6cB6D29fF8d57ef696323d188",
+  aaveOracle: "0x6837B3cF5d959d01e07bf6DaB53f562877BF7d53",
   liquidationExecutor: zero,
-  protocolVault: "0xAe120F0df055428E45b264E7794A18c54a2a3fAF",
+  protocolVault: "0x83Ec5DbFEd6d972be89df88d3654EA2c70Fa2FB3",
   ethUsdFeed: ROBINHOOD_ETH_USD,
   weth: ROBINHOOD_WETH,
   wethGateway: zero,
@@ -233,26 +240,26 @@ export const addresses: Record<SupportedChainId, ProtocolAddresses> = {
     tokenVesting: envAddr(["TOKEN_VESTING", "VITE_TOKEN_VESTING", "NEXT_PUBLIC_TOKEN_VESTING"]),
     faucet: envAddr(["FAUCET", "VITE_FAUCET", "NEXT_PUBLIC_FAUCET"]),
   },
-  /** Lending/DEX defaults remain canonical; reviewed launches require explicit evidence. */
+  /** Current mined launch, canonical Abyss, and replacement lending infrastructure. */
   4663: {
     ...robinhoodAbyssInfrastructure,
-    ...launchApplicationFromEnv(zeroLaunchApplication),
-    lendingPool: "0x5b8F732A4F7a62D642070bb49255d6C434A76766",
-    addressesProvider: "0xaaD329d0Da03C8c00E8460b5b208D0A21A48C9df",
-    dataProvider: "0x3B097A7899DF433552B8428E774964661b53C193",
-    uiPoolDataProvider: "0x2F35A64c7E7cBc0c05A1A1C3e2F3952E103fD5b8",
-    walletBalanceProvider: "0x833BB152212DD5d2d6C7b0501aB38efb9602AD8B",
-    aaveOracle: "0xb9441f8D3Eda65Ac7cbb6b542b5345c98067e5Fb",
+    ...launchApplicationFromEnv(robinhoodLaunchApplication),
+    lendingPool: "0x5D8878b145904425C598f12EB8eD550985369a82",
+    addressesProvider: "0x892faB533E8D04135D902F94974e45dB48C17697",
+    dataProvider: "0x1f3faA42C1D5cC330f6BD0242B9a56d611bdC78a",
+    uiPoolDataProvider: "0x02D2CA3bBbBaBD3C25bEDD4bE0eE6E5885C4D152",
+    walletBalanceProvider: "0xBbb5D81123C3d514456974e9Fe6C7C8d7a0E4E2A",
+    aaveOracle: "0x6837B3cF5d959d01e07bf6DaB53f562877BF7d53",
     liquidationExecutor: envAddr([
       "LIQUIDATION_EXECUTOR",
       "VITE_LIQUIDATION_EXECUTOR",
       "NEXT_PUBLIC_LIQUIDATION_EXECUTOR",
     ]),
-    protocolVault: "0x961981916AB6575C3af3eeCecbf6A3b7Fad7C9e1",
+    protocolVault: "0x83Ec5DbFEd6d972be89df88d3654EA2c70Fa2FB3",
     ethUsdFeed: ROBINHOOD_ETH_USD,
     weth: ROBINHOOD_WETH,
-    wethGateway: "0xAbc9E3B20e8773536BDCa5ba28C619762C8e0570",
-    lens: "0x82FA6e601F48d64b4f163Eb47D6001f2d5040f9B",
+    wethGateway: "0xa16aB7646267327cB26dD3533526309cDe676d9d",
+    lens: "0xB56079f966597CB9edaE27c589F8190f4dCD12df",
     tokenVesting: zero,
     faucet: zero,
   },

package/src/client.ts

@@ -20,7 +20,7 @@ export function createProtocolPublicClient(opts?: {
 }): PublicClient {
   const chainId = opts?.chainId ?? 31337;
   const chain = chains[chainId] ?? foundry;
-  const transport = http(opts?.rpcUrl ?? process.env.RPC_URL ?? "http://127.0.0.1:8545");
+  const transport = http(opts?.rpcUrl ?? process.env.RPC_URL ?? chain.rpcUrls.default.http[0]);
   return createPublicClient({ chain, transport });
 }
 
@@ -31,7 +31,7 @@ export function createProtocolWalletClient(opts: {
 }): WalletClient {
   const chainId = opts.chainId ?? 31337;
   const chain: Chain = chains[chainId] ?? foundry;
-  const transport: Transport = http(opts.rpcUrl ?? process.env.RPC_URL ?? "http://127.0.0.1:8545");
+  const transport: Transport = http(opts.rpcUrl ?? process.env.RPC_URL ?? chain.rpcUrls.default.http[0]);
   const account: Account = privateKeyToAccount(opts.privateKey);
   return createWalletClient({ account, chain, transport });
 }

package/src/launch-api.ts

@@ -14,7 +14,7 @@ export type LaunchAttributionAuthorization = { nonce: Hex; deadline: string; sig
 export type LaunchSessionCreateRequest = { chainId: number; wallet: Address; metadata: LaunchSessionCreateMetadata; image?: LaunchSessionImageDescriptor; authorization: LaunchAttributionAuthorization };
 export type LaunchSessionPublishRequest = { chainId: number; transactionHash: Hash };
 export type LaunchSessionStatus = "awaiting_upload" | "verifying_image" | "ready_to_launch" | "transaction_submitted" | "awaiting_indexer" | "optimistic" | "final" | "reorged" | "expired" | "rejected";
-export type LaunchSessionDirectUpload = { url: string; headers: Record<string, string>; expiresAt: string };
+export type LaunchSessionDirectUpload = { url: string; method: "PUT"; headers: Record<string, string>; expiresInSeconds: number };
 export type LaunchSessionResponse = { sessionId: string; chainId: number; wallet: Address; status: LaunchSessionStatus; metadata: { name: string; symbol: string; description: string | null; websiteUrl: string | null; twitterUrl: string | null; telegramUrl: string | null; discordUrl: string | null }; image: { sha256: Hex; contentType: LaunchImageContentType; contentLength: number; width: number | null; height: number | null } | null; transactionHash?: Hash | null; token?: Address | null; canonicalStatus: "pending" | "optimistic" | "final" | "reorged"; metadataStatus: "queued" | "ready" | "needs_owner_action" | "none"; imageStatus: "none" | "upload_pending" | "verifying" | "ready" | "rejected"; retryable: boolean; createdAt: string; updatedAt: string; sessionExpiresAt: string; publishedAt?: string; upload?: LaunchSessionDirectUpload; capability?: string; imageUrl?: string };
 export type LaunchApiErrorCode = "INVALID_REQUEST" | "INVALID_ADDRESS" | "INVALID_IDEMPOTENCY_KEY" | "INVALID_CAPABILITY" | "UNSUPPORTED_CHAIN" | "NOT_FOUND" | "IMAGE_INVALID" | "SESSION_STATE_CONFLICT" | "SESSION_EXPIRED" | "IDEMPOTENCY_CONFLICT" | "UPLOAD_CONFLICT" | "RATE_LIMITED" | "OVERLOADED" | "RPC_UNAVAILABLE" | "RPC_TIMEOUT" | "INDEXER_UNAVAILABLE" | "APP_STORAGE_UNAVAILABLE" | "IMAGE_STORAGE_UNAVAILABLE" | "TX_REVERTED" | "TX_PROVENANCE_MISMATCH" | "TX_METADATA_MISMATCH" | (string & {});
 
@@ -102,7 +102,8 @@ export const launchAttributionTypes = { LaunchAttribution: [
   { name: "idempotencyKey", type: "string" }, { name: "nonce", type: "bytes32" }, { name: "deadline", type: "uint256" },
 ] } as const;
 export function canonicalLaunchMetadataHash(metadata: LaunchSessionMetadata): Hex {
-  return keccak256(stringToHex(JSON.stringify({ name: metadata.name.normalize("NFC").trim(), symbol: metadata.symbol.normalize("NFC").trim(), description: (metadata.description ?? "").normalize("NFC").trim(), websiteUrl: metadata.websiteUrl ?? null, twitterUrl: metadata.twitterUrl ?? null, telegramUrl: metadata.telegramUrl ?? null, discordUrl: metadata.discordUrl ?? null, imageKey: metadata.imageKey ?? null })));
+  const url = (value: string | undefined) => value === undefined ? null : new URL(value.normalize("NFC").trim()).toString();
+  return keccak256(stringToHex(JSON.stringify({ name: metadata.name.normalize("NFC").trim(), symbol: metadata.symbol.normalize("NFC").trim(), description: (metadata.description ?? "").normalize("NFC").trim(), websiteUrl: url(metadata.websiteUrl), twitterUrl: url(metadata.twitterUrl), telegramUrl: url(metadata.telegramUrl), discordUrl: url(metadata.discordUrl), imageKey: metadata.imageKey ?? null })));
 }
 export async function sha256Hex(bytes: ArrayBuffer): Promise<Hex> {
   const digest = await crypto.subtle.digest("SHA-256", bytes);

package/src/lifecycle/abi.ts

@@ -119,7 +119,6 @@ const v4AdapterMetadataAbi = [
   { type: "function", name: "CONFIG_VERSION", stateMutability: "view", inputs: [], outputs: [{ type: "uint32" }] },
   { type: "function", name: "implementationRegistry", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
   { type: "function", name: "poolManager", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
-  { type: "function", name: "hookRoot", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
   { type: "function", name: "oracleFactory", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
   { type: "function", name: "locker", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
   { type: "function", name: "collectorFactory", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
@@ -127,6 +126,7 @@ const v4AdapterMetadataAbi = [
 ] as const;
 export const sharedMarketAdapterV1Abi = [
   ...v4AdapterMetadataAbi,
+  { type: "function", name: "hookRoot", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
   { type: "constructor", stateMutability: "nonpayable", inputs: [
     { name: "core_", type: "address" }, { name: "manager_", type: "address" }, { name: "root_", type: "address" },
     { name: "locker_", type: "address" }, { name: "helper_", type: "address" }, { name: "registry_", type: "address" },
@@ -142,6 +142,7 @@ export const abyssLifecycleAdapterAbi = [
 ] as const;
 export const poolMarketAdapterV1Abi = [
   ...v4AdapterMetadataAbi,
+  { type: "function", name: "hookRoot", stateMutability: "pure", inputs: [], outputs: [{ type: "address" }] },
   { type: "constructor", stateMutability: "nonpayable", inputs: [
     { name: "core_", type: "address" }, { name: "manager_", type: "address" }, { name: "oracleFactory_", type: "address" },
     { name: "locker_", type: "address" }, { name: "deployer_", type: "address" }, { name: "helper_", type: "address" },
@@ -205,17 +206,78 @@ export const lifecycleV4HookAbi = [
   { type: "function", name: "pendingFees", stateMutability: "view", inputs: [{ type: "bytes32" }, { type: "address" }], outputs: [{ type: "uint256" }] },
   { type: "function", name: "settledFees", stateMutability: "view", inputs: [{ type: "bytes32" }, { type: "address" }], outputs: [{ type: "uint256" }] },
 ] as const;
-export const poolBoundLaunchFeeHookV1Abi = [
-  ...lifecycleV4HookAbi,
-  { type: "constructor", stateMutability: "nonpayable", inputs: [boundParametersInput] },
-  { type: "function", name: "boundPoolId", stateMutability: "view", inputs: [], outputs: [{ type: "bytes32" }] },
-  { type: "function", name: "deploymentConfigHash", stateMutability: "view", inputs: [], outputs: [{ type: "bytes32" }] },
-  { type: "function", name: "marketCommitment", stateMutability: "view", inputs: [], outputs: [{ type: "bytes32" }] },
-  { type: "function", name: "core", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
-  { type: "function", name: "liquidityLocker", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
-  { type: "function", name: "token", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
-  { type: "function", name: "openingSqrtPriceX96", stateMutability: "view", inputs: [], outputs: [{ type: "uint160" }] },
-  { type: "function", name: "expectedPositionCount", stateMutability: "view", inputs: [], outputs: [{ type: "uint32" }] },
+/** Complete mined FixedFeePoolHookV1 ABI (pool-launch-v1, 20261005T053747Z-b5a7b88).
+ * Compiler-only internalType annotations are omitted; the constructor is one 18-field tuple. */
+export const fixedFeePoolHookV1Abi = [
+  { type: "constructor", inputs: [boundParametersInput], stateMutability: "nonpayable" },
+  { type: "function", name: "ALL_HOOK_MASK", inputs: [], outputs: [{ name: "", type: "uint160" }], stateMutability: "view" },
+  { type: "function", name: "MAX_ORACLE_CARDINALITY", inputs: [], outputs: [{ name: "", type: "uint16" }], stateMutability: "view" },
+  { type: "function", name: "PIPS_DENOMINATOR", inputs: [], outputs: [{ name: "", type: "uint24" }], stateMutability: "view" },
+  { type: "function", name: "REQUIRED_HOOK_FLAGS", inputs: [], outputs: [{ name: "", type: "uint160" }], stateMutability: "view" },
+  { type: "function", name: "afterDonate", inputs: [{ name: "", type: "address" }, { name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "", type: "uint256" }, { name: "", type: "uint256" }, { name: "", type: "bytes" }], outputs: [{ name: "", type: "bytes4" }], stateMutability: "nonpayable" },
+  { type: "function", name: "afterInitialize", inputs: [{ name: "sender", type: "address" }, { name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "sqrtPriceX96", type: "uint160" }, { name: "tick", type: "int24" }], outputs: [{ name: "", type: "bytes4" }], stateMutability: "nonpayable" },
+  { type: "function", name: "afterSwap", inputs: [{ name: "", type: "address" }, { name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "params", type: "tuple", components: [{ name: "zeroForOne", type: "bool" }, { name: "amountSpecified", type: "int256" }, { name: "sqrtPriceLimitX96", type: "uint160" }] }, { name: "delta", type: "int256" }, { name: "", type: "bytes" }], outputs: [{ name: "", type: "bytes4" }, { name: "", type: "int128" }], stateMutability: "nonpayable" },
+  { type: "function", name: "aggregateLiabilities", inputs: [{ name: "asset", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "aggregateManagerClaims", inputs: [{ name: "asset", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "beforeAddLiquidity", inputs: [{ name: "sender", type: "address" }, { name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "params", type: "tuple", components: [{ name: "tickLower", type: "int24" }, { name: "tickUpper", type: "int24" }, { name: "liquidityDelta", type: "int256" }, { name: "salt", type: "bytes32" }] }, { name: "", type: "bytes" }], outputs: [{ name: "", type: "bytes4" }], stateMutability: "nonpayable" },
+  { type: "function", name: "beforeDonate", inputs: [{ name: "", type: "address" }, { name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "amount0", type: "uint256" }, { name: "amount1", type: "uint256" }, { name: "", type: "bytes" }], outputs: [{ name: "", type: "bytes4" }], stateMutability: "nonpayable" },
+  { type: "function", name: "beforeRemoveLiquidity", inputs: [{ name: "sender", type: "address" }, { name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "params", type: "tuple", components: [{ name: "tickLower", type: "int24" }, { name: "tickUpper", type: "int24" }, { name: "liquidityDelta", type: "int256" }, { name: "salt", type: "bytes32" }] }, { name: "", type: "bytes" }], outputs: [{ name: "", type: "bytes4" }], stateMutability: "nonpayable" },
+  { type: "function", name: "beforeSwap", inputs: [{ name: "", type: "address" }, { name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "params", type: "tuple", components: [{ name: "zeroForOne", type: "bool" }, { name: "amountSpecified", type: "int256" }, { name: "sqrtPriceLimitX96", type: "uint160" }] }, { name: "", type: "bytes" }], outputs: [{ name: "", type: "bytes4" }, { name: "", type: "int256" }, { name: "", type: "uint24" }], stateMutability: "nonpayable" },
+  { type: "function", name: "boundPoolId", inputs: [], outputs: [{ name: "", type: "bytes32" }], stateMutability: "view" },
+  { type: "function", name: "collectFees", inputs: [{ name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }], outputs: [{ name: "amount0", type: "uint256" }, { name: "amount1", type: "uint256" }], stateMutability: "nonpayable" },
+  { type: "function", name: "completePoolOpening", inputs: [{ name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "core", inputs: [], outputs: [{ name: "", type: "address" }], stateMutability: "view" },
+  { type: "function", name: "deploymentConfigHash", inputs: [], outputs: [{ name: "", type: "bytes32" }], stateMutability: "view" },
+  { type: "function", name: "expectedPositionCount", inputs: [], outputs: [{ name: "", type: "uint32" }], stateMutability: "view" },
+  { type: "function", name: "increaseObservationCardinalityNext", inputs: [{ name: "id", type: "bytes32" }, { name: "requested", type: "uint16" }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "initialized", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "", type: "bool" }], stateMutability: "view" },
+  { type: "function", name: "liquidityLocker", inputs: [], outputs: [{ name: "", type: "address" }], stateMutability: "view" },
+  { type: "function", name: "marketCommitment", inputs: [], outputs: [{ name: "", type: "bytes32" }], stateMutability: "view" },
+  { type: "function", name: "observations", inputs: [{ name: "id", type: "bytes32" }, { name: "index", type: "uint256" }], outputs: [{ name: "blockTimestamp", type: "uint32" }, { name: "tickCumulative", type: "int56" }, { name: "secondsPerLiquidityCumulativeX128", type: "uint160" }, { name: "observationInitialized", type: "bool" }], stateMutability: "view" },
+  { type: "function", name: "observeTruncated", inputs: [{ name: "id", type: "bytes32" }, { name: "secondsAgos", type: "uint32[]" }], outputs: [{ name: "tickCumulatives", type: "int56[]" }, { name: "secondsPerLiquidityCumulativeX128s", type: "uint160[]" }], stateMutability: "view" },
+  { type: "function", name: "openingCompletedAt", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "openingSqrtPriceX96", inputs: [], outputs: [{ name: "", type: "uint160" }], stateMutability: "view" },
+  { type: "function", name: "oracleFactory", inputs: [], outputs: [{ name: "", type: "address" }], stateMutability: "view" },
+  { type: "function", name: "oracleInitializedAt", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "oracleState", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "index", type: "uint16" }, { name: "cardinality", type: "uint16" }, { name: "cardinalityNext", type: "uint16" }, { name: "tick", type: "int24" }, { name: "lastBlock", type: "uint64" }, { name: "initializedAt", type: "uint64" }, { name: "maxAbsTickMove", type: "int24" }, { name: "cardinalityCap", type: "uint16" }], stateMutability: "view" },
+  { type: "function", name: "pendingFees", inputs: [{ name: "id", type: "bytes32" }, { name: "asset", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "pendingTreasurySweeps", inputs: [{ name: "id", type: "bytes32" }, { name: "asset", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "poolConfig", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "", type: "tuple", components: lifecycleV4HookPoolConfigComponents }], stateMutability: "view" },
+  { type: "function", name: "poolKey", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "", type: "tuple", components: lifecycleV4PoolKeyComponents }], stateMutability: "view" },
+  { type: "function", name: "poolManager", inputs: [], outputs: [{ name: "", type: "address" }], stateMutability: "view" },
+  { type: "function", name: "pools", inputs: [], outputs: [{ name: "ids", type: "bytes32[]" }], stateMutability: "view" },
+  { type: "function", name: "registerPool", inputs: [{ name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "config", type: "tuple", components: lifecycleV4HookPoolConfigComponents }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "registered", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "", type: "bool" }], stateMutability: "view" },
+  { type: "function", name: "registrar", inputs: [], outputs: [{ name: "", type: "address" }], stateMutability: "view" },
+  { type: "function", name: "settledFees", inputs: [{ name: "id", type: "bytes32" }, { name: "asset", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "token", inputs: [], outputs: [{ name: "", type: "address" }], stateMutability: "view" },
+  { type: "function", name: "unlockCallback", inputs: [{ name: "data", type: "bytes" }], outputs: [{ name: "", type: "bytes" }], stateMutability: "nonpayable" },
+  { type: "function", name: "validateCollector", inputs: [{ name: "key", type: "tuple", components: lifecycleV4PoolKeyComponents }, { name: "collector", type: "address" }, { name: "locker", type: "address" }], outputs: [], stateMutability: "view" },
+  { type: "function", name: "validateOracleConfig", inputs: [{ name: "oracleConfigId", type: "bytes32" }], outputs: [{ name: "maxAbsTickMove", type: "uint24" }, { name: "cardinality", type: "uint16" }], stateMutability: "view" },
+  { type: "event", name: "FeeAccrued", inputs: [{ name: "poolId", type: "bytes32", indexed: true }, { name: "asset", type: "address", indexed: true }, { name: "gross", type: "uint256", indexed: false }, { name: "treasury", type: "uint256", indexed: false }], anonymous: false },
+  { type: "event", name: "FeesCollected", inputs: [{ name: "poolId", type: "bytes32", indexed: true }, { name: "collector", type: "address", indexed: true }, { name: "amount0", type: "uint256", indexed: false }, { name: "amount1", type: "uint256", indexed: false }], anonymous: false },
+  { type: "event", name: "IncreaseObservationCardinalityNext", inputs: [{ name: "poolId", type: "bytes32", indexed: true }, { name: "cardinalityNextOld", type: "uint16", indexed: false }, { name: "cardinalityNextNew", type: "uint16", indexed: false }], anonymous: false },
+  { type: "event", name: "LpFeesCheckpointed", inputs: [{ name: "poolId", type: "bytes32", indexed: true }, { name: "locker", type: "address", indexed: true }, { name: "amount0", type: "uint256", indexed: false }, { name: "amount1", type: "uint256", indexed: false }], anonymous: false },
+  { type: "event", name: "OpeningCompleted", inputs: [{ name: "poolId", type: "bytes32", indexed: true }, { name: "completedAt", type: "uint256", indexed: true }], anonymous: false },
+  { type: "event", name: "PoolInitialized", inputs: [{ name: "poolId", type: "bytes32", indexed: true }], anonymous: false },
+  { type: "event", name: "PoolRegistered", inputs: [{ name: "poolId", type: "bytes32", indexed: true }, { name: "collector", type: "address", indexed: true }, { name: "locker", type: "address", indexed: true }], anonymous: false },
+  { type: "error", name: "AlreadyRegistered", inputs: [] },
+  { type: "error", name: "ClaimMismatch", inputs: [] },
+  { type: "error", name: "ExternalLiquidityDisabled", inputs: [] },
+  { type: "error", name: "FeeSettlementRequired", inputs: [] },
+  { type: "error", name: "FeeTooLarge", inputs: [] },
+  { type: "error", name: "IncompleteFill", inputs: [] },
+  { type: "error", name: "InexactTransfer", inputs: [] },
+  { type: "error", name: "InvalidCallback", inputs: [] },
+  { type: "error", name: "InvalidConfiguration", inputs: [] },
+  { type: "error", name: "InvalidHookAddress", inputs: [] },
+  { type: "error", name: "InvalidObservationState", inputs: [] },
+  { type: "error", name: "InvalidPool", inputs: [] },
+  { type: "error", name: "ObservationTooOld", inputs: [] },
+  { type: "error", name: "OpeningAlreadyComplete", inputs: [] },
+  { type: "error", name: "OpeningNotComplete", inputs: [] },
+  { type: "error", name: "Reentrancy", inputs: [] },
+  { type: "error", name: "Unauthorized", inputs: [] },
 ] as const;
 export const lifecycleV4LockerAbi = [
   { type: "function", name: "poolManager", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
@@ -249,6 +311,39 @@ export const lifecycleErc20Abi = [
   { type: "function", name: "allowance", stateMutability: "view", inputs: [{ type: "address" }, { type: "address" }], outputs: [{ type: "uint256" }] },
   { type: "function", name: "approve", stateMutability: "nonpayable", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }] },
 ] as const;
+/** Shared immutable bindings and terminal state of LaunchERC20V1 / LaunchERC404V1. */
+export const lifecycleTokenContextAbi = [
+  { type: "function", name: "authority", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "tokenFactory", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "launchId", stateMutability: "view", inputs: [], outputs: [{ type: "bytes32" }] },
+  { type: "function", name: "rewardMode", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
+  { type: "function", name: "initialSupply", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "burnOnCancel", stateMutability: "view", inputs: [], outputs: [{ type: "bool" }] },
+  { type: "function", name: "active", stateMutability: "view", inputs: [], outputs: [{ type: "bool" }] },
+  { type: "function", name: "cancelled", stateMutability: "view", inputs: [], outputs: [{ type: "bool" }] },
+  { type: "function", name: "exclusionsFinalized", stateMutability: "view", inputs: [], outputs: [{ type: "bool" }] },
+  { type: "function", name: "feeHub", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "rewardModule", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+] as const;
+export const lifecycleErc404Abi = [
+  ...lifecycleTokenContextAbi,
+  { type: "function", name: "unit", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "baseURI", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+  { type: "function", name: "mirrorERC721", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+] as const;
+export const lifecycleErc404MirrorAbi = [
+  { type: "function", name: "baseERC20", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+] as const;
+export const lifecycleTokenFactoryAbi = [
+  { type: "function", name: "core", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "tokenOfLaunch", stateMutability: "view", inputs: [{ type: "bytes32" }], outputs: [{ type: "address" }] },
+  { type: "function", name: "launchOfToken", stateMutability: "view", inputs: [{ type: "address" }], outputs: [{ type: "bytes32" }] },
+  { type: "event", name: "TokenDeployed", anonymous: false, inputs: [
+    { name: "launchId", type: "bytes32", indexed: true }, { name: "token", type: "address", indexed: true },
+    { name: "kind", type: "uint8", indexed: false },
+  ] },
+] as const;
+
 export const lifecycleOracleFactoryAbi = [
   { type: "function", name: "oracleConfigs", stateMutability: "view", inputs: [{ type: "bytes32" }], outputs: [{ type: "uint24" }, { type: "uint16" }] },
 ] as const;