@raac/rpc 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/contracts/tokens/veRAAC/withdraw.js

@@ -4,6 +4,7 @@ exports.withdraw = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Withdraws expired tokens from all eligible lock positions.
  * Withdraws all expired tokens and transfers them to the caller, also claims rewards.
@@ -16,18 +17,16 @@ const withdraw = async (chainId, signer) => {
     if (!signer) {
         throw new Error("Signer is required");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
     try {
-        const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
         const abi = (0, artifacts_1.getABI)("veraac");
         const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
         const tx = await contract.withdraw();
         await tx.wait();
-        console.log(`Withdrew expired tokens at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error withdrawing:", error);
-        throw new Error(`Failed to withdraw: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.withdraw", error, { chainId, address: contractAddress });
     }
 };
 exports.withdraw = withdraw;

package/dist/contracts/zeno/_helpers.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20_ABI = void 0;
+exports.getZenoContract = getZenoContract;
+exports.getAuctionContract = getAuctionContract;
+exports.toZenoAmount = toZenoAmount;
+exports.addressOrNull = addressOrNull;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+/** The one ERC20 call the zeno methods make: the underlying held by a ZENO. */
+exports.ERC20_ABI = ["function balanceOf(address) view returns (uint256)"];
+/** A ZENO bond. Bonds are created by the factory, so the address is passed in rather than read from the config. */
+function getZenoContract(chainId, zeno, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    return new ethers_1.ethers.Contract(zeno, (0, artifacts_1.getABI)("zeno"), runner);
+}
+/** A ZENO auction. Auctions are created by the factory, so the address is passed in rather than read from the config. */
+function getAuctionContract(chainId, auction, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    return new ethers_1.ethers.Contract(auction, (0, artifacts_1.getABI)("auction"), runner);
+}
+/**
+ * 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.
+ */
+function toZenoAmount(chainId, underlying, value, symbol) {
+    return (0, amount_1.toAmount)(value, (0, amount_1.getTokenInfo)(chainId, underlying)?.decimals ?? amount_1.WAD_DECIMALS, symbol);
+}
+/** `ZENO.auction()` and other unset address fields read as the zero address; this maps that to null. */
+function addressOrNull(address) {
+    return address === ethers_1.ethers.ZeroAddress ? null : address;
+}

package/dist/contracts/zeno/buy.js

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

package/dist/contracts/zeno/createAuction.js

@@ -1,38 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FundingMode = void 0;
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
+/** How an auction's ZENO is backed by the underlying asset. Mirrors `IAuction.FundingMode`. */
+var FundingMode;
+(function (FundingMode) {
+    /** The ZENO must already hold underlying for the full allocation. */
+    FundingMode[FundingMode["Prefilled"] = 0] = "Prefilled";
+    /** The issuer tops up the underlying before maturity. */
+    FundingMode[FundingMode["Float"] = 1] = "Float";
+})(FundingMode || (exports.FundingMode = FundingMode = {}));
 /**
- * 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.
  */
-async function createAuction(chainId, zenoAddress, usdcAddress, businessAddress, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated, signer) {
+async function createAuction(chainId, zenoAddress, tokenAddress, issuer, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated, fundingMode, initialOwner, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
     }
+    const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
     try {
-        const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
-        const auctionFactoryABI = (0, artifacts_1.getABI)("auctionfactory");
-        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, auctionFactoryABI, signer);
-        const tx = await auctionFactoryContract.createAuction(zenoAddress, usdcAddress, businessAddress, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated);
-        await tx.wait();
-        const auctionsCount = await auctionFactoryContract.getAuctionCount();
-        const auctionAddress = await auctionFactoryContract.getAuction(auctionsCount - BigInt(1));
-        console.log(`Zeno auction created at address: ${auctionAddress}`);
+        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, (0, artifacts_1.getABI)("auctionfactory"), signer);
+        const tx = await auctionFactoryContract.createAuction(zenoAddress, tokenAddress, issuer, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated, fundingMode, initialOwner);
+        const receipt = await tx.wait();
+        for (const log of receipt.logs) {
+            const parsed = auctionFactoryContract.interface.parseLog(log);
+            if (parsed?.name === "AuctionCreated") {
+                return parsed.args.auctionAddress;
+            }
+        }
+        throw new Error("AuctionCreated event not found in receipt");
     }
     catch (error) {
-        console.error("Error creating zeno auction:", error);
-        throw new Error(`Failed to create zeno auction: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("zeno.createAuction", error, { chainId, address: auctionFactoryAddress });
     }
 }
 exports.default = createAuction;

package/dist/contracts/zeno/createZeno.js

@@ -3,24 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
-async function createZeno(chainId, usdcAddress, maturityDate, signer) {
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * 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.
+ */
+async function createZeno(chainId, tokenAddress, maturityDate, initialOwner, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
     }
+    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 tx = await zenoFactoryContract.createZENOContract(usdcAddress, maturityDate);
-        await tx.wait();
-        const zenosCount = await zenoFactoryContract.getZENOCount();
-        const zenoAddress = await zenoFactoryContract.getZENO(zenosCount - BigInt(1));
-        console.log(`Zeno created at address: ${zenoAddress}`);
-        return zenoAddress;
+        const zenoFactoryContract = new ethers_1.ethers.Contract(zenoFactoryAddress, (0, artifacts_1.getABI)("zenofactory"), signer);
+        const tx = await zenoFactoryContract.createZENOContract(tokenAddress, maturityDate, initialOwner);
+        const receipt = await tx.wait();
+        for (const log of receipt.logs) {
+            const parsed = zenoFactoryContract.interface.parseLog(log);
+            if (parsed?.name === "ZENOCreated") {
+                return parsed.args.zenoAddress;
+            }
+        }
+        throw new Error("ZENOCreated event not found in receipt");
     }
     catch (error) {
-        console.error("Error creating zeno:", error);
-        throw new Error(`Failed to create zeno: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("zeno.createZeno", error, { chainId, address: zenoFactoryAddress });
     }
 }
 exports.default = createZeno;

package/dist/contracts/zeno/getAuctionState.js

@@ -0,0 +1,45 @@
+"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 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.
+ */
+async function getAuctionState(chainId, auction, provider) {
+    try {
+        const contract = (0, _helpers_1.getAuctionContract)(chainId, auction, provider);
+        const [details, paymentToken, paused, ended] = await Promise.all([
+            contract.getDetails(),
+            contract.token(),
+            contract.paused(),
+            contract.checkAuctionEnded(),
+        ]);
+        const underlying = await (0, _helpers_1.getZenoContract)(chainId, details.zenoAddress, contract.runner).underlyingAsset();
+        return {
+            auction: details.auctionAddress,
+            zeno: details.zenoAddress,
+            paymentToken,
+            issuer: details.issuer,
+            fundingMode: Number(details.fundingMode),
+            startTime: details.auctionStartTime,
+            endTime: details.auctionEndTime,
+            startingPrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.startingPrice),
+            reservePrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.reservePrice),
+            isFixedPrice: details.startingPrice === details.reservePrice,
+            price: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.price),
+            totalAllocated: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENOAllocated),
+            totalRemaining: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENORemaining),
+            paused,
+            ended,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.getAuctionState", error, { chainId, address: auction });
+    }
+}
+exports.default = getAuctionState;

