@logswap/sdk 0.5.49 → 0.5.51

package/dist/fpool.d.ts

@@ -110,6 +110,16 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "kind";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "pure";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -195,6 +205,20 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "nameOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -276,10 +300,6 @@ export declare const fPolicyBaseAbi: readonly [{
             readonly name: "phi";
             readonly internalType: "uint256";
             readonly type: "uint256";
-        }, {
-            readonly name: "kind";
-            readonly internalType: "enum Kind";
-            readonly type: "uint8";
         }, {
             readonly name: "policy";
             readonly internalType: "address";
@@ -301,6 +321,24 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "uint8";
     }];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "from";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "onMigrate";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint8";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -397,6 +435,30 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly name: "proposeAuthority";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "quoteCurated";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "quoteListed";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -407,6 +469,44 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly name: "setHarvestCut";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "name_";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "setName";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setQuoteCurated";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setQuoteListed";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -471,6 +571,46 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "HarvestCutSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "name";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: false;
+    }];
+    readonly name: "NameSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "QuoteCuratedSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "QuoteListed";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -486,10 +626,18 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "RulesSet";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "BadFee";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "BadRate";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NoCreator";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -502,6 +650,22 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "NotManager";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotRegistry";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "OneBase";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "QuoteNotListed";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -547,11 +711,11 @@ export interface FPoolState {
     policy: Address;
     /** Whether the policy asked to be consulted on swaps ({@link ASK_SWAP}) and mints ({@link ASK_MINT}) — the desk's policy does, no other. */
     asks: number;
-    /** The sponsor's own label for this pool, mutable and never identity. "" when unnamed. */
+    /** The sponsor's own label for this pool — the policy's word (decisions 049), mutable and never identity. "" when unnamed. */
     name: string;
     /** The block of the last harvest / composition action: no swap runs in it. */
     restructureBlock: number;
-    /** The rung — see {@link FPoolKind}. */
+    /** What the pool is — its POLICY's self-description (decisions 049); see {@link FPoolKind}. */
     kind: FPoolKind;
     /** False before the first seed — and between a retire and the next one (decisions 032). */
     seeded: boolean;
@@ -568,25 +732,27 @@ export interface FPoolState {
 /** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
 export declare function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolState>;
 /**
- * The kind of pool (decisions 036, 038, 044) — what the manager promises structurally, whatever
- * the pool's policy answers. `public`: the protocol's own pool — its policy requires the collector as
- * creator; no gate, no operator. `private`, the desk: the one kind whose policy may gate swaps and
- * mints, with an operator that reshapes the legs between generations. `pol`, a treasury's pool
- * or a basket: composition and access fixed at birth. `pad`, a launch: a POL whose harvest is
- * income only whatever its policy says and whose seed the contract minted to 0xdead — one asset,
- * open to all. private → pol → pad is the ladder of rigidity; public is a pol held by the
- * protocol. Every rate, role and gate is the policy's.
+ * The kind of pool — the POLICY's self-description (decisions 049: the manager knows no kind; the
+ * policy the key names is the kind, and what it promises is its code). `public`: the protocol's
+ * own pool — its policy requires the collector as creator; no gate, no operator. `private`, the
+ * desk: the one whose policy may gate swaps and mints, with an operator that reshapes the legs
+ * between generations. `pol`, a treasury's pool, one base: composition and access fixed at
+ * birth. `pad`, a launch, one base: its policy answers income only at every harvest and declared
+ * its seed the pool's at birth (`SEED_TO_DEAD`) — open to all. private → pol → pad is the ladder
+ * of rigidity; public is a pol held by the protocol. Every rate, role and gate is the policy's.
  */
 export type FPoolKind = "public" | "private" | "pol" | "pad";
-/** The key's enum values. */
-export declare const F_KIND: {
-    readonly public: 0;
-    readonly private: 1;
-    readonly pol: 2;
-    readonly pad: 3;
-};
-export declare function fPoolKindOf(n: number | bigint): FPoolKind;
-/** The deployment's policy for a kind (decisions 044): what a key of that kind names. */
+/** The policy's birth-time declaration that the seed's shares are the pool's (a pad's), in `asks`. */
+export declare const SEED_TO_DEAD = 4;
+/**
+ * What a policy IS — its `kind()` tag, read once per policy address and cached for the client's
+ * chain: a pool's kind is its policy's word (decisions 049), never the manager's. An unknown tag
+ * (a policy that is not one of the protocol's four shapes) throws; the app has no screen for it.
+ */
+export declare function fPoolKindOfPolicy(c: LogswapClient, policy: Address): Promise<FPoolKind>;
+/** The pool's label, as its policy holds it (decisions 049). "" when unnamed. */
+export declare function fPoolNameOf(c: LogswapClient, poolId: Hex, policy?: Address): Promise<string>;
+/** The deployment's policy for a kind (decisions 044, 049): the protocol's policy that IS that kind. */
 export declare function fPoolPolicyFor(c: LogswapClient, kind: FPoolKind): Address;
 /** The policy a pool named in its key — one read; {@link getFPool} carries it too. */
 export declare function fPoolPolicyOf(c: LogswapClient, poolId: Hex): Promise<Address>;
@@ -857,12 +1023,16 @@ export interface FPoolCreateArgs {
     weights: bigint[];
     /** Fixed fee, WAD. The base-for-base fee is pinned at 2φ on-chain. */
     phi: bigint;
-    /** The rung (decisions 036) — see {@link FPoolKind}. In the key: the pool's identity, never changed after. */
+    /**
+     * Which of the protocol's four the pool is — see {@link FPoolKind}. NOT a key field (decisions
+     * 049: the manager knows no kind): it selects the deployment's policy of that kind when `policy`
+     * is not named ({@link fPoolPolicyFor}), and it is what the policy will say it is.
+     */
     kind: FPoolKind;
     /**
-     * The pool's policy (decisions 041, 044): the contract the key names, approved by the protocol
-     * for the kind. Defaults to the deployment's policy for `kind` ({@link fPoolPolicyFor}) — the one
-     * every protocol pool names.
+     * The pool's policy (decisions 041, 044, 049): the contract the key names, approved by the
+     * registry, and the pool's kind. Defaults to the deployment's policy for `kind`
+     * ({@link fPoolPolicyFor}) — the one every protocol pool names.
      */
     policy?: Address;
     /** Who is born holding the pool: immutable identity, the pool's first authority (the policy records it). */
@@ -871,7 +1041,7 @@ export interface FPoolCreateArgs {
      * The differentiator, and nothing else. Identity is the key's hash, so one sponsor cannot run
      * two pools of the same shape without varying it — the second `initialize` would land on the
      * first pool's id. Defaults to zero, which is the first book of any shape. A pool's NAME is not
-     * this: names are mutable state (`fPoolSetName`), so a rename forks nothing.
+     * this: names are the policy's mutable state (`fPoolSetName`), so a rename forks nothing.
      */
     salt?: Hex;
     account: Address;
@@ -884,13 +1054,12 @@ export declare function sortFPoolLegs<T>(bases: Address[], ...companions: T[][])
     bases: Address[];
     companions: T[][];
 };
-/** The key as the manager hashes it: legs sorted, the kind's policy filled in when none is named. */
+/** The key as the manager hashes it: legs sorted, the kind's policy filled in when none is named; no kind in it (049). */
 export declare function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): {
     quote: `0x${string}`;
     bases: `0x${string}`[];
     weights: bigint[];
     phi: bigint;
-    kind: 0 | 1 | 3 | 2;
     policy: `0x${string}`;
     creator: `0x${string}`;
     salt: `0x${string}`;
@@ -1020,7 +1189,7 @@ export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
         amountIn: bigint;
         minOut?: bigint;
     };
-    /** The pool's label, set in the batch (≤ 31 bytes of UTF-8). */
+    /** The pool's label (≤ 31 bytes of UTF-8) — the policy's word (049), written right after the batch by {@link fPoolLaunch}; not in the batch. */
     name?: string;
     /**
      * The pool already exists (a previous launch got as far as `initialize` and no further — a seed
@@ -1044,9 +1213,9 @@ export declare function fPoolLaunchCalls(poolId: Hex, a: FPoolLaunchArgs & ({
     x0: bigint[];
 })): Hex[];
 /**
- * The desk's opening posture, on its policy (decisions 044): gated minting, the creator listed. No
- * appointment: the authority is the operator until one is appointed (decisions 037). Two writes
- * to `PrivatePolicy`; the launch batch cannot carry them (they are not manager calls).
+ * The desk's opening posture, on its policy (decisions 044, 048): gated minting, the creator a
+ * minter. No appointment: the authority is the operator until one is appointed (decisions 037).
+ * Two writes to `PrivatePolicy`; the launch batch cannot carry them (they are not manager calls).
  */
 export declare function fPoolDeskOpening(c: LogswapClient, a: {
     poolId: Hex;
@@ -1108,35 +1277,53 @@ export declare function fPoolSetGates(c: LogswapClient, a: {
     policy?: Address;
 }): Promise<`0x${string}`>;
 /**
- * Add to or remove from the pool's list, in one call (the authority, on the desk's policy). The list
- * is keyed by the authority that granted it: a handover starts the buyer with an empty one.
+ * Add to or remove from the pool's MINTERS — who may mint, and swap (a zap in is both under one
+ * lock) — in one call (the authority, on the desk's policy; decisions 048). The list is keyed by
+ * the authority that granted it: a handover starts the buyer with an empty one. Stamps the
+ * block: no swap lands in it (047).
  */
-export declare function fPoolSetAllowed(c: LogswapClient, a: {
+export declare function fPoolSetMinters(c: LogswapClient, a: {
+    poolId: Hex;
+    who: readonly Address[];
+    allowed: boolean;
+    account: Address;
+    policy?: Address;
+}): Promise<`0x${string}`>;
+/** Add to or remove from the pool's TAKERS — who may swap only — in one call (the authority; decisions 048). Stamps the block. */
+export declare function fPoolSetTakers(c: LogswapClient, a: {
     poolId: Hex;
     who: readonly Address[];
     allowed: boolean;
     account: Address;
     policy?: Address;
 }): Promise<`0x${string}`>;
-/** Whether `who` is on the pool's list under its current authority (consulted only while a gate is on). */
+/** On the pool's minters under its current authority: may mint, and swap. */
+export declare function fPoolIsMinter(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean>;
+/** On the pool's takers under its current authority: may swap only. */
+export declare function fPoolIsTaker(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean>;
+/** May swap: a minter or a taker (consulted only while the swap gate is on). */
 export declare function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean>;
-/** Label the pool — the sponsor's own words, mutable, never identity. At most 31 bytes of UTF-8. */
+/** Label the pool — the authority's own words on the pool's POLICY (decisions 049), mutable, never identity. At most 31 bytes of UTF-8. */
 export declare function fPoolSetName(c: LogswapClient, a: {
     poolId: Hex;
     name: string;
     account: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
 /**
- * What the PROTOCOL says an address is — "Keyrock". Only `feeCollector` may write it, which is
- * what makes it an attestation rather than a claim anyone could make about themselves.
+ * What the PROTOCOL says an address is — "Keyrock" — on the REGISTRY (decisions 049). Only its
+ * owner, the LOG authority, may write it, which is what makes it an attestation rather than a
+ * claim anyone could make about themselves.
  */
 export declare function fPoolSetSponsorName(c: LogswapClient, a: {
     who: Address;
     name: string;
     account: Address;
 }): Promise<`0x${string}`>;
-/** The protocol's attestation for an address, or "" when unattested — which most addresses are. */
+/** The protocol's attestation for an address, or "" when unattested — which most addresses are, and every address on a deployment with no registry. */
 export declare function fPoolSponsorName(c: LogswapClient, who: Address): Promise<string>;
+/** The registry the manager asks at every birth — `addresses.policyRegistry`, else the manager's word; zero on a bare deployment. */
+export declare function fPoolRegistryOf(c: LogswapClient): Promise<Address>;
 /** Who runs the pool (decisions 037): the appointed operator, or the authority until one is. */
 export declare function fPoolOperatorOf(s: Pick<FPoolRoles, "authority" | "operator">): Address;
 /**
@@ -1189,7 +1376,7 @@ export interface DiscoveredFPool {
     weights: bigint[];
     phi: bigint;
     kind: FPoolKind;
-    /** The pool's policy — the contract the key names (decisions 041, 044, 045). */
+    /** The pool's policy AT BIRTH — the contract the key names (decisions 041, 044, 045). The LIVE one is {@link getFPool}'s `policy`: the registry's owner may have moved the pool (046, `PolicyMigrated`). */
     policy: Address;
     /** Who was born holding the pool (immutable). The LIVE authority is the policy's — {@link getFPoolRoles}. */
     creator: Address;
@@ -1208,9 +1395,10 @@ export interface DiscoveredFPool {
     shape: FPoolShape;
 }
 /**
- * Every F pool ever created, from `Initialize` logs alone. Possible only because the event
- * carries the full key preimage (bases, weights, phi, pad) — the poolId is a hash and could
- * never be inverted; contracts PR #17 exists for exactly this call.
+ * Every F pool ever created, from `Initialize` logs alone — plus one `kind()` read per distinct
+ * policy, cached. Possible only because the event carries the full key preimage (bases,
+ * weights, phi, policy) — the poolId is a hash and could never be inverted; contracts PR #17
+ * exists for exactly this call.
  */
 export declare function discoverFPools(c: LogswapClient, opts?: {
     fromBlock?: bigint;