hookr-sdk 0.2.0 → 1.0.0

package/dist/core/policies.d.ts

@@ -0,0 +1,136 @@
+import { type Hash } from "./schema.js";
+export declare const SOURCE_POLICY_BODIES: {
+    readonly immediate: {
+        readonly mode: 0;
+        readonly activity: "authenticated-opt-in-actual-core-quote";
+        readonly rounding: "contract-fractional-carry";
+        readonly award: "fixed-rate-bounded-budget-wallet-cap";
+        readonly systemFlows: "excluded";
+        readonly schema: "hookr.source-policy.v1";
+        readonly history: "contiguous-finalized-receipts-pinned-runtime";
+        readonly identity: "chain-source-pool-config-participant";
+        readonly quantities: "raw-integer-per-currency";
+        readonly truth: "configured-RPC-and-named-attestor-reviewer";
+        readonly washResistance: "bounded-funded-campaign-not-Sybil-proof";
+    };
+    readonly dailySwap: {
+        readonly mode: 1;
+        readonly activity: "explicit-DailyActivityAccepted-plus-authenticated-receipt";
+        readonly rounding: "sum-raw-per-wallet-scope-day-then-normalize-floor";
+        readonly award: "fixed-UTC-day-budget-pro-rata-floor-wallet-caps-clip-no-redistribution";
+        readonly systemFlows: "excluded";
+        readonly schema: "hookr.source-policy.v1";
+        readonly history: "contiguous-finalized-receipts-pinned-runtime";
+        readonly identity: "chain-source-pool-config-participant";
+        readonly quantities: "raw-integer-per-currency";
+        readonly truth: "configured-RPC-and-named-attestor-reviewer";
+        readonly washResistance: "bounded-funded-campaign-not-Sybil-proof";
+    };
+    readonly dailyLPFees: {
+        readonly mode: 2;
+        readonly activity: "v4-integer-step-replay-LP-trade-fee-growth";
+        readonly ownership: "canonical-PositionManager-NFT-and-Launcher-family-actual-log-order";
+        readonly donations: "excluded-all";
+        readonly rounding: "sum-Q128-earned-per-owner-currency-day-then-floor-then-scope-normalize-floor";
+        readonly award: "fixed-UTC-day-budget-pro-rata-floor-wallet-caps-clip-no-redistribution";
+        readonly reconciliation: "end-block-pool-ticks-positions-owner-state";
+        readonly unsupportedCustody: "excluded-disclosed";
+        readonly selfPaidFees: "excluded-when-owner-is-router-payer-or-recipient-or-poolmanager-sender-or-transaction-origin";
+        readonly unattributedSwaps: "excluded-curated-router-and-unpaired-router-swaps";
+        readonly priceLimits: "v4-limit-bound-swaps-replayed-at-emitted-final-price";
+        readonly schema: "hookr.source-policy.v1";
+        readonly history: "contiguous-finalized-receipts-pinned-runtime";
+        readonly identity: "chain-source-pool-config-participant";
+        readonly quantities: "raw-integer-per-currency";
+        readonly truth: "configured-RPC-and-named-attestor-reviewer";
+        readonly washResistance: "bounded-funded-campaign-not-Sybil-proof";
+    };
+    readonly dailyReferral: {
+        readonly mode: 3;
+        readonly activity: "normalized-qualified-base-activity-not-awarded-points";
+        readonly binding: "authenticated-immutable-before-first-activity-Solidity-parent-clock";
+        readonly bases: readonly ["immediate", "dailySwap", "dailyLPFees"];
+        readonly award: "separate-fixed-daily-budget-weighted-per-payer-leaf-referrer-wallet-cap";
+        readonly donations: "excluded-all";
+        readonly lpBase: "dailyLPFees-self-paid-and-unattributed-swaps-excluded";
+        readonly rounding: "base-policy-activity-rounding-then-per-payer-budget-floor";
+        readonly schema: "hookr.source-policy.v1";
+        readonly history: "contiguous-finalized-receipts-pinned-runtime";
+        readonly identity: "chain-source-pool-config-participant";
+        readonly quantities: "raw-integer-per-currency";
+        readonly truth: "configured-RPC-and-named-attestor-reviewer";
+        readonly washResistance: "bounded-funded-campaign-not-Sybil-proof";
+    };
+    readonly commission: {
+        readonly activity: "actual-collected-protocol-or-creator-royalty-fee-lots";
+        readonly binding: "authenticated-immutable-before-first-activity-Solidity-parent-clock";
+        readonly payer: "unambiguous-known-router-fee-event-pair";
+        readonly payerCode: "EOA-or-reviewed-smart-wallet-runtime-including-EIP-7702-delegate";
+        readonly selfReferral: "referrer-originated-payer-swaps-excluded-related-wallet-evidence-not-Sybil-proof";
+        readonly collection: "refunds-to-router-payer-or-PoolManager-sender-unattributed-refunds-absorbed-first-by-lot-owners-non-owner-claims-skipped-then-FIFO-fee-lots-protocol-matches-Treasury-receipt";
+        readonly award: "immutable-bps-chronological-daily-budget-wallet-fee-cap";
+        readonly stacking: "each-fee-unit-once-within-operator-database-and-against-other-campaigns-onchain-proposals-review-required-across-operators";
+        readonly schema: "hookr.source-policy.v1";
+        readonly history: "contiguous-finalized-receipts-pinned-runtime";
+        readonly identity: "chain-source-pool-config-participant";
+        readonly quantities: "raw-integer-per-currency";
+        readonly truth: "configured-RPC-and-named-attestor-reviewer";
+        readonly washResistance: "bounded-funded-campaign-not-Sybil-proof";
+    };
+};
+export declare const SOURCE_POLICIES: {
+    readonly immediate: `0x${string}`;
+    readonly dailySwap: `0x${string}`;
+    readonly dailyLPFees: `0x${string}`;
+    readonly dailyReferral: `0x${string}`;
+    readonly commission: `0x${string}`;
+};
+export declare const LAUNCH_SEASON_POLICY_BODIES: {
+    readonly traders: {
+        readonly mode: 1;
+        readonly activity: "every-route-PoolManager-Swap-quote-leg";
+        readonly wash: "ATT-03-same-day-liquidity-rule-actor-and-effective-origin-dev-buy-per-formula";
+        readonly rounding: "sum-ETH-equivalent-wei-per-actor-over-the-ledger-period-floor";
+        readonly history: "finalized-eth_getLogs-spans-at-most-5000-blocks-plus-receipts-of-every-pool-transaction";
+        readonly identity: "chain-root-pool-actor";
+        readonly scope: "every-pool-a-pinned-root-opened-from-the-configured-launch-block";
+        readonly attribution: "router-payer-forwarder-intent-owner-dev-buy-buyer-userop-sender-universal-router-tx-sender-or-traced-listed-wallet-caller-lane-trader-as-caller-else-origin-flagged-trace-failures-fail-the-pass";
+        readonly unit: "ETH-equivalent-wei-at-the-swap-block-priced-before-it-by-chainlink-feeds-or-an-owner-pinned-reference-pool-TWAP-of-earlier-blocks-unpriced-weighs-zero";
+        readonly systemFlows: "arb-recapture-legs-executor-rules-treasury-launcher-vault-poolmanager-forwarder-and-owner-listed-wallets-excluded";
+        readonly receipts: "HookrPrograms-execution-receipts-ignored";
+        readonly payout: "ledger-UTC-days-paid-as-the-content-of-a-later-program-day-each-ledger-day-paid-once-per-kind-coverage-names-the-ledger-block-range";
+        readonly award: "fixed-UTC-day-budget-pro-rata-floor-wallet-caps-clip-no-redistribution";
+        readonly schema: "hookr.source-policy.v1";
+        readonly quantities: "raw-integer-per-currency";
+        readonly truth: "configured-RPC-and-named-attestor-reviewer";
+        readonly washResistance: "bounded-funded-campaign-not-Sybil-proof";
+    };
+    readonly lps: {
+        readonly mode: 2;
+        readonly activity: "v4-integer-step-replay-LP-trade-fee-growth-every-attributed-swap";
+        readonly ownership: "canonical-PositionManager-NFT-Launcher-family-and-HookrLiquidityVault-share-holders-actual-log-order";
+        readonly donations: "excluded-all";
+        readonly selfPaidFees: "excluded-when-owner-is-actor-origin-effective-origin-sender-payer-or-recipient";
+        readonly unattributedSwaps: "excluded-arb-recapture-executor-legs";
+        readonly rounding: "sum-Q128-earned-per-owner-currency-day-then-floor-then-each-currency-ETH-equivalent-at-day-close-by-feed-or-pinned-reference-TWAP-never-the-pool-price-unpriced-side-weighs-zero";
+        readonly history: "finalized-eth_getLogs-spans-at-most-5000-blocks-plus-receipts-of-every-pool-transaction";
+        readonly identity: "chain-root-pool-actor";
+        readonly scope: "every-pool-a-pinned-root-opened-from-the-configured-launch-block";
+        readonly attribution: "router-payer-forwarder-intent-owner-dev-buy-buyer-userop-sender-universal-router-tx-sender-or-traced-listed-wallet-caller-lane-trader-as-caller-else-origin-flagged-trace-failures-fail-the-pass";
+        readonly unit: "ETH-equivalent-wei-at-the-swap-block-priced-before-it-by-chainlink-feeds-or-an-owner-pinned-reference-pool-TWAP-of-earlier-blocks-unpriced-weighs-zero";
+        readonly systemFlows: "arb-recapture-legs-executor-rules-treasury-launcher-vault-poolmanager-forwarder-and-owner-listed-wallets-excluded";
+        readonly receipts: "HookrPrograms-execution-receipts-ignored";
+        readonly payout: "ledger-UTC-days-paid-as-the-content-of-a-later-program-day-each-ledger-day-paid-once-per-kind-coverage-names-the-ledger-block-range";
+        readonly award: "fixed-UTC-day-budget-pro-rata-floor-wallet-caps-clip-no-redistribution";
+        readonly schema: "hookr.source-policy.v1";
+        readonly quantities: "raw-integer-per-currency";
+        readonly truth: "configured-RPC-and-named-attestor-reviewer";
+        readonly washResistance: "bounded-funded-campaign-not-Sybil-proof";
+    };
+};
+export declare const LAUNCH_SEASON_POLICIES: {
+    readonly traders: `0x${string}`;
+    readonly lps: `0x${string}`;
+};
+export declare function policyForMode(mode: number): Hash;
+export declare function requirePolicy(value: Hash, mode: number | "commission"): void;

