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

package/dist/types/configs/chains/index.d.ts

@@ -128,6 +128,14 @@ declare const chains: {
             };
         };
         proposals: any[];
+        psm: {
+            "rpsm-susds": {
+                id: string;
+                name: string;
+                contract: string;
+                rateProvider: string;
+            };
+        };
         pools: {
             stabilitypool: {
                 id: string;
@@ -164,6 +172,13 @@ declare const chains: {
                 decimals: number;
                 contract: string;
             };
+            susds: {
+                id: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                contract: string;
+            };
             xpm: {
                 id: string;
                 name: string;
@@ -380,6 +395,14 @@ export declare const configs: {
             };
         };
         proposals: any[];
+        psm: {
+            "rpsm-susds": {
+                id: string;
+                name: string;
+                contract: string;
+                rateProvider: string;
+            };
+        };
         pools: {
             stabilitypool: {
                 id: string;
@@ -416,6 +439,13 @@ export declare const configs: {
                 decimals: number;
                 contract: string;
             };
+            susds: {
+                id: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                contract: string;
+            };
             xpm: {
                 id: string;
                 name: string;

package/dist/types/configs/index.d.ts

@@ -128,6 +128,14 @@ declare function getChainsConfig(): {
             };
         };
         proposals: any[];
+        psm: {
+            "rpsm-susds": {
+                id: string;
+                name: string;
+                contract: string;
+                rateProvider: string;
+            };
+        };
         pools: {
             stabilitypool: {
                 id: string;
@@ -164,6 +172,13 @@ declare function getChainsConfig(): {
                 decimals: number;
                 contract: string;
             };
+            susds: {
+                id: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                contract: string;
+            };
             xpm: {
                 id: string;
                 name: string;

package/dist/types/contracts/complianceRegistry/getStatuses.d.ts

@@ -0,0 +1,25 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+/** Whether an address is blocked by the ComplianceRegistry, and why. */
+export interface ComplianceStatus {
+    address: string;
+    /** `isBlacklisted`: on the registry's own list, or sanctioned. */
+    blocked: boolean;
+    /** On the registry's own list; null when its storage layout could not be confirmed. */
+    listed: boolean | null;
+    /** On the external sanctions list; unblacklisting does not clear this. */
+    sanctioned: boolean;
+}
+/**
+ * Reads the sanctions list and each address's compliance status. `_blacklisted` is private, so the own-list flag is
+ * read from storage, trusted only when slot 2 matches `sanctionsList()`; otherwise `listed` is null where it cannot
+ * be told apart from a sanction.
+ * @param chainId The chain id.
+ * @param addresses The addresses to check.
+ * @param provider The provider to read with.
+ */
+declare function getStatuses(chainId: ChainId, addresses: readonly string[], provider: Provider): Promise<{
+    sanctionsList: string;
+    statuses: ComplianceStatus[];
+}>;
+export default getStatuses;

package/dist/types/contracts/crvUSDToUSDOracle/getState.d.ts

@@ -0,0 +1,36 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+/** Which route the crvUSD/USD price came from, as `getLatestPrice`'s third value reports it. */
+export declare const CRVUSD_PRICE_SOURCES: readonly ["chainlink", "curve", "fallback"];
+export type CrvUSDPriceSource = (typeof CRVUSD_PRICE_SOURCES)[number];
+/** CrvUSDToUSDOracle state. Prices are 18-decimal USD; times are seconds. */
+export interface CrvUSDToUSDOracleState {
+    owner: string;
+    /** Null when every route reverts. */
+    price: bigint | null;
+    priceTimestamp: number | null;
+    source: CrvUSDPriceSource | null;
+    circuitBreakerEnabled: boolean;
+    minPriceThreshold: bigint;
+    maxPriceThreshold: bigint;
+    fallbackPriceInUSD: bigint;
+    lastFallbackUpdateTimestamp: number;
+    /** How stale the Chainlink crvUSD/USD feed may be before the Curve route is tried. */
+    maxStableStaleTime: bigint;
+    /** How stale the ETH/USD feed may be before the fallback price is used. */
+    maxUnstableStaleTime: bigint;
+    crvUSDDataFeed: string;
+    ethDataFeed: string;
+    curveOracle: string;
+    /** Coin index the Curve oracle prices ETH in. */
+    K: bigint;
+}
+/**
+ * Reads the crvUSD/USD oracle's current price and route and every setting behind them. A reverting price read gives
+ * `price: null` instead of failing, since that is exactly when the settings matter.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ * @param oracleAddress Optional address, e.g. from `housePrices.getState`; defaults to the registry's `crvusdtousdoracle`.
+ */
+declare function getState(chainId: ChainId, provider: Provider, oracleAddress?: string): Promise<CrvUSDToUSDOracleState>;
+export default getState;

package/dist/types/contracts/curve/common/_helpers.d.ts

@@ -0,0 +1,31 @@
+import { ethers, Provider, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry, CurvePoolFlavour, CurvePools } from "../../../configs/chains/chain";
+/**
+ * Reads every Curve pool flavour shares. Coin indexes differ (uint256 vs int128) only in swap and liquidity
+ * methods, which are not here.
+ */
+export declare const CURVE_POOL_READ_ABI: string[];
+export declare const getCurvePools: (chainId: ChainId) => CurvePools;
+/** Resolves a Curve pool by its config key (any casing) or its address. */
+export declare function resolveCurvePool(chainId: ChainId, poolAddressOrId: string): CurvePoolEntry;
+export declare function getCurvePoolContract(chainId: ChainId, poolAddressOrId: string, provider?: Provider): {
+    entry: CurvePoolEntry;
+    contract: ethers.Contract;
+    provider: ethers.Provider;
+};
+/**
+ * Swap and liquidity methods per flavour. twocrypto-ng and tricrypto-ng index coins with uint256 and take fixed
+ * uint256[2] / uint256[3] arrays; stableswap-ng indexes with int128 and takes a dynamic uint256[]. Encoding one
+ * against another reverts, so the pool's configured flavour picks the ABI.
+ */
+export declare const CURVE_POOL_WRITE_ABI: Record<CurvePoolFlavour, string[]>;
+/** The pool contract with its flavour's swap and liquidity ABI, bound to a signer or provider. */
+export declare function getCurvePoolFlavourContract(chainId: ChainId, poolAddressOrId: string, runner?: Signer | Provider): {
+    entry: CurvePoolEntry;
+    contract: ethers.Contract;
+};
+/** Checks an amounts array matches the pool's coin count before it reaches the encoder. */
+export declare function assertCoinCount(entry: CurvePoolEntry, amounts: readonly bigint[], what: string): void;
+/** Checks a coin index is inside the pool. */
+export declare function assertCoinIndex(entry: CurvePoolEntry, index: number): void;

package/dist/types/contracts/curve/common/addLiquidity.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Deposits coins into a Curve pool for LP tokens. The caller approves each non-zero coin to the pool first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param amounts - One amount per coin, in pool order and each coin's base units; 0 for a coin not deposited.
+ * @param minMintAmount - The least LP to accept (18 decimals); the deposit reverts below it. See `calcTokenAmount`.
+ * @param receiver - Who receives the LP tokens.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const addLiquidity: (chainId: ChainId, poolAddressOrId: string, amounts: bigint[], minMintAmount: bigint, receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/curve/common/calcTokenAmount.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * LP tokens a deposit (or, with `isDeposit` false, a proportional withdrawal) of `amounts` mints or burns at the
+ * pool's current state. Fees are not included, so apply a slippage margin before using it as a minimum.
+ *
+ * @param amounts - One amount per coin, in pool order and each coin's base units.
+ * @returns LP tokens (18 decimals).
+ */
+export declare const calcTokenAmount: (chainId: ChainId, poolAddressOrId: string, amounts: bigint[], isDeposit: boolean, provider?: Provider) => Promise<bigint>;

package/dist/types/contracts/curve/common/calcWithdrawOneCoin.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * How much of coin `i` burning `lpAmount` LP tokens returns at the pool's current state.
+ *
+ * @returns The output amount in coin `i`'s base units.
+ */
+export declare const calcWithdrawOneCoin: (chainId: ChainId, poolAddressOrId: string, lpAmount: bigint, i: number, provider?: Provider) => Promise<bigint>;

package/dist/types/contracts/curve/common/exchange.d.ts

@@ -0,0 +1,16 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Swaps `amountIn` of coin `i` for coin `j` in a Curve pool. The caller approves coin `i` to the pool first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param i - Index of the coin sold, in pool order.
+ * @param j - Index of the coin bought, in pool order.
+ * @param amountIn - Amount of coin `i`, in its base units.
+ * @param minAmountOut - The least of coin `j` to accept, in its base units; the swap reverts below it.
+ * @param receiver - Who receives coin `j`.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const exchange: (chainId: ChainId, poolAddressOrId: string, i: number, j: number, amountIn: bigint, minAmountOut: bigint, receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/curve/common/getDy.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * How much of coin `j` a swap of `amountIn` of coin `i` returns at the pool's current state, before slippage.
+ *
+ * @returns The output amount in coin `j`'s base units.
+ */
+export declare const getDy: (chainId: ChainId, poolAddressOrId: string, i: number, j: number, amountIn: bigint, provider?: Provider) => Promise<bigint>;

package/dist/types/contracts/curve/common/getPoolInterface.d.ts

@@ -0,0 +1,12 @@
+import { ethers } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * The pool's swap and liquidity ABI for its flavour, for encoding calls that are sent elsewhere (e.g. queued in a
+ * Safe) instead of through `exchange` / `addLiquidity` / `removeLiquidity` / `removeLiquidityOneCoin`. Reads the config
+ * only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @returns The interface (stableswap-ng indexes coins with int128 and takes dynamic arrays, the crypto pools uint256 and fixed arrays).
+ */
+export declare const getPoolInterface: (chainId: ChainId, poolAddressOrId: string) => ethers.Interface;

package/dist/types/contracts/curve/common/getPoolState.d.ts

@@ -0,0 +1,43 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { ScaledValue, TokenAmount } from "../../../utils/amount";
+import { CurvePool } from "./getPools";
+export interface CurvePoolState {
+    pool: CurvePool;
+    /** Coin balances in pool index order, each in its own decimals and symbol. */
+    balances: TokenAmount[];
+    /** LP tokens in circulation (the pool is its own LP token, 18 decimals). */
+    totalSupply: TokenAmount;
+    /** `get_virtual_price()`: underlying per LP token, only grows with fees. */
+    virtualPrice: TokenAmount;
+    /** Value of one LP token in coin 0: `lp_price()` on crypto pools, the balances at oracle prices on stableswap pools. */
+    lpPrice: TokenAmount;
+    /** Price of each coin in coin 0, 18 decimals, from the pool's EMA oracle; `oraclePrices[0]` is 1. */
+    oraclePrices: TokenAmount[];
+    /** Price of each coin in coin 0 right now: `last_prices` on crypto pools, `get_p` on stableswap pools. */
+    spotPrices: TokenAmount[];
+    /** Crypto pools only: where liquidity is concentrated (`price_scale`), in coin 0. Null on stableswap pools. */
+    priceScale: TokenAmount[] | null;
+    /** Each balance valued in coin 0 at the oracle price; their sum is the pool's TVL in coin 0. */
+    values: TokenAmount[];
+    tvl: TokenAmount;
+    /** Current swap fee as a fraction (Curve's 1e10 scale). */
+    fee: ScaledValue;
+    /** Crypto pools: the fee range the current fee moves in, as fractions. Null on stableswap pools. */
+    feeRange: {
+        mid: ScaledValue;
+        out: ScaledValue;
+    } | null;
+    /** Amplification, as the pool's `A()` reports it (crypto pools scale it by 10000). */
+    A: bigint;
+}
+/**
+ * Reads a Curve pool's composition, prices and fees in one go: balances, LP supply, virtual and LP price, the
+ * oracle, spot and (crypto) scale price of every coin in coin 0, each balance's value in coin 0, and the fee and A.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The pool's state; values and TVL are in coin 0's units at the oracle price.
+ */
+export declare const getPoolState: (chainId: ChainId, poolAddressOrId: string, provider?: Provider) => Promise<CurvePoolState>;

package/dist/types/contracts/curve/common/getPools.d.ts

@@ -0,0 +1,30 @@
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry } from "../../../configs/chains/chain";
+export interface CurvePoolCoin {
+    /** Asset key in the chain config, e.g. "pmusd". */
+    asset: string;
+    address: string;
+    /** From the token registry; the asset key when the registry has no symbol. */
+    symbol: string;
+    decimals: number;
+}
+export interface CurvePool extends Omit<CurvePoolEntry, "coins"> {
+    /** In pool index order: coins[i] is coin i on chain. */
+    coins: CurvePoolCoin[];
+}
+/**
+ * Lists the Curve pools in the chain config.
+ *
+ * @param chainId - The chain/network to use.
+ * @returns Every configured pool with its flavour and coins in pool index order; empty when the chain has none.
+ */
+export declare const getPools: (chainId: ChainId) => CurvePool[];
+/**
+ * Looks up one Curve pool in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's config key or its address.
+ * @returns The pool with its flavour and coins in pool index order.
+ * @throws If the pool is not configured on the chain.
+ */
+export declare const getPool: (chainId: ChainId, poolAddressOrId: string) => CurvePool;

package/dist/types/contracts/curve/common/getVirtualPrice.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Reads a Curve pool's virtual price: the value of one whole LP token in units of the pool's underlying coins,
+ * which only grows with fees. For a stableswap pool of $1 coins it is the LP token's USD price.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns `get_virtual_price()` as an 18-decimal amount, e.g. 1.0021 underlying per LP token.
+ */
+export declare const getVirtualPrice: (chainId: ChainId, poolAddressOrId: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/curve/common/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./addLiquidity";
+export * from "./calcTokenAmount";
+export * from "./calcWithdrawOneCoin";
+export * from "./exchange";
+export * from "./getDy";
+export * from "./getPools";
+export * from "./getPoolInterface";
+export * from "./getPoolState";
+export * from "./getVirtualPrice";
+export * from "./removeLiquidity";
+export * from "./removeLiquidityOneCoin";

package/dist/types/contracts/curve/common/removeLiquidity.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Burns LP tokens for every coin of a Curve pool in proportion to its balances.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param lpAmount - LP tokens to burn (18 decimals).
+ * @param minAmounts - The least of each coin to accept, in pool order and each coin's base units.
+ * @param receiver - Who receives the coins.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const removeLiquidity: (chainId: ChainId, poolAddressOrId: string, lpAmount: bigint, minAmounts: bigint[], receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/curve/common/removeLiquidityOneCoin.d.ts

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Burns LP tokens for a single coin of a Curve pool.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param lpAmount - LP tokens to burn (18 decimals).
+ * @param i - Index of the coin to receive, in pool order.
+ * @param minAmount - The least of coin `i` to accept, in its base units. See `calcWithdrawOneCoin`.
+ * @param receiver - Who receives the coin.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const removeLiquidityOneCoin: (chainId: ChainId, poolAddressOrId: string, lpAmount: bigint, i: number, minAmount: bigint, receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/faucet/claim.d.ts

@@ -0,0 +1,18 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+export interface FaucetClaim {
+    /** Token address. */
+    token: string;
+    /** Amount in the token's base units. */
+    amount: bigint;
+}
+/**
+ * Claims testnet tokens from the faucet: one `claim` for a single token, one `claimMultiple` for several.
+ *
+ * @param chainId - The chain/network to use; only chains with a `faucet` contract in their config.
+ * @param claims - The tokens and amounts to claim.
+ * @param signer - The signer sending the transaction; the tokens go to its address.
+ * @returns The mined transaction receipt.
+ * @throws If the chain has no faucet, `claims` is empty, or the transaction fails.
+ */
+export declare const claim: (chainId: ChainId, claims: FaucetClaim[], signer: Signer) => Promise<any>;

package/dist/types/contracts/faucet/getState.d.ts

@@ -0,0 +1,27 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+export interface FaucetToken {
+    address: string;
+    symbol: string;
+    decimals: number;
+    /** What the faucet holds and can still give out. */
+    balance: TokenAmount;
+    /** The most one claim may take. */
+    cap: TokenAmount;
+    approved: boolean;
+}
+export interface FaucetState {
+    address: string;
+    owner: string;
+    paused: boolean;
+    tokens: FaucetToken[];
+}
+/**
+ * Reads the testnet faucet: its owner, whether it is paused, and every token it gives out with its balance and per-claim cap.
+ * The faucet has no deposit function; it is topped up with a plain ERC20 transfer.
+ *
+ * @param chainId - The chain/network to use; only chains with a `faucet` contract in their config (Sepolia).
+ * @param provider - Optional ethers.js Provider instance.
+ */
+export declare const getState: (chainId: ChainId, provider?: Provider) => Promise<FaucetState>;

package/dist/types/contracts/faucet/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./claim";
+export * from "./getState";

package/dist/types/contracts/feeCollector/getState.d.ts

@@ -0,0 +1,42 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+import { TokenAmount } from "../../utils/amount";
+/** The six places a fee type splits into, as FeeCollector names them. */
+export declare const FEE_TARGETS: readonly ["TREASURY", "REPAIR_FUND", "BURN", "VERAAC", "RAAC_CORP", "OTHER"];
+export type FeeTarget = (typeof FEE_TARGETS)[number];
+/** Fee type names used across the protocol; others show as their raw bytes32. */
+export declare const KNOWN_FEE_TYPES: string[];
+/** One fee type and how it splits, in basis points (the shares add up to at most 10_000; the contract adds the rest to the treasury). */
+export interface FeeTypeInfo {
+    id: string;
+    /** The known name, or null when `id` is not one of `KNOWN_FEE_TYPES`. */
+    name: string | null;
+    shares: Record<FeeTarget, bigint>;
+}
+/** Fees collected for one token and fee type, still owed to each target. */
+export interface CollectedFees {
+    token: string;
+    feeType: string;
+    amounts: Record<FeeTarget, TokenAmount>;
+}
+export interface FeeCollectorState {
+    paused: boolean;
+    /** Where each target's share is sent. */
+    targets: Record<FeeTarget, string>;
+    feeTypes: FeeTypeInfo[];
+    tokens: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    }[];
+    /** Every token and fee type pair that has something owed. */
+    collected: CollectedFees[];
+}
+/**
+ * Reads the FeeCollector: pause state, targets, fee types and their splits, supported tokens, and what is still owed
+ * per token, fee type and target. Walks `supportedTokens(i)` until the index reverts.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+declare function getState(chainId: ChainId, provider: Provider): Promise<FeeCollectorState>;
+export default getState;

package/dist/types/contracts/getRoles.d.ts

@@ -0,0 +1,15 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+/** OpenZeppelin role ids: DEFAULT_ADMIN_ROLE is zero, every other role is the keccak of its name. */
+export declare function roleId(role: string): string;
+/**
+ * Which of an AccessControl contract's roles each account holds, e.g. to show what a Safe and a wallet may do.
+ * @param chainId The chain id, for error context.
+ * @param contractAddress The AccessControl contract.
+ * @param roles Role names ("GUARDIAN_ROLE", "DEFAULT_ADMIN_ROLE") or raw 32-byte ids.
+ * @param accounts The accounts to check.
+ * @param provider The provider to read with.
+ * @returns Keyed by lowercased account address, then by role as passed in.
+ */
+declare function getRoles(chainId: ChainId, contractAddress: string, roles: string[], accounts: string[], provider: Provider): Promise<Record<string, Record<string, boolean>>>;
+export default getRoles;

package/dist/types/contracts/getTokenMetadata.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export interface TokenMetadata {
+    symbol: string;
+    decimals: number;
+}
+/**
+ * Reads `symbol()`/`decimals()` directly from an arbitrary ERC20 token address -
+ * for tokens not in the chain config's asset registry (e.g. a veRAAC reward
+ * token or a gauge's reward token), where there's no registry entry to look
+ * up instead.
+ */
+export declare const getTokenMetadata: (chainId: ChainId, address: string, provider?: Provider) => Promise<TokenMetadata>;

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

@@ -6,23 +6,3 @@
  * @returns The checksummed address.
  */
 export declare const requireAddress: (address: string, name: string) => string;
-/** The fields a caller needs to explain a failed transaction, lifted from an ethers error. */
-export interface GovernanceTxError extends Error {
-    /** ethers error code, e.g. "ACTION_REJECTED", "CALL_EXCEPTION", "INSUFFICIENT_FUNDS". */
-    code?: string;
-    /** Revert data, when the node returned it. */
-    data?: string;
-    /** Decoded custom error name, e.g. "AlreadyVoted". */
-    errorName?: string;
-    cause: unknown;
-}
-/**
- * Wraps a failed write so the message says what failed while the original
- * error stays reachable: its code (a wallet rejection is ACTION_REJECTED), its
- * revert data and the decoded custom error name.
- *
- * @param prefix - What was being attempted, e.g. "Failed to cast vote".
- * @param error - The error ethers threw.
- * @returns An Error carrying `code`, `data`, `errorName` and `cause`.
- */
-export declare const toGovernanceTxError: (prefix: string, error: any) => GovernanceTxError;

package/dist/types/contracts/governance/proposals/castVote.d.ts

@@ -1,6 +1,5 @@
 import { ethers, Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
-import { TokenAmount } from "../../../utils/amount";
 /**
  * Casts a vote on a governance proposal.
  * Allows veToken holders to vote on active proposals.
@@ -17,5 +16,5 @@ import { TokenAmount } from "../../../utils/amount";
  */
 export declare const castVote: (chainId: ChainId, governance: string, proposalId: number | bigint, support: boolean, signer: Signer) => Promise<{
     tx: ethers.ContractTransactionResponse;
-    weight: TokenAmount;
+    weight: import("../../../utils/amount").TokenAmount;
 }>;

package/dist/types/contracts/housePrices/getState.d.ts

@@ -0,0 +1,24 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+/** RAACHousePrices administration state. */
+export interface HousePricesState {
+    owner: string;
+    /** The only account allowed to call `setHousePrice(s)`. */
+    oracle: string;
+    crvUSDToUSDOracle: string;
+    /** Properties that have a price. */
+    count: number;
+    /** UNIX seconds of the last price update. */
+    lastUpdateTimestamp: number;
+    /** Contracts notified of every price change. */
+    syncers: string[];
+    /** `MAX_SYNCERS`. */
+    maxSyncers: number;
+}
+/**
+ * Reads who administers RAACHousePrices, who may set prices, and its syncers.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+declare function getState(chainId: ChainId, provider: Provider): Promise<HousePricesState>;
+export default getState;

package/dist/types/contracts/lockers/botLocker/addRewardTokens.d.ts

@@ -0,0 +1,11 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Register reward tokens that can be distributed to lockers. MANAGER_ROLE only.
+ * Reverts if any token is the zero address or already registered.
+ *
+ * @param chainId - The chain/network to use.
+ * @param tokens - ERC20 addresses to register.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const addRewardTokens: (chainId: ChainId, tokens: string[], signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/botLocker/distributeRewardToken.d.ts

@@ -0,0 +1,13 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Distribute `amount` of a registered reward token across all currently locked NFTs. DISTRIBUTOR_ROLE only.
+ * The signer's tokens are pulled via transferFrom, so approve the locker for `amount` first.
+ * Reverts when nothing is locked.
+ *
+ * @param chainId - The chain/network to use.
+ * @param token - Address of a registered reward token.
+ * @param amount - Amount to distribute, in `token` base units.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const distributeRewardToken: (chainId: ChainId, token: string, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/botLocker/getConfig.d.ts

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerConfig {
+    /** Address of the RAAC Bot NFT collection the locker accepts. */
+    nft: string;
+    /** Length of one epoch, seconds (EPOCH_DURATION). */
+    epochDuration: number;
+    /** Epochs per lock cycle; an NFT can unlock when its locked epochs are a non-zero multiple of this (LOCK_DURATION_IN_EPOCH). */
+    lockDurationEpochs: number;
+    rewardTokens: string[];
+    paused: boolean;
+}
+/**
+ * Read the locker's configuration in a single call batch.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The NFT collection, lock timing constants, reward tokens and pause state.
+ */
+export declare const getConfig: (chainId: ChainId, provider?: Provider) => Promise<BotLockerConfig>;

package/dist/types/contracts/lockers/botLocker/getLocks.d.ts

@@ -9,6 +9,10 @@ export interface BotLockerNFTLock {
  * Returns every active NFT lock across all owners.
  */
 export declare const getLocks: (chainId: ChainId, provider?: Provider) => Promise<BotLockerNFTLock[]>;
+/**
+ * Returns the lock of a single NFT, or null when it is not locked.
+ */
+export declare const getLock: (chainId: ChainId, tokenId: string | number | bigint, provider?: Provider) => Promise<BotLockerNFTLock | null>;
 /**
  * Returns every active NFT lock owned by `owner`.
  */