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

package/dist/contracts/zeno/getBondState.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function getBondState(chainId, zeno, provider) {
+    try {
+        const contract = (0, _helpers_1.getZenoContract)(chainId, zeno, provider);
+        const [details, underlying, auction, totalSupply, sweepableSurplus, isRedeemable] = await Promise.all([
+            contract.getDetails(),
+            contract.underlyingAsset(),
+            contract.auction(),
+            contract.totalSupply(),
+            contract.sweepableSurplus(),
+            contract.isRedeemable(),
+        ]);
+        const collateral = await new ethers_1.ethers.Contract(underlying, _helpers_1.ERC20_ABI, contract.runner).balanceOf(zeno);
+        return {
+            zeno: details.zenoAddress,
+            name: details.name,
+            symbol: details.symbol,
+            underlying,
+            auction: (0, _helpers_1.addressOrNull)(auction),
+            maturityDate: details.maturityDate,
+            isRedeemable,
+            totalMinted: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalMinted, details.symbol),
+            totalSupply: (0, _helpers_1.toZenoAmount)(chainId, underlying, totalSupply, details.symbol),
+            totalRedeemed: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalRedeemed, details.symbol),
+            collateral: (0, amount_1.toTokenAmount)(chainId, underlying, collateral),
+            sweepableSurplus: (0, amount_1.toTokenAmount)(chainId, underlying, sweepableSurplus),
+            isFunded: collateral >= totalSupply,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.getBondState", error, { chainId, address: zeno });
+    }
+}
+exports.default = getBondState;

package/dist/contracts/zeno/getPrice.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function getPrice(chainId, auction, provider) {
+    try {
+        const contract = (0, _helpers_1.getAuctionContract)(chainId, auction, provider);
+        const [price, paymentToken] = await Promise.all([contract.getPrice(), contract.token()]);
+        return (0, amount_1.toTokenAmount)(chainId, paymentToken, price);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.getPrice", error, { chainId, address: auction });
+    }
+}
+exports.default = getPrice;

package/dist/contracts/zeno/getZenos.js

@@ -1,28 +1,44 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
-async function getZenos(chainId, signer) {
-    if (!signer) {
-        throw new Error("Wallet not connected");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function getZenos(chainId, provider) {
+    if (!provider) {
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
     }
+    const zenoFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "zenofactory");
     try {
-        const zenoFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "zenofactory");
-        const zenoFactoryABI = (0, artifacts_1.getABI)("zenofactory");
-        const zenoFactoryContract = new ethers_1.ethers.Contract(zenoFactoryAddress, zenoFactoryABI, signer);
-        const zenosCount = await zenoFactoryContract.getZENOCount();
-        const zenos = [];
-        for (let i = 0; i < zenosCount; i++) {
-            const zeno = await zenoFactoryContract.getZENODetails(i);
-            zenos.push(zeno);
-        }
-        console.log(`Zenos: ${zenos}`);
-        return zenos;
+        const zenoFactoryContract = new ethers_1.ethers.Contract(zenoFactoryAddress, (0, artifacts_1.getABI)("zenofactory"), provider);
+        const zenoAddresses = await zenoFactoryContract.getZENOs();
+        return await Promise.all(zenoAddresses.map(async (address) => {
+            const zenoContract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("zeno"), provider);
+            const [details, underlying] = await Promise.all([zenoContract.getDetails(), zenoContract.underlyingAsset()]);
+            return {
+                zenoAddress: details.zenoAddress,
+                maturityDate: details.maturityDate,
+                name: details.name,
+                symbol: details.symbol,
+                totalMinted: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalMinted, details.symbol),
+                totalRedeemed: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalRedeemed, details.symbol),
+            };
+        }));
     }
     catch (error) {
-        console.error("Error getting zenos:", error);
-        throw new Error(`Failed to get zenos: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("zeno.getZenos", error, { chainId, address: zenoFactoryAddress });
     }
 }
 exports.default = getZenos;

package/dist/contracts/zeno/grantRole.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grantRole = grantRole;
+exports.revokeRole = revokeRole;
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function grantRole(chainId, auction, role, account, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).grantRole(role, account);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.grantRole", error, { chainId, address: auction });
+    }
+}
+/**
+ * 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.
+ */
+async function revokeRole(chainId, auction, role, account, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).revokeRole(role, account);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.revokeRole", error, { chainId, address: auction });
+    }
+}

package/dist/contracts/zeno/pause.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pause = pause;
+exports.unpause = unpause;
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function pause(chainId, auction, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).pause();
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.pause", error, { chainId, address: auction });
+    }
+}
+/**
+ * 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.
+ */
+async function unpause(chainId, auction, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).unpause();
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.unpause", error, { chainId, address: auction });
+    }
+}

package/dist/contracts/zeno/priceAt.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.priceAt = void 0;
+/**
+ * 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.
+ */
+const priceAt = (terms, now) => {
+    if (now < terms.startTime)
+        return terms.startingPrice;
+    if (now >= terms.endTime)
+        return terms.reservePrice;
+    return (terms.startingPrice -
+        ((terms.startingPrice - terms.reservePrice) * (now - terms.startTime)) / (terms.endTime - terms.startTime));
+};
+exports.priceAt = priceAt;

package/dist/contracts/zeno/quoteBuy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteBuy = void 0;
+const BPS = 10000n;
+/**
+ * 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.
+ */
+const quoteBuy = (input) => {
+    if (input.price <= 0n)
+        throw new Error("Price must be positive");
+    const slippageBps = input.slippageBps ?? 0n;
+    if (slippageBps < 0n || slippageBps > BPS)
+        throw new Error("Slippage must be between 0 and 10000 bps");
+    const scale = 10n ** BigInt(input.zenoDecimals);
+    const zenoOut = (input.paymentAmount * scale) / input.price;
+    // floor(p * scale / price) <= remaining  <=>  p * scale < (remaining + 1) * price
+    const maxPayment = ((input.totalRemaining + 1n) * input.price - 1n) / scale;
+    return {
+        zenoOut,
+        minZenoOut: (zenoOut * (BPS - slippageBps)) / BPS,
+        maxPayment,
+        exceedsRemaining: input.paymentAmount > maxPayment,
+    };
+};
+exports.quoteBuy = quoteBuy;

package/dist/contracts/zeno/redeem.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeem = redeem;
+exports.redeemAll = redeemAll;
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function redeem(chainId, zeno, amount, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).redeem(amount);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.redeem", error, { chainId, address: zeno });
+    }
+}
+/**
+ * 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.
+ */
+async function redeemAll(chainId, zeno, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).redeemAll();
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.redeemAll", error, { chainId, address: zeno });
+    }
+}

package/dist/contracts/zeno/setAuction.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function setAuction(chainId, zeno, auction, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).setAuction(auction);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.setAuction", error, { chainId, address: zeno });
+    }
+}
+exports.default = setAuction;

package/dist/contracts/zeno/sweepSurplus.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function sweepSurplus(chainId, zeno, to, amount, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).sweepSurplus(to, amount);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.sweepSurplus", error, { chainId, address: zeno });
+    }
+}
+exports.default = sweepSurplus;