package/dist/core/policies.js

@@ -0,0 +1,125 @@
+import { assert } from "./schema.js";
+import { digest } from "./proofs.js";
+const common = {
+    schema: "hookr.source-policy.v1",
+    history: "contiguous-finalized-receipts-pinned-runtime",
+    identity: "chain-source-pool-config-participant",
+    quantities: "raw-integer-per-currency",
+    truth: "configured-RPC-and-named-attestor-reviewer",
+    washResistance: "bounded-funded-campaign-not-Sybil-proof",
+};
+export const SOURCE_POLICY_BODIES = {
+    immediate: {
+        ...common,
+        mode: 0,
+        activity: "authenticated-opt-in-actual-core-quote",
+        rounding: "contract-fractional-carry",
+        award: "fixed-rate-bounded-budget-wallet-cap",
+        systemFlows: "excluded",
+    },
+    dailySwap: {
+        ...common,
+        mode: 1,
+        activity: "explicit-DailyActivityAccepted-plus-authenticated-receipt",
+        rounding: "sum-raw-per-wallet-scope-day-then-normalize-floor",
+        award: "fixed-UTC-day-budget-pro-rata-floor-wallet-caps-clip-no-redistribution",
+        systemFlows: "excluded",
+    },
+    dailyLPFees: {
+        ...common,
+        mode: 2,
+        activity: "v4-integer-step-replay-LP-trade-fee-growth",
+        ownership: "canonical-PositionManager-NFT-and-Launcher-family-actual-log-order",
+        donations: "excluded-all",
+        rounding: "sum-Q128-earned-per-owner-currency-day-then-floor-then-scope-normalize-floor",
+        award: "fixed-UTC-day-budget-pro-rata-floor-wallet-caps-clip-no-redistribution",
+        reconciliation: "end-block-pool-ticks-positions-owner-state",
+        unsupportedCustody: "excluded-disclosed",
+        selfPaidFees: "excluded-when-owner-is-router-payer-or-recipient-or-poolmanager-sender-or-transaction-origin",
+        unattributedSwaps: "excluded-curated-router-and-unpaired-router-swaps",
+        priceLimits: "v4-limit-bound-swaps-replayed-at-emitted-final-price",
+    },
+    dailyReferral: {
+        ...common,
+        mode: 3,
+        activity: "normalized-qualified-base-activity-not-awarded-points",
+        binding: "authenticated-immutable-before-first-activity-Solidity-parent-clock",
+        bases: ["immediate", "dailySwap", "dailyLPFees"],
+        award: "separate-fixed-daily-budget-weighted-per-payer-leaf-referrer-wallet-cap",
+        donations: "excluded-all",
+        lpBase: "dailyLPFees-self-paid-and-unattributed-swaps-excluded",
+        rounding: "base-policy-activity-rounding-then-per-payer-budget-floor",
+    },
+    commission: {
+        ...common,
+        activity: "actual-collected-protocol-or-creator-royalty-fee-lots",
+        binding: "authenticated-immutable-before-first-activity-Solidity-parent-clock",
+        payer: "unambiguous-known-router-fee-event-pair",
+        payerCode: "EOA-or-reviewed-smart-wallet-runtime-including-EIP-7702-delegate",
+        selfReferral: "referrer-originated-payer-swaps-excluded-related-wallet-evidence-not-Sybil-proof",
+        collection: "refunds-to-router-payer-or-PoolManager-sender-unattributed-refunds-absorbed-first-by-lot-owners-non-owner-claims-skipped-then-FIFO-fee-lots-protocol-matches-Treasury-receipt",
+        award: "immutable-bps-chronological-daily-budget-wallet-fee-cap",
+        stacking: "each-fee-unit-once-within-operator-database-and-against-other-campaigns-onchain-proposals-review-required-across-operators",
+    },
+};
+export const SOURCE_POLICIES = {
+    immediate: digest(SOURCE_POLICY_BODIES.immediate),
+    dailySwap: digest(SOURCE_POLICY_BODIES.dailySwap),
+    dailyLPFees: digest(SOURCE_POLICY_BODIES.dailyLPFees),
+    dailyReferral: digest(SOURCE_POLICY_BODIES.dailyReferral),
+    commission: digest(SOURCE_POLICY_BODIES.commission),
+};
+/**
+ * Off-chain launch points ledger (service/src/points): activity counted from the Hookr 1 launch block on every pinned
+ * root's pools whatever the route, then paid through ordinary DailySwap (traders) or DailyLPFees (LPs) programs whose
+ * days carry earlier ledger periods. A program naming one of these hashes is allocated only by the ledger
+ * (`points-ledger allocate`), never from HookrPrograms receipts, so a swap opted into the season program by
+ * recordExecution is not counted twice.
+ */
+const launchSeason = {
+    ...common,
+    history: "finalized-eth_getLogs-spans-at-most-5000-blocks-plus-receipts-of-every-pool-transaction",
+    identity: "chain-root-pool-actor",
+    scope: "every-pool-a-pinned-root-opened-from-the-configured-launch-block",
+    attribution: "router-payer-forwarder-intent-owner-dev-buy-buyer-userop-sender-universal-router-tx-sender-or-traced-listed-wallet-caller-lane-trader-as-caller-else-origin-flagged-trace-failures-fail-the-pass",
+    unit: "ETH-equivalent-wei-at-the-swap-block-priced-before-it-by-chainlink-feeds-or-an-owner-pinned-reference-pool-TWAP-of-earlier-blocks-unpriced-weighs-zero",
+    systemFlows: "arb-recapture-legs-executor-rules-treasury-launcher-vault-poolmanager-forwarder-and-owner-listed-wallets-excluded",
+    receipts: "HookrPrograms-execution-receipts-ignored",
+    payout: "ledger-UTC-days-paid-as-the-content-of-a-later-program-day-each-ledger-day-paid-once-per-kind-coverage-names-the-ledger-block-range",
+    award: "fixed-UTC-day-budget-pro-rata-floor-wallet-caps-clip-no-redistribution",
+};
+export const LAUNCH_SEASON_POLICY_BODIES = {
+    traders: {
+        ...launchSeason,
+        mode: 1,
+        activity: "every-route-PoolManager-Swap-quote-leg",
+        wash: "ATT-03-same-day-liquidity-rule-actor-and-effective-origin-dev-buy-per-formula",
+        rounding: "sum-ETH-equivalent-wei-per-actor-over-the-ledger-period-floor",
+    },
+    lps: {
+        ...launchSeason,
+        mode: 2,
+        activity: "v4-integer-step-replay-LP-trade-fee-growth-every-attributed-swap",
+        ownership: "canonical-PositionManager-NFT-Launcher-family-and-HookrLiquidityVault-share-holders-actual-log-order",
+        donations: "excluded-all",
+        selfPaidFees: "excluded-when-owner-is-actor-origin-effective-origin-sender-payer-or-recipient",
+        unattributedSwaps: "excluded-arb-recapture-executor-legs",
+        rounding: "sum-Q128-earned-per-owner-currency-day-then-floor-then-each-currency-ETH-equivalent-at-day-close-by-feed-or-pinned-reference-TWAP-never-the-pool-price-unpriced-side-weighs-zero",
+    },
+};
+export const LAUNCH_SEASON_POLICIES = {
+    traders: digest(LAUNCH_SEASON_POLICY_BODIES.traders),
+    lps: digest(LAUNCH_SEASON_POLICY_BODIES.lps),
+};
+export function policyForMode(mode) {
+    assert(Number.isInteger(mode) && mode >= 0 && mode <= 3, "Unsupported program mode");
+    return [
+        SOURCE_POLICIES.immediate,
+        SOURCE_POLICIES.dailySwap,
+        SOURCE_POLICIES.dailyLPFees,
+        SOURCE_POLICIES.dailyReferral,
+    ][mode];
+}
+export function requirePolicy(value, mode) {
+    assert(value === (mode === "commission" ? SOURCE_POLICIES.commission : policyForMode(mode)), "Unsupported source policy; use the published policy body and matching immutable hash");
+}

