@raac/rpc 2.0.0-beta.4 → 2.0.0-beta.6

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

@@ -20,8 +20,8 @@ export interface ZenoDetails {
  * 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. Amounts take decimals from the chain config registry and fall back to 18 when the
- * bond is not listed.
+ * @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;

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

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Sweeps underlying held above the ZENO's outstanding supply: unsold prefill, overpayments and post-maturity residue.
+ * ZENO owner only, and only once the bound auction has ended. `getBondState(...).sweepableSurplus` is the most it takes.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param to The recipient of the underlying.
+ * @param amount Underlying to sweep, in base units.
+ * @param signer The ZENO owner.
+ * @returns The transaction receipt.
+ */
+declare function sweepSurplus(chainId: ChainId, zeno: string, to: string, amount: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default sweepSurplus;

package/dist/types/nfts/getNFTBalance.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Get how many tokens of an NFT contract an address holds
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param owner - The address to check
+ * @param provider - The provider to use for the contract call
+ * @returns The number of tokens held
+ */
+declare function getNFTBalance(chainId: ChainId, nftContractName: NftContractNames, owner: string, provider: Provider): Promise<bigint>;
+export default getNFTBalance;

package/dist/types/nfts/transferNFT.d.ts

@@ -0,0 +1,15 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Transfer an NFT from the signer to another address with safeTransferFrom
+ * Do not use it to put a Bot NFT into the bot locker: the locker only records NFTs deposited through `lockers.botLocker.lock`.
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param to - The recipient address
+ * @param tokenId - The token ID to transfer
+ * @param signer - The signer that owns the token
+ * @returns Transaction receipt
+ */
+declare function transferNFT(chainId: ChainId, nftContractName: NftContractNames, to: string, tokenId: string | number | bigint, signer: Signer): Promise<ethers.ContractTransactionReceipt>;
+export default transferNFT;

package/dist/types/utils/artifacts.d.ts

@@ -117,6 +117,56 @@ declare const ABIS: {
         type: string;
         anonymous?: undefined;
     })[];
+    raacbotnft: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
     raactoken: ({
         inputs: {
             internalType: string;
@@ -4937,6 +4987,55 @@ declare const getABI: (name: keyof typeof ABIS) => any[] | ({
     stateMutability: string;
     type: string;
     anonymous?: undefined;
+})[] | ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
 })[] | ({
     inputs: any[];
     stateMutability: string;

package/dist/utils/artifacts.js

@@ -52,6 +52,7 @@ const pmBlender_json_1 = __importDefault(require("../artifacts/core/pmBlender/pm
 const RAACLiquidLocker_json_1 = __importDefault(require("../artifacts/core/lockers/RAACLiquidLocker.sol/RAACLiquidLocker.json"));
 const RAACMaturityVault_json_1 = __importDefault(require("../artifacts/core/lockers/RAACMaturityVault.sol/RAACMaturityVault.json"));
 const RAACBotLocker_json_1 = __importDefault(require("../artifacts/core/lockers/RAACBotLocker.sol/RAACBotLocker.json"));
+const ERC721Mock_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/ERC721Mock.sol/ERC721Mock.json"));
 // leRAAC token
 const LiquidEscrowedRAAC_json_1 = __importDefault(require("../artifacts/core/tokens/LeRAAC.sol/LiquidEscrowedRAAC.json"));
 // Zap
@@ -95,6 +96,8 @@ const ABIS = {
     xpm: XPM_ABI,
     // RAAC
     raacnft: RAACNFT_ABI,
+    // Standard OpenZeppelin ERC721 ABI; the Bot NFT is a plain ERC721 with no RAAC-specific functions
+    raacbotnft: ERC721Mock_json_1.default.abi,
     raactoken: RAACToken_ABI,
     veraac: VERAAC_ABI,
     // Pools tokens

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "2.0.0-beta.4",
+	"version": "2.0.0-beta.6",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",