@raac/rpc 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/types/contracts/yearn/vault/getVaultInfo.d.ts

@@ -0,0 +1,43 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { YearnVaultEntry } from "../../../configs/chains/chain";
+import { ScaledValue, TokenAmount } from "../../../utils/amount";
+export interface YearnVaultInfo extends YearnVaultEntry {
+    /** Address of the vault asset. */
+    assetAddress: string;
+    apiVersion: string;
+    totalAssets: TokenAmount;
+    totalSupply: TokenAmount;
+    /** Assets held by the vault itself; all of them for a vault without strategies. */
+    totalIdle: TokenAmount;
+    /** Assets lent to strategies. */
+    totalDebt: TokenAmount;
+    /** Assets per whole share, in the vault asset's decimals. */
+    pricePerShare: ScaledValue;
+    /** Current APR from the profit still unlocking, as a WAD (0.05e18 = 5%); 0 when nothing is unlocking. */
+    apr: ScaledValue;
+    /** Reported profit not yet released to depositors, in the vault asset. */
+    lockedProfit: TokenAmount;
+    /** Seconds a reported profit takes to unlock. */
+    profitMaxUnlockTime: number;
+    /** Unix timestamp the locked profit finishes unlocking; 0 or in the past when nothing is unlocking. */
+    fullProfitUnlockDate: number;
+    /** Unix timestamp of the last report. */
+    lastProfitUpdate: number;
+    depositLimit: TokenAmount;
+    isShutdown: boolean;
+    /** Null when no accountant is set (no fees). */
+    accountant: string | null;
+    roleManager: string;
+    /** The default withdrawal queue; empty for a vault without strategies. */
+    strategies: string[];
+}
+/**
+ * Gets the vault-wide state of a Yearn V3 vault. For a user's position use `getUserInfo`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section (e.g. "spmusd"), or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault state, with amounts in base units.
+ */
+export declare function getVaultInfo(chainId: ChainId, vaultAddressOrId: string, provider?: Provider): Promise<YearnVaultInfo>;

package/dist/types/contracts/yearn/vault/getVaults.d.ts

@@ -0,0 +1,18 @@
+import { ChainId } from "../../../configs/chains";
+import { YearnVaultEntry } from "../../../configs/chains/chain";
+/**
+ * Lists the Yearn V3 vaults in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @returns Every configured vault; empty when the chain has none.
+ */
+export declare const getVaults: (chainId: ChainId) => YearnVaultEntry[];
+/**
+ * Looks up one Yearn V3 vault in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's config key or its address.
+ * @returns The vault entry.
+ * @throws If the vault is not configured on the chain.
+ */
+export declare const getVault: (chainId: ChainId, vaultAddressOrId: string) => YearnVaultEntry;

package/dist/types/contracts/yearn/vault/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./deposit";
+export * from "./getApr";
+export * from "./getUserInfo";
+export * from "./getVaultInfo";
+export * from "./getVaults";
+export * from "./mint";
+export * from "./previewDeposit";
+export * from "./previewMint";
+export * from "./previewRedeem";
+export * from "./previewWithdraw";
+export * from "./processReport";
+export * from "./redeem";
+export * from "./withdraw";