package/dist/core/proofs.d.ts

@@ -0,0 +1,25 @@
+import { type Address, type Hash } from "./schema.js";
+export declare const digest: (value: unknown) => Hash;
+export interface DayDomain {
+    chainId: string;
+    distributor: Address;
+    programId: string;
+    termsHash: Hash;
+    day: string;
+    epochStart: string;
+    epochEnd: string;
+    coverageHash: Hash;
+}
+export declare function dayLeaf(d: DayDomain, beneficiary: Address, weight: string): Hash;
+export declare const pair: (a: Hash, b: Hash) => Hash;
+export declare function merkle(leaves: Hash[]): {
+    root: Hash;
+    proofs: Hash[][];
+};
+export declare const verifyProof: (leaf: Hash, proof: Hash[], root: Hash) => boolean;
+export interface FeeDomain extends Omit<DayDomain, "programId"> {
+    campaignId: string;
+    collectionsHash: Hash;
+}
+export declare function feeLeaf(d: FeeDomain, payer: Address, referrer: Address, firstActivityBlock: string, eligibleFees: string): Hash;
+export declare function referralPointLeaf(d: DayDomain, payer: Address, referrer: Address, firstActivityBlock: string, weight: string): Hash;

package/dist/core/proofs.js

@@ -0,0 +1,118 @@
+import { encodeAbiParameters, keccak256, concatHex, stringToHex } from "viem";
+import { assert, canonical, hash, uint, ZERO_HASH } from "./schema.js";
+export const digest = (value) => keccak256(stringToHex(canonical(value)));
+export function dayLeaf(d, beneficiary, weight) {
+    uint(weight, 128);
+    return keccak256(keccak256(encodeAbiParameters([
+        { type: "uint256" },
+        { type: "address" },
+        { type: "uint256" },
+        { type: "bytes32" },
+        { type: "uint256" },
+        { type: "uint64" },
+        { type: "uint64" },
+        { type: "bytes32" },
+        { type: "address" },
+        { type: "uint128" },
+    ], [
+        uint(d.chainId),
+        d.distributor,
+        uint(d.programId),
+        d.termsHash,
+        uint(d.day),
+        uint(d.epochStart, 64),
+        uint(d.epochEnd, 64),
+        d.coverageHash,
+        beneficiary,
+        uint(weight, 128),
+    ])));
+}
+export const pair = (a, b) => keccak256(concatHex(a.toLowerCase() < b.toLowerCase() ? [a, b] : [b, a]));
+export function merkle(leaves) {
+    if (!leaves.length)
+        return { root: ZERO_HASH, proofs: [] };
+    const levels = [leaves.map(hash)];
+    assert(new Set(levels[0]).size === leaves.length, "Duplicate leaves");
+    while (levels.at(-1).length > 1) {
+        const prev = levels.at(-1);
+        const next = [];
+        for (let i = 0; i < prev.length; i += 2)
+            next.push(i + 1 < prev.length ? pair(prev[i], prev[i + 1]) : prev[i]);
+        levels.push(next);
+    }
+    assert(levels.length <= 33, "Merkle depth exceeded");
+    return {
+        root: levels.at(-1)[0],
+        proofs: leaves.map((_, i) => {
+            const proof = [];
+            for (const level of levels.slice(0, -1)) {
+                const other = i ^ 1;
+                if (other < level.length)
+                    proof.push(level[other]);
+                i = Math.floor(i / 2);
+            }
+            return proof;
+        }),
+    };
+}
+export const verifyProof = (leaf, proof, root) => proof.reduce(pair, leaf) === root;
+export function feeLeaf(d, payer, referrer, firstActivityBlock, eligibleFees) {
+    return keccak256(keccak256(encodeAbiParameters([
+        { type: "uint256" },
+        { type: "address" },
+        { type: "uint256" },
+        { type: "bytes32" },
+        { type: "uint256" },
+        { type: "uint64" },
+        { type: "uint64" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "address" },
+        { type: "address" },
+        { type: "uint64" },
+        { type: "uint128" },
+    ], [
+        uint(d.chainId),
+        d.distributor,
+        uint(d.campaignId),
+        d.termsHash,
+        uint(d.day),
+        uint(d.epochStart, 64),
+        uint(d.epochEnd, 64),
+        d.coverageHash,
+        d.collectionsHash,
+        payer,
+        referrer,
+        uint(firstActivityBlock, 64),
+        uint(eligibleFees, 128),
+    ])));
+}
+export function referralPointLeaf(d, payer, referrer, firstActivityBlock, weight) {
+    return keccak256(keccak256(encodeAbiParameters([
+        { type: "uint256" },
+        { type: "address" },
+        { type: "uint256" },
+        { type: "bytes32" },
+        { type: "uint256" },
+        { type: "uint64" },
+        { type: "uint64" },
+        { type: "bytes32" },
+        { type: "address" },
+        { type: "address" },
+        { type: "uint64" },
+        { type: "uint128" },
+    ], [
+        uint(d.chainId),
+        d.distributor,
+        uint(d.programId),
+        d.termsHash,
+        uint(d.day),
+        uint(d.epochStart, 64),
+        uint(d.epochEnd, 64),
+        d.coverageHash,
+        payer,
+        referrer,
+        uint(firstActivityBlock, 64),
+        uint(weight, 128),
+    ])));
+}

