hookr-sdk 0.2.1 → 1.1.0

package/dist/core/registry.d.ts

@@ -0,0 +1,357 @@
+import { type Abi, type Hex } from "viem";
+import { type Address, type Call, type DeploymentManifest, type Hash } from "./schema.js";
+import { type Caps } from "./rules.js";
+/** IHookrRegistry.Kind. */
+export declare const ADMISSION_KIND: {
+    readonly RULES: 0;
+    readonly ADVISORY: 1;
+};
+/** HookrTypes phase bits an advisory may run in. */
+export declare const PHASE: {
+    readonly BEFORE_SWAP: 1;
+    readonly AFTER_SWAP: 2;
+};
+/** IHookrRegistry.Admission: an immutable, codehash-pinned module admission for one root. */
+export interface Admission {
+    kind: 0 | 1;
+    implementation: Address;
+    codeHash: Hash;
+    schemaHash: Hash;
+    caps: Caps;
+    gasLimit: number;
+    phaseMask: number;
+    feeOnly: boolean;
+    failOpen: boolean;
+}
+/** A timelocked HookrRegistry operation: the kind and the arguments its executing function re-derives. */
+export type RegistryOperation = {
+    kind: "SET_LAUNCHER";
+    launcher: Address;
+    active: boolean;
+} | {
+    kind: "SET_QUOTE";
+    asset: Address;
+    active: boolean;
+}
+/**
+ * Admits a whole quote class (`enableQuoteClassOf`): every contract whose runtime codehash is `codeHash` becomes a
+ * quote for new pools, the way every Robinhood stock token shares one BeaconProxy runtime
+ * (`ROBINHOOD_STOCK_QUOTE_CLASS`). `witness` is a deployed member the registry checks the hash against, when queued
+ * and when executed. Withdrawing a class is the immediate brake `buildExcludeQuoteClass`, not an operation.
+ */
+ | {
+    kind: "SET_QUOTE_CLASS";
+    witness: Address;
+    codeHash: Hash;
+}
+/**
+ * Opens new markets to any quote that holds code and is not an EIP-7702 delegated account (`allowOpenQuotes`), the
+ * rule the live launchpads apply. Closing them is the immediate brake `buildStopOpenQuotes`.
+ */
+ | {
+    kind: "OPEN_QUOTES";
+}
+/** `codeHash` is the root's runtime codehash; registration refuses any other runtime. */
+ | {
+    kind: "REGISTER_ROOT";
+    root: Address;
+    codeHash: Hash;
+} | {
+    kind: "RETIRE_ROOT";
+    root: Address;
+} | {
+    kind: "REOPEN_ROOT";
+    root: Address;
+}
+/** `codeHash` is the factory's runtime codehash; activation is refused while the factory is active. */
+ | {
+    kind: "SET_ROOT_FACTORY";
+    factory: Address;
+    codeHash: Hash;
+    active: boolean;
+}
+/**
+ * `root` is a root, or an active root factory admitting a pair advisory (kind ADVISORY) for the pair roots it
+ * deploys (`factoryAdmission`). The registry refuses a factory scope before SET_ROOT_FACTORY executes.
+ */
+ | {
+    kind: "ADMIT";
+    root: Address;
+    admission: Admission;
+} | {
+    kind: "TRANSFER_OWNER";
+    nextOwner: Address;
+} | {
+    kind: "SET_GUARDIAN";
+    guardian: Address;
+} | {
+    kind: "RESUME_NEW_MARKETS";
+};
+export type RegistryOperationKind = RegistryOperation["kind"];
+/**
+ * The quote-admission surface of HookrRegistry: the two timelocked operations (a quote class by
+ * runtime codehash, open quotes), their two immediate brakes (owner or guardian), the reads and the events. Written
+ * from its compiled ABI; `test/quote-admission.test.ts` pins every item to it (`test/fixtures`) and to the
+ * generated ABI once the packet carries them. Their kind constants are private in the registry: keccak256 of the name.
+ */
+export declare const QUOTE_ADMISSION_ABI: readonly [{
+    readonly name: "enableQuoteClassOf";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "witness";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "codeHash";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "excludeQuoteClassNow";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "codeHash";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "allowOpenQuotes";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "stopOpenQuotesNow";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "curatedQuote";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "asset";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "quoteState";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+        readonly name: "openQuotes";
+    }, {
+        readonly type: "uint48";
+        readonly name: "openQuotesStoppedAt";
+    }, {
+        readonly type: "bytes32[]";
+        readonly name: "classes";
+    }];
+}, {
+    readonly name: "QuoteClassSet";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "codeHash";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "witness";
+        readonly indexed: true;
+    }, {
+        readonly type: "bool";
+        readonly name: "active";
+    }];
+}, {
+    readonly name: "QuoteClassExcluded";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "codeHash";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "by";
+        readonly indexed: true;
+    }];
+}, {
+    readonly name: "OpenQuotesSet";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "bool";
+        readonly name: "open";
+    }, {
+        readonly type: "address";
+        readonly name: "by";
+        readonly indexed: true;
+    }];
+}, {
+    readonly name: "QuoteClassActive";
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "codeHash";
+    }];
+}, {
+    readonly name: "OpenQuotesActive";
+    readonly type: "error";
+    readonly inputs: readonly [];
+}, {
+    readonly name: "QueuedBeforeBrake";
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "operation";
+    }];
+}];
+/** The two quote-admission operations by kind name, and the function each executes with. */
+export declare const QUOTE_ADMISSION_OPERATIONS: {
+    readonly SET_QUOTE_CLASS: "enableQuoteClassOf";
+    readonly OPEN_QUOTES: "allowOpenQuotes";
+};
+/**
+ * Whether `abi` (by default the packet's generated HookrRegistry ABI) carries every quote-admission item with the exact
+ * signature. The operations, brakes and reads below refuse an ABI without them, so nothing can build a call the
+ * release does not have; a caller that targets another registry build passes that build's ABI.
+ */
+export declare function registryHasQuoteAdmission(abi?: Abi): boolean;
+/** Whether `abi` carries the function a quote-admission operation executes with. */
+export declare function registryHasOperation(kind: keyof typeof QUOTE_ADMISSION_OPERATIONS, abi?: Abi): boolean;
+/** A quote class's runtime codehash: nonzero and never the empty-code hash. */
+export declare function quoteClassHash(value: unknown): Hash;
+/** keccak256 of each kind name, as the registry's public constants. */
+export declare const REGISTRY_KINDS: Record<RegistryOperationKind, Hash>;
+/**
+ * `queue(kind, arguments)` inputs for an operation, with the canonical ABI arguments. `abi` is the registry build's ABI
+ * (default: the packet's); a kind whose executing function it lacks is refused.
+ */
+export declare function encodeRegistryOperation(op: RegistryOperation, abi?: Abi): {
+    kind: Hash;
+    arguments: Hex;
+};
+/**
+ * Decodes an `OperationQueued(kind, arguments)` into the operation it will execute. Refuses an unknown kind and any
+ * non-canonical argument encoding, as HookrRegistry.queue does.
+ */
+export declare function decodeRegistryOperation(kind: Hash, args: Hex, abi?: Abi): RegistryOperation;
+/** HookrRegistry.operationHash: keccak256(abi.encode(chainId, registry, kind, arguments)). */
+export declare function registryOperationHash(chainId: bigint, registry: Address, kind: Hash, args: Hex): Hash;
+/** Owner call that queues `op`; it executes after the registry delay with `buildRegistryExecute`. */
+export declare function buildRegistryQueue(m: DeploymentManifest, op: RegistryOperation, abi?: Abi): Call;
+/** Owner call that executes a matured `op`: the same arguments the queue committed to. */
+export declare function buildRegistryExecute(m: DeploymentManifest, op: RegistryOperation, abi?: Abi): Call;
+/**
+ * Brake (owner or guardian, immediate): withdraws quote class `codeHash` from new pools and refuses every admission of
+ * it queued until now. Existing pools keep the quote they bound; a catalog entry for the same asset still qualifies it.
+ */
+export declare function buildExcludeQuoteClass(m: DeploymentManifest, codeHash: Hash, abi?: Abi): Call;
+/**
+ * Brake (owner or guardian, immediate): turns open quotes off for new pools and refuses every opening queued until
+ * now. The catalog, the admitted classes and native ETH still qualify; existing pools keep their quote.
+ */
+export declare function buildStopOpenQuotes(m: DeploymentManifest, abi?: Abi): Call;
+/** HookrRegistry.quoteState: whether open quotes are on, the last brake that stopped them and the admitted classes. */
+export interface QuoteState {
+    openQuotes: boolean;
+    /** Unix seconds of the last `stopOpenQuotesNow`; zero when never braked. */
+    openQuotesStoppedAt: number;
+    /** Runtime codehash of every admitted quote class, in the registry's order. */
+    classes: Hash[];
+}
+/** `quoteState()` calldata. */
+export declare function encodeQuoteStateCall(): Hex;
+/** Decodes a `quoteState()` result. */
+export declare function decodeQuoteState(data: Hex): QuoteState;
+/** `curatedQuote(asset)` calldata: native ETH, a catalog asset or a class member, never an open quote. */
+export declare function encodeCuratedQuoteCall(asset: Address): Hex;
+/** Decodes a `curatedQuote(asset)` result. */
+export declare function decodeCuratedQuote(data: Hex): boolean;
+/**
+ * Refuses an admission HookrRegistry would refuse on its own terms (the checks that do not read chain state).
+ * A Rules admission runs both phases, never fails open and carries exactly `RULES_GAS_LIMIT` gas.
+ */
+export declare function checkAdmission(a: Admission): void;
+/**
+ * A HookrRules admission: both phases, fail-closed, exactly RULES_GAS_LIMIT gas, and the Rules' schema id
+ * (`schemaHash`, RULES_CONFIG_SCHEMA_HASH, the keccak256 of RulesConfig's type string since r26; omitted, it is that
+ * id). Any other id is refused: HookrLane checks each admission's schemaHash against the Rules' own
+ * configSchemaHash(), so a Rules admitted under another id could never serve a lane pool.
+ */
+export declare function rulesAdmission(p: {
+    implementation: Address;
+    codeHash: Hash;
+    schemaHash?: Hash;
+    caps: Caps;
+    feeOnly: boolean;
+}): Admission;
+/**
+ * An advisory admission. `caps` is the advisory's admitted maximum; every pool that binds it reserves that maximum
+ * out of its caps (`poolCapsFor`).
+ */
+export declare function advisoryAdmission(p: {
+    implementation: Address;
+    codeHash: Hash;
+    schemaHash: Hash;
+    caps: Caps;
+    gasLimit: number;
+    phaseMask: number;
+    feeOnly: boolean;
+    failOpen: boolean;
+}): Admission;
+/**
+ * A pair-advisory admission for a root factory: kind ADVISORY, surcharge cap `maxLpFeePips`, BEFORE_SWAP, fee-only,
+ * no quote take, fail closed unless `failOpen`. HookrRootFactory deploys a root naming the advisory only when the
+ * root's advisory cap and gas are at most these and the advisory's runtime codehash is `codeHash`; a fail-open root
+ * additionally needs a fail-open admission (the rule HookrRoot applies when it binds a fail-open advisory).
+ */
+export declare function pairAdvisoryAdmission(p: {
+    implementation: Address;
+    codeHash: Hash;
+    schemaHash: Hash;
+    maxLpFeePips: number;
+    gasLimit: number;
+    failOpen?: boolean;
+}): Admission;
+/** The timelocked ADMIT of a pair advisory scoped to root factory `factory`. */
+export declare function factoryAdmission(factory: Address, admission: Admission): RegistryOperation;
+/**
+ * The checks HookrRootFactory.deploy runs on a pair root's advisory against its factory admission (read with
+ * `admission(factory, advisory)`) and the advisory's current runtime codehash. A fail-open root charges its full cap
+ * whenever the advisory fails, so it needs an admission that is fail-open, fee-only and without a quote take.
+ */
+export declare function checkPairRootAdmission(params: {
+    advisory: Address;
+    advisoryCapPips: number;
+    advisoryGasLimit: number;
+    advisoryFailOpen?: boolean;
+}, admitted: Admission, advisoryCodeHash: Hash): void;
+/**
+ * Brake (owner or guardian, immediate): permanently withdraws root factory `factory`'s admissions of the given pair
+ * advisories. Deployed pair roots keep their advisory; `rootStatus` then reads them as unverified.
+ */
+export declare function buildRevokeFactoryAdmissions(m: DeploymentManifest, factory: Address, implementations: readonly Address[]): Call;
+/** HookrRegistry.rootStatus: the advisory a root factory recorded for `root` and whether the root is verified. */
+export interface RootStatus {
+    advisory: Address;
+    verified: boolean;
+}
+/** `rootStatus(root)` calldata. */
+export declare function encodeRootStatusCall(root: Address): Hex;
+/**
+ * Decodes a `rootStatus(root)` result. `verified` is true for a registered root whose advisory, if any, is still
+ * admitted for its factory with an unchanged runtime codehash; gate pair roots on it.
+ */
+export declare function decodeRootStatus(data: Hex): RootStatus;
+/**
+ * Whether `code` is an EIP-7702 delegation designator (0xef0100 || target). The registry, the treasury and every
+ * HookrGoverned contract refuse such an account as owner, nominee or guardian.
+ */
+export declare function isDelegatedCode(code: Hex | undefined): boolean;
+/** Refuses an owner, nominee or guardian account whose code (from eth_getCode) is an EIP-7702 delegation. */
+export declare function checkUndelegated(account: Address, code: Hex | undefined): Address;