package/dist/types/contracts/yearn/vault/mint.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Mints exactly `shares`, pulling the assets they cost (see `previewMint`). The signer approves the vault for the
+ * asset first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param receiver - Who receives the shares.
+ * @param signer - The signer sending the transaction and paying the assets.
+ * @returns The mined transaction receipt.
+ */
+export declare const mint: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/previewDeposit.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Shares a deposit of `assets` would mint now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The shares, in base units.
+ */
+export declare const previewDeposit: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/previewMint.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Assets a mint of `shares` would pull now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault asset amount, in its base units.
+ */
+export declare const previewMint: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/previewRedeem.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Assets a redemption of `shares` would pay out now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault asset amount, in its base units.
+ */
+export declare const previewRedeem: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/previewWithdraw.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Shares a withdrawal of `assets` would burn now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The shares, in base units.
+ */
+export declare const previewWithdraw: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/processReport.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Reports a strategy, or with no `strategy` the vault itself. A self-report books any vault asset sent to the vault
+ * since the last report as profit and streams it to depositors over `profitMaxUnlockTime`; this is how rewards
+ * reach a vault without strategies. The signer needs the vault's REPORTING_MANAGER role.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param strategy - The strategy to report; defaults to the vault (self-report).
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const processReport: (chainId: ChainId, vaultAddressOrId: string, strategy: string | undefined, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/redeem.d.ts

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Redeems `shares` for the vault asset (see `previewRedeem`). Use this, with the user's full share balance, to
+ * exit completely. Uses Yearn's default max loss of 100%, which only matters for a vault with strategies.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param receiver - Who receives the assets.
+ * @param owner - Whose shares are burnt; the signer, or an owner that approved the signer for the shares.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const redeem: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, receiver: string, owner: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/withdraw.d.ts

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Withdraws exactly `assets` of the vault asset, burning the shares they cost (see `previewWithdraw`). Uses
+ * Yearn's default max loss of 0.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param receiver - Who receives the assets.
+ * @param owner - Whose shares are burnt; the signer, or an owner that approved the signer for the shares.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const withdraw: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, receiver: string, owner: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/zap/aladdin/inspectCurvePool.d.ts

@@ -0,0 +1,28 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { AladdinPoolType } from "./_types";
+export interface InspectedCoin {
+    address: string;
+    /** "?" when the token has no readable symbol. */
+    symbol: string;
+    decimals: number;
+}
+export interface InspectedCurvePool {
+    pool: string;
+    /** In pool index order: the index a route hop uses. */
+    coins: InspectedCoin[];
+    /** Zap pool types whose swap call the pool's bytecode has, best match first; empty when none is found. */
+    poolTypes: AladdinPoolType[];
+}
+/**
+ * Reads a Curve pool that may not be in the chain config, so a zap route can be built through it: its coins in index
+ * order with their symbols, and which zap pool types it can swap as. The types come from the swap function selectors in
+ * its deployed bytecode, which Vyper and Solidity dispatchers embed; a match means the call exists, not that the pool
+ * behaves as that type in every other way.
+ *
+ * @param chainId - The chain/network to use.
+ * @param pool - The pool address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @throws If the address has no code or no `coins(0)`.
+ */
+export declare const inspectCurvePool: (chainId: ChainId, pool: string, provider?: Provider) => Promise<InspectedCurvePool>;

package/dist/types/contracts/zeno/_helpers.d.ts

@@ -0,0 +1,17 @@
+import { Provider, Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+import { Auction, ZENO } from "../../typechain-types";
+/** The one ERC20 call the zeno methods make: the underlying held by a ZENO. */
+export declare const ERC20_ABI: string[];
+/** A ZENO bond. Bonds are created by the factory, so the address is passed in rather than read from the config. */
+export declare function getZenoContract(chainId: ChainId, zeno: string, runner?: Provider | Signer): ZENO;
+/** A ZENO auction. Auctions are created by the factory, so the address is passed in rather than read from the config. */
+export declare function getAuctionContract(chainId: ChainId, auction: string, runner?: Provider | Signer): Auction;
+/**
+ * A ZENO amount. ZENO takes its decimals from its underlying, so they come from the underlying's registry entry; a
+ * ZENO address itself is never in the registry. Falls back to 18 decimals when the underlying is not listed.
+ */
+export declare function toZenoAmount(chainId: ChainId, underlying: string, value: bigint, symbol?: string): TokenAmount;
+/** `ZENO.auction()` and other unset address fields read as the zero address; this maps that to null. */
+export declare function addressOrNull(address: string): string | null;

package/dist/types/contracts/zeno/buy.d.ts

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Buys ZENO: spends exactly `paymentAmount` of the payment token, sent to the issuer, at the price of the block it is
+ * mined in. Needs a payment token allowance for the auction (`wallet.assets.approveAsset`). Reverts while paused,
+ * outside the auction window, when the ZENO out would exceed what is left, or when it is below `minZenoOut`.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param paymentAmount Payment token to spend, in base units.
+ * @param minZenoOut The least ZENO to accept, in ZENO base units; `quoteBuy` sizes it.
+ * @param signer The buyer, who receives the ZENO.
+ * @returns The transaction receipt; its `ZENOPurchased` log carries the ZENO minted and the price paid.
+ */
+declare function buy(chainId: ChainId, auction: string, paymentAmount: bigint, minZenoOut: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default buy;

package/dist/types/contracts/zeno/createAuction.d.ts

@@ -1,17 +1,27 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
+/** How an auction's ZENO is backed by the underlying asset. Mirrors `IAuction.FundingMode`. */
+export declare enum FundingMode {
+    /** The ZENO must already hold underlying for the full allocation. */
+    Prefilled = 0,
+    /** The issuer tops up the underlying before maturity. */
+    Float = 1
+}
 /**
- * Creates a ZENO auction through the AuctionFactory.
+ * Creates a ZENO auction through the AuctionFactory. Only the factory owner can call this.
  * @param chainId The chain id.
  * @param zenoAddress The ZENO bond token sold.
- * @param usdcAddress The payment token bidders pay with.
- * @param businessAddress The issuer receiving the proceeds.
+ * @param tokenAddress The payment token bidders pay with.
+ * @param issuer The issuer receiving the proceeds.
  * @param auctionStartTime UNIX timestamp (seconds) the auction starts.
  * @param auctionEndTime UNIX timestamp (seconds) the auction ends.
  * @param startingPrice The Dutch auction starting price, in payment token base units per whole ZENO.
  * @param reservePrice The Dutch auction reserve price, in payment token base units per whole ZENO.
  * @param totalZenoAllocated The ZENO offered, in ZENO base units.
- * @param signer The signer sending the transaction.
+ * @param fundingMode How the ZENO is backed; `Prefilled` requires the ZENO to hold underlying for the full allocation.
+ * @param initialOwner The owner of the new auction.
+ * @param signer The factory owner.
+ * @returns The address of the new auction.
  */
-declare function createAuction(chainId: ChainId, zenoAddress: string, usdcAddress: string, businessAddress: string, auctionStartTime: bigint, auctionEndTime: bigint, startingPrice: bigint, reservePrice: bigint, totalZenoAllocated: bigint, signer: Signer): Promise<void>;
+declare function createAuction(chainId: ChainId, zenoAddress: string, tokenAddress: string, issuer: string, auctionStartTime: bigint, auctionEndTime: bigint, startingPrice: bigint, reservePrice: bigint, totalZenoAllocated: bigint, fundingMode: FundingMode, initialOwner: string, signer: Signer): Promise<string>;
 export default createAuction;

package/dist/types/contracts/zeno/createZeno.d.ts

@@ -1,4 +1,13 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function createZeno(chainId: ChainId, usdcAddress: string, maturityDate: string, signer: Signer): Promise<string>;
+/**
+ * Creates a ZENO bond through the ZENOFactory. Only the factory owner can call this.
+ * @param chainId The chain id.
+ * @param tokenAddress The underlying asset the bond redeems for.
+ * @param maturityDate UNIX timestamp (seconds) the bond matures. Must be in the future.
+ * @param initialOwner The owner of the new bond, typically the auction or a multisig.
+ * @param signer The factory owner.
+ * @returns The address of the new ZENO bond.
+ */
+declare function createZeno(chainId: ChainId, tokenAddress: string, maturityDate: bigint, initialOwner: string, signer: Signer): Promise<string>;
 export default createZeno;

package/dist/types/contracts/zeno/getAuctionState.d.ts

@@ -0,0 +1,45 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+import { FundingMode } from "./createAuction";
+/** A ZENO auction's terms and live state. Prices take the payment token's decimals, ZENO amounts the underlying's. */
+export interface AuctionState {
+    /** The auction contract. */
+    auction: string;
+    /** The ZENO bond it sells. */
+    zeno: string;
+    /** What buyers pay with. */
+    paymentToken: string;
+    /** Receives every payment. */
+    issuer: string;
+    fundingMode: FundingMode;
+    /** UNIX timestamp (seconds) buying opens. */
+    startTime: bigint;
+    /** UNIX timestamp (seconds) buying closes, unless it sells out first. */
+    endTime: bigint;
+    /** Price at `startTime`, in payment token base units per whole ZENO. */
+    startingPrice: TokenAmount;
+    /** Price at and after `endTime`; equal to `startingPrice` for a fixed-price bond. */
+    reservePrice: TokenAmount;
+    /** True when the price does not decay. */
+    isFixedPrice: boolean;
+    /** `getPrice()` as of the block read. A Dutch price keeps falling every block, also while paused. */
+    price: TokenAmount;
+    /** ZENO on offer. */
+    totalAllocated: TokenAmount;
+    /** ZENO not yet sold; `buy` reverts when it would mint more. */
+    totalRemaining: TokenAmount;
+    /** True while `buy` is halted by the pauser. */
+    paused: boolean;
+    /** True once past `endTime` or sold out, as `checkAuctionEnded()` says. */
+    ended: boolean;
+}
+/**
+ * Reads one auction's terms and live state.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The auction's state.
+ */
+declare function getAuctionState(chainId: ChainId, auction: string, provider?: Provider): Promise<AuctionState>;
+export default getAuctionState;

package/dist/types/contracts/zeno/getAuctions.d.ts

@@ -1,14 +1,17 @@
-import { Signer } from "ethers";
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
 import { TokenAmount } from "../../utils/amount";
+import { FundingMode } from "./createAuction";
 /** A ZENO auction, with its amounts in base units. */
 export interface AuctionDetails {
     /** The auction contract address. */
     auctionAddress: string;
     /** The ZENO bond token sold. */
     zenoAddress: string;
+    /** The payment token bidders pay with. */
+    tokenAddress: string;
     /** The issuer receiving the proceeds. */
-    businessAddress: string;
+    issuer: string;
     /** UNIX timestamp (seconds) the auction starts. */
     auctionStartTime: bigint;
     /** UNIX timestamp (seconds) the auction ends. */
@@ -23,19 +26,16 @@ export interface AuctionDetails {
     totalZENOAllocated: TokenAmount;
     /** ZENO still unsold, in ZENO base units. */
     totalZENORemaining: TokenAmount;
-    /** UNIX timestamp (seconds) of the last bid. */
-    lastBidTime: bigint;
-    /** The address of the last bidder. */
-    lastBidder: string;
-    /** The last bid, in payment token base units. */
-    lastBidAmount: TokenAmount;
+    /** How the auction's ZENO is backed by the underlying asset. */
+    fundingMode: FundingMode;
 }
 /**
  * Lists every auction created by the AuctionFactory.
  * @param chainId The chain id.
- * @param signer The signer to read with.
- * @returns One record per auction. Price and bid amounts use the auction's payment token, ZENO amounts the ZENO
- * token; decimals and symbols come from the chain config registry and fall back to 18 when the token is not listed.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns One record per auction. Price amounts use the auction's payment token, ZENO amounts the ZENO's underlying,
+ * whose decimals ZENO shares; decimals and symbols come from the chain config registry and fall back to 18 when the
+ * token is not listed.
  */
-declare function getAuctions(chainId: ChainId, signer: Signer): Promise<AuctionDetails[]>;
+declare function getAuctions(chainId: ChainId, provider?: Provider): Promise<AuctionDetails[]>;
 export default getAuctions;

package/dist/types/contracts/zeno/getBondState.d.ts

@@ -0,0 +1,42 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/** A ZENO bond's live state. ZENO amounts take the underlying's decimals. */
+export interface BondState {
+    /** The ZENO bond contract. */
+    zeno: string;
+    /** ERC20 name, e.g. `ZENO Bond 20270101`. */
+    name: string;
+    /** ERC20 symbol, e.g. `ZENO-20270101`. */
+    symbol: string;
+    /** What 1 ZENO redeems for at maturity. */
+    underlying: string;
+    /** The auction bound by `setAuction`, the only one that can mint; null until it is set. */
+    auction: string | null;
+    /** UNIX timestamp (seconds) the bond matures. */
+    maturityDate: bigint;
+    /** True once maturity has passed. Redemption also needs `isFunded`. */
+    isRedeemable: boolean;
+    /** ZENO minted over the bond's lifetime; never falls. */
+    totalMinted: TokenAmount;
+    /** ZENO outstanding, still to be redeemed. */
+    totalSupply: TokenAmount;
+    /** ZENO redeemed for the underlying. */
+    totalRedeemed: TokenAmount;
+    /** Underlying held by the ZENO, in the underlying's base units. */
+    collateral: TokenAmount;
+    /** Underlying above outstanding supply, which the owner may sweep once the auction has ended. */
+    sweepableSurplus: TokenAmount;
+    /** True when collateral covers outstanding supply. `redeem` reverts with `InsufficientCollateral` while it is false, which only a Float bond the issuer has not topped up can reach. */
+    isFunded: boolean;
+}
+/**
+ * Reads a ZENO bond's live state: supply, collateral and whether it can be redeemed. Collateral is read here rather
+ * than indexed, because top-ups are plain transfers on the underlying that no ZENO event records.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The bond's state.
+ */
+declare function getBondState(chainId: ChainId, zeno: string, provider?: Provider): Promise<BondState>;
+export default getBondState;

package/dist/types/contracts/zeno/getPrice.d.ts

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Reads an auction's current price. Read it right before `buy` to size `minZenoOut`: a Dutch price falls every block.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The price in payment token base units per whole ZENO.
+ */
+declare function getPrice(chainId: ChainId, auction: string, provider?: Provider): Promise<TokenAmount>;
+export default getPrice;

package/dist/types/contracts/zeno/getZenos.d.ts

@@ -1,4 +1,27 @@
-import { Signer } from "ethers";
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function getZenos(chainId: ChainId, signer: Signer): Promise<any[]>;
+import { TokenAmount } from "../../utils/amount";
+/** A ZENO bond, with its amounts in base units. */
+export interface ZenoDetails {
+    /** The ZENO bond contract address. */
+    zenoAddress: string;
+    /** UNIX timestamp (seconds) the bond matures. */
+    maturityDate: bigint;
+    /** The bond's ERC20 name, e.g. `ZENO Bond 20270101`. */
+    name: string;
+    /** The bond's ERC20 symbol, e.g. `ZENO-20270101`. */
+    symbol: string;
+    /** ZENO minted over the bond's lifetime, in ZENO base units. */
+    totalMinted: TokenAmount;
+    /** ZENO redeemed for the underlying, in ZENO base units. */
+    totalRedeemed: TokenAmount;
+}
+/**
+ * Lists every ZENO bond created by the ZENOFactory.
+ * @param chainId The chain id.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns One record per bond. ZENO shares its underlying's decimals, so amounts take the underlying's from the chain
+ * config registry and fall back to 18 when it is not listed.
+ */
+declare function getZenos(chainId: ChainId, provider?: Provider): Promise<ZenoDetails[]>;
 export default getZenos;

package/dist/types/contracts/zeno/grantRole.d.ts

@@ -0,0 +1,22 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Grants an auction role, e.g. PAUSER_ROLE to a guardian bot. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to grant it to.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function grantRole(chainId: ChainId, auction: string, role: string, account: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * Revokes an auction role. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to revoke it from.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function revokeRole(chainId: ChainId, auction: string, role: string, account: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/zeno/pause.d.ts

@@ -0,0 +1,18 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Halts `buy` on an auction. PAUSER_ROLE only. A Dutch price keeps falling while paused.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param signer A PAUSER_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function pause(chainId: ChainId, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * Resumes `buy` on an auction. DEFAULT_ADMIN_ROLE only, so a compromised pauser cannot reopen buying.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function unpause(chainId: ChainId, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/zeno/priceAt.d.ts

@@ -0,0 +1,20 @@
+/** The auction terms that set its price. All values as the contract stores them. */
+export interface AuctionPriceTerms {
+    /** UNIX timestamp (seconds). */
+    startTime: bigint;
+    /** UNIX timestamp (seconds). */
+    endTime: bigint;
+    /** Payment token base units per whole ZENO. */
+    startingPrice: bigint;
+    /** Payment token base units per whole ZENO. */
+    reservePrice: bigint;
+}
+/**
+ * An auction's price at `now`, computed locally without an RPC call. Mirrors `Auction.getPrice()` exactly, truncating
+ * division included: the starting price before the window, the reserve from `endTime` on, a linear fall between.
+ *
+ * @param terms The auction's price terms, e.g. from `getAuctionState` or the subgraph's `BondAuction`.
+ * @param now UNIX timestamp (seconds). Use the latest block timestamp to match the contract exactly.
+ * @returns The price in payment token base units per whole ZENO.
+ */
+export declare const priceAt: (terms: AuctionPriceTerms, now: bigint) => bigint;

package/dist/types/contracts/zeno/quoteBuy.d.ts

@@ -0,0 +1,34 @@
+export interface BuyQuoteInput {
+    /** Price in payment token base units per whole ZENO, from `priceAt` or `getPrice`. */
+    price: bigint;
+    /** Payment token to spend, in base units. */
+    paymentAmount: bigint;
+    /** ZENO decimals, equal to the underlying's. */
+    zenoDecimals: number;
+    /** ZENO left to sell, in base units (`totalRemaining`). */
+    totalRemaining: bigint;
+    /** Tolerance below `zenoOut` for `minZenoOut`, in basis points (10000 = 100%). Defaults to 0. */
+    slippageBps?: bigint;
+}
+export interface BuyQuote {
+    /** ZENO minted for `paymentAmount` at `price`, in base units. */
+    zenoOut: bigint;
+    /** `zenoOut` less the slippage tolerance; pass it to `buy` as `minZenoOut`. */
+    minZenoOut: bigint;
+    /** The largest payment `buy` accepts at `price`; anything above mints more than `totalRemaining` and reverts. */
+    maxPayment: bigint;
+    /** True when `paymentAmount` is above `maxPayment`. */
+    exceedsRemaining: boolean;
+}
+/**
+ * What a buy mints, computed locally without an RPC call with `Auction.buy`'s integer maths:
+ * `zenoOut = paymentAmount * 10^zenoDecimals / price`, truncated.
+ *
+ * A Dutch price only falls, so a buy mined after the quote mints at least `zenoOut`; `minZenoOut` guards against a
+ * fixed price or a stale quote. The same fall means a payment at exactly `maxPayment` can revert a block later, so
+ * leave headroom when buying out the remainder.
+ *
+ * @param input The price, payment, ZENO decimals, remaining supply and slippage tolerance.
+ * @returns The ZENO out, the `minZenoOut` to send, and the payment ceiling.
+ */
+export declare const quoteBuy: (input: BuyQuoteInput) => BuyQuote;

package/dist/types/contracts/zeno/redeem.d.ts

@@ -0,0 +1,20 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Redeems ZENO 1:1 for the underlying. Reverts before maturity, and while the bond's collateral is short of its
+ * outstanding supply (`getBondState(...).isFunded`).
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param amount ZENO to redeem, in base units.
+ * @param signer The holder, who receives the underlying.
+ * @returns The transaction receipt.
+ */
+export declare function redeem(chainId: ChainId, zeno: string, amount: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * Redeems the signer's whole ZENO balance for the underlying. Same conditions as `redeem`.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param signer The holder, who receives the underlying.
+ * @returns The transaction receipt.
+ */
+export declare function redeemAll(chainId: ChainId, zeno: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/zeno/setAuction.d.ts

@@ -0,0 +1,13 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Binds a ZENO to the auction that sells it. One-shot, ZENO owner only; reverts unless the auction's `zeno()` points
+ * back at this ZENO. Until it is set, the auction's buys revert.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param auction The auction created for it.
+ * @param signer The ZENO owner.
+ * @returns The transaction receipt.
+ */
+declare function setAuction(chainId: ChainId, zeno: string, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default setAuction;