package/dist/core/quotes.d.ts

@@ -0,0 +1,185 @@
+import { type Hex } from "viem";
+import { type Address, type Call, type DeploymentManifest, type Hash } from "./schema.js";
+import { type StockToken } from "./stocks.generated.js";
+import { type Swap } from "./wallet.js";
+/**
+ * Quote assets: every asset a Hookr 1 market may quote in, the classes the app and the release tooling name them by,
+ * their decimals, and the ERC-20 funding a launch or trade needs.
+ *
+ * On chain the registry decides. HookrRoot.initializePool refuses a quote `isQuote` does not admit (UnqualifiedQuote);
+ * native ETH is always admitted, an ERC-20 through the reviewed catalog (SET_QUOTE), a whole class by runtime code hash
+ * (SET_QUOTE_CLASS, every Robinhood stock token) or, while open quotes are on (OPEN_QUOTES), any contract that is not an
+ * EIP-7702 delegated account, as the live launchpads accept. `curatedQuote` tells the first three from an open quote.
+ * Nothing here can admit a quote: `quoteAdmission` reads the registry at a block, and a class below is a label for
+ * guidance, never an admission.
+ *
+ * The classification follows the live app's v2-asset-class.ts: the curated catalog first (the only source that can
+ * name a stablecoin), then the ERC-1967 beacon slot (every Robinhood stock token is a BeaconProxy of one beacon), then
+ * fail closed to an unconfident "erc20".
+ */
+/** ERC-1967 beacon slot: bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1). */
+export declare const ERC1967_BEACON_SLOT: Hash;
+/** ERC-1967 implementation slot: bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1). */
+export declare const ERC1967_IMPLEMENTATION_SLOT: Hash;
+/** The one beacon every Robinhood tokenized stock and ETF on chain 4663 proxies to (also its pause registry). */
+export declare const ROBINHOOD_STOCK_BEACON: Address;
+/** The runtime keccak256 every one of those proxies shares: OpenZeppelin BeaconProxy with that beacon immutable. */
+export declare const ROBINHOOD_STOCK_PROXY_RUNTIME_KECCAK256: Hash;
+/** Canonical Permit2: HookrForwarder pulls a gasless swap's ERC-20 input through it. */
+export declare const PERMIT2: Address;
+/**
+ * What a quote is, for guidance and labels. `native` is ETH (the zero address), `weth` wrapped ETH, `stable` the
+ * reviewed dollar token USDG, `hookr` the HOOKR token, `listed` every other token on the reviewed genesis catalog,
+ * `rwa` a Robinhood stock token, and `erc20` anything else.
+ */
+export type QuoteClass = "native" | "weth" | "stable" | "hookr" | "listed" | "rwa" | "erc20";
+/** How a classification was reached: rendered, so a reader knows what the answer rests on. */
+export type QuoteSource = "native" | "catalog" | "beacon" | "unclassified";
+export interface QuoteAsset {
+    address: Address;
+    /** Read from the token or the catalog; null when it could not be read. Never assumed. */
+    symbol: string | null;
+    /** Read from the token or the catalog; null when it could not be read. Never assumed to be 18. */
+    decimals: number | null;
+    class: QuoteClass;
+    source: QuoteSource;
+    /** False for an address neither the catalog nor the beacon identifies: its class is the fail-closed default. */
+    confident: boolean;
+    /** The stock token's onchain name, when the class is `rwa` and the scan list carries it. */
+    name?: string;
+}
+/** A reviewed catalog quote: exact onchain metadata and runtime, with the ERC-1967 implementation it proxies to. */
+export interface CatalogQuote {
+    address: Address;
+    symbol: string;
+    name: string;
+    decimals: number;
+    class: Exclude<QuoteClass, "native" | "rwa" | "erc20">;
+    runtimeKeccak256: Hash;
+    /** The ERC-1967 implementation the proxy held when read, or null for a token that is not a proxy. */
+    implementation: Address | null;
+}
+/** The block the catalog below was read at (chain 4663, through Alchemy, 2026-10-06 00:54 UTC). */
+export declare const ROBINHOOD_QUOTE_CATALOG_BLOCK = 81225166;
+/**
+ * The genesis catalog the owner set on 2026-10-05: the 20 largest tokens on Robinhood Chain by market cap at
+ * ROBINHOOD_QUOTE_CATALOG_BLOCK that pass review (WETH and USDG among them) plus HOOKR and What The Hook's WTH, in the
+ * registry's queue order (the release template's `quoteAssets`).
+ * Every field was read from chain 4663 at ROBINHOOD_QUOTE_CATALOG_BLOCK, not copied from a document (USDG and
+ * syrupUSDG are 6 decimals). WETH, USDG and U are ERC-1967 proxies: a runtime hash alone does not review their upgrade
+ * authority.
+ */
+export declare const ROBINHOOD_QUOTE_CATALOG: readonly CatalogQuote[];
+/** Native ETH: the zero address in every pool key, 18 decimals, always admitted by the registry. */
+export declare const NATIVE_QUOTE: QuoteAsset;
+/** Display labels for each class. */
+export declare const QUOTE_CLASS_LABELS: Readonly<Record<QuoteClass, string>>;
+/** What a stock quote means for the pool, in the live classifier's words. */
+export declare const STOCK_QUOTE_NOTE = "This token is a Robinhood tokenized stock: its proxy points at the shared beacon, so a pause there halts every pool holding it.";
+/** Why an unclassified quote still warns. */
+export declare const UNCLASSIFIED_QUOTE_NOTE = "This address is not on the verified list and does not point at the shared Robinhood stock beacon. It is treated as an ERC-20 you do not control: verify what it does on transfer before you use it.";
+/** An upgradeable catalog quote. */
+export declare const PROXY_QUOTE_NOTE = "This token is an upgradeable proxy: its issuer can change what it does, and every pool quoting it follows.";
+/** A quote whose transfers move less or more than asked is refused by every Hookr transfer (exact settlement). */
+export declare const EXACT_TRANSFER_NOTE = "Hookr settles exact amounts: a token that takes a fee on transfer, rebases or blocks addresses can make launches, trades and fee claims revert.";
+/** The reviewed catalog entry for an address, or null. */
+export declare function catalogQuote(target: string): CatalogQuote | null;
+/** The scanned stock token at an address (its label), or null. A token absent here can still be a stock token. */
+export declare function stockToken(target: string): StockToken | null;
+/** A token's decimals as the contracts can use them: an integer from 0 to 36. Anything else throws. */
+export declare function quoteDecimals(value: unknown): number;
+/** Parses a decimal amount typed in quote units ("1.5") into raw units, refusing more places than the token has. */
+export declare function parseQuoteAmount(text: string, decimals: number): bigint;
+/** Formats a raw quote amount in its token's units. */
+export declare function formatQuoteAmount(raw: bigint, decimals: number): string;
+/** The address a 32-byte storage word holds, or null for an empty or malformed word. */
+export declare function addressFromWord(word: unknown): Address | null;
+/** The classification that needs no network: native ETH, the catalog and the scanned stock list. Null otherwise. */
+export declare function classifyQuoteOffline(target: string): QuoteAsset | null;
+/** The minimum a caller supplies to read the chain: a storage read and an eth_call. Mocked in tests. */
+export interface QuoteReader {
+    getStorageAt(target: Address, slot: Hash): Promise<Hex | undefined>;
+    call(to: Address, data: Hex): Promise<Hex>;
+}
+/**
+ * The full classification: native, the catalog, then the ERC-1967 beacon slot, then an unconfident "erc20". Decimals
+ * and symbol are read from the token and are null when it does not answer (a quote without decimals cannot be priced
+ * or funded, so callers refuse it). A read that throws degrades to "erc20", never to a safer class.
+ */
+export declare function classifyQuote(reader: QuoteReader, target: string): Promise<QuoteAsset>;
+/**
+ * The warnings a quote carries before anyone launches or trades against it, in display order. `curated` is the
+ * registry's `curatedQuote` answer (`quoteAdmission`): false adds the open-quote note.
+ */
+export declare function quoteWarnings(q: QuoteAsset, curated?: boolean | null): string[];
+/** A read-only registry isQuote call for `asset` at the manifest's registry. */
+export declare function buildIsQuote(m: DeploymentManifest, asset: Address): {
+    to: Address;
+    data: Hex;
+};
+/** Whether the registry admits `asset` as a new market's quote, by an eth_call the caller pins to a block. */
+export declare function quoteAdmitted(ethCall: (to: Address, data: Hex) => Promise<Hex>, m: DeploymentManifest, asset: Address): Promise<boolean>;
+/**
+ * What the registry says of a quote at the caller's block: `admitted`, whether a new pool may bind it (`isQuote`), and
+ * `curated`, whether it is native ETH, a catalog asset or a class member rather than admitted only by open quotes.
+ * `curated` is null when the registry does not answer `curatedQuote` (a release without quote classes, where every
+ * admitted quote is a catalog asset) or the read fails; a caller then labels the quote by its classification alone.
+ */
+export declare function quoteAdmission(ethCall: (to: Address, data: Hex) => Promise<Hex>, m: DeploymentManifest, asset: Address): Promise<{
+    admitted: boolean;
+    curated: boolean | null;
+}>;
+/** The note an open quote carries: the registry admits it without any review. */
+export declare const OPEN_QUOTE_NOTE = "The registry admits this token only because open quotes are on: nobody reviewed it. Check its address before you use it.";
+/**
+ * Refuses a member quote the Launcher or the root would refuse before any pool opens, and one no amount could be read
+ * in: the subject itself, a quote repeated in one family, or an ERC-20 without known decimals. Registry admission is
+ * checked on chain (`quoteAdmitted`).
+ */
+export declare function checkLaunchQuotes(subject: Address | null, quotes: readonly QuoteAsset[]): void;
+/** An ERC-20 allowance an action needs: `spender` must be approved for `amount` of `token` from the signer. */
+export interface Allowance {
+    token: Address;
+    spender: Address;
+    amount: bigint;
+}
+/** What a launch collects from its caller: native value and each ERC-20 the Launcher pulls, summed per token. */
+export interface LaunchFunding {
+    native: bigint;
+    allowances: Allowance[];
+}
+/**
+ * The funding HookrLauncher.launch / launchAdvised / launchWithBuy / launchFamily collects from the caller: for every
+ * member, its quote side's maximum (amount1Max when the subject sorts first, else amount0Max) plus the dev buy's quoteIn
+ * on each buy's member (launchFamily takes up to one per member); for an existing subject, the subject side's maxima too
+ * (a new token is minted to the Launcher); and the launch fee in native value (r31, `launchFee`, read at the launch
+ * block). Native ETH is the call's value; each ERC-20 needs an allowance to the Launcher of the listed amount.
+ */
+export declare function launchFunding(m: DeploymentManifest, subject: Address, existingSubject: boolean, members: readonly Record<string, unknown>[], launchFee: bigint, buys?: readonly {
+    member: number;
+    quoteIn: bigint;
+}[]): LaunchFunding;
+/**
+ * The ERC-20 allowance HookrRouter.swap needs: the input currency's exact amount for exact input, the bound for exact
+ * output, to the router. Null when the input is native ETH (sent as value). Through HookrForwarder (gasless) the
+ * allowance goes to Permit2 instead: `permit2Allowance`.
+ */
+export declare function swapAllowance(m: DeploymentManifest, s: Swap): Allowance | null;
+/** A gasless swap's ERC-20 input needs a Permit2 allowance; the intent's signature then authorizes each pull. */
+export declare function permit2Allowance(token: Address, amount: bigint): Allowance;
+/**
+ * The ERC-20 approve for an allowance. `current` is the signer's allowance now: a token that refuses to move a
+ * nonzero allowance to another nonzero value (USDT-style) is reset to zero first, so pass it and send the calls in
+ * order. Returns no call when the allowance already covers the amount.
+ */
+export declare function buildApprovals(m: DeploymentManifest, a: Allowance, current?: bigint): Call[];
+/**
+ * The Robinhood stock tokens as one reviewed quote class (SET_QUOTE_CLASS): the runtime keccak256 every proxy of the
+ * stock beacon shares, the beacon it embeds, and AAPL as the witness the registry checks the hash against.
+ */
+export declare const ROBINHOOD_STOCK_QUOTE_CLASS: Readonly<{
+    label: "Robinhood stock tokens";
+    runtimeKeccak256: `0x${string}`;
+    beacon: `0x${string}`;
+    witness: Address;
+}>;