package/dist/contracts/zeno/getAuctions.js

@@ -1,51 +1,56 @@
 "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");
 const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
 /**
  * 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.
  */
-async function getAuctions(chainId, signer) {
-    if (!signer) {
-        throw new Error("Wallet not connected");
+async function getAuctions(chainId, provider) {
+    if (!provider) {
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
     }
+    const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
     try {
-        const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
-        const auctionFactoryABI = (0, artifacts_1.getABI)("auctionfactory");
-        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, auctionFactoryABI, signer);
-        const auctionsCount = await auctionFactoryContract.getAuctionCount();
-        const auctions = [];
-        for (let i = 0; i < auctionsCount; i++) {
-            const auction = await auctionFactoryContract.getAuctionDetails(i);
-            const auctionContract = new ethers_1.ethers.Contract(auction.auctionAddress, (0, artifacts_1.getABI)("auction"), signer);
-            const paymentToken = await auctionContract.token();
-            auctions.push({
-                auctionAddress: auction.auctionAddress,
-                zenoAddress: auction.zenoAddress,
-                businessAddress: auction.businessAddress,
-                auctionStartTime: auction.auctionStartTime,
-                auctionEndTime: auction.auctionEndTime,
-                startingPrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.startingPrice),
-                reservePrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.reservePrice),
-                price: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.price),
-                totalZENOAllocated: (0, amount_1.toTokenAmount)(chainId, auction.zenoAddress, auction.totalZENOAllocated),
-                totalZENORemaining: (0, amount_1.toTokenAmount)(chainId, auction.zenoAddress, auction.totalZENORemaining),
-                lastBidTime: auction.lastBidTime,
-                lastBidder: auction.lastBidder,
-                lastBidAmount: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.lastBidAmount),
-            });
-        }
-        return auctions;
+        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, (0, artifacts_1.getABI)("auctionfactory"), provider);
+        const auctionAddresses = await auctionFactoryContract.getAuctions();
+        return await Promise.all(auctionAddresses.map(async (address) => {
+            const auctionContract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("auction"), provider);
+            const [details, tokenAddress] = await Promise.all([
+                auctionContract.getDetails(),
+                auctionContract.token(),
+            ]);
+            const underlying = await (0, _helpers_1.getZenoContract)(chainId, details.zenoAddress, provider).underlyingAsset();
+            return {
+                auctionAddress: details.auctionAddress,
+                zenoAddress: details.zenoAddress,
+                tokenAddress,
+                issuer: details.issuer,
+                auctionStartTime: details.auctionStartTime,
+                auctionEndTime: details.auctionEndTime,
+                startingPrice: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.startingPrice),
+                reservePrice: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.reservePrice),
+                price: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.price),
+                totalZENOAllocated: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENOAllocated),
+                totalZENORemaining: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENORemaining),
+                fundingMode: Number(details.fundingMode),
+            };
+        }));
     }
     catch (error) {
-        console.error("Error getting auctions:", error);
-        throw new Error(`Failed to get auctions: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("zeno.getAuctions", error, { chainId, address: auctionFactoryAddress });
     }
 }
 exports.default = getAuctions;

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;