@andrewkimjoseph/celina-sdk 0.9.7 → 0.9.9

package/build/src/services/gooddollar.service.js

@@ -0,0 +1,675 @@
+/**
+ * GoodDollar IdentityV4 whitelist, reverification reads, UBI claims, and reserve swaps on Celo mainnet.
+ */
+import { concat, encodeFunctionData, erc20Abi, formatUnits, maxUint256, } from "viem";
+import { goodDollarBrokerAbi } from "../abis/gooddollar-broker.js";
+import { goodDollarIdentityAbi } from "../abis/gooddollar-identity.js";
+import { ubiSchemeAbi } from "../abis/ubi-scheme.js";
+import { GOODDOLLAR_CUSD_EXCHANGE_ID, GOODDOLLAR_IDENTITY_ADDRESS, GOODDOLLAR_MENTO_BROKER, GOODDOLLAR_MENTO_EXCHANGE_PROVIDER, GOODDOLLAR_RESERVE_COLLATERAL, GOODDOLLAR_TOKEN_ADDRESS, GOODDOLLAR_UBI_SCHEME_ADDRESS, isGoodDollarUsdReservePair, } from "../config/gooddollar.js";
+import { CELINA_DATA_SUFFIX } from "../config/celina-tag.js";
+import { serializePreparedFlow, } from "../types/prepared.js";
+import { ALLOWANCE_MAPPING_SLOTS, erc20AllowanceStateOverride, } from "../utils/erc20-allowance-storage.js";
+import { TokenService } from "./token.service.js";
+import { formatUnixDate } from "../utils/format-date.js";
+import { formatDuration } from "../utils/format-duration.js";
+import { formatUnixDateTimeUtc, formatUnixIso, } from "../utils/format-unix-datetime.js";
+import { resolveUbiPeriodEligibility } from "../utils/gooddollar-ubi-period.js";
+const SECONDS_PER_DAY = 86400n;
+const G_DOLLAR_DECIMALS = 18;
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const STATUS_LABELS = {
+    0: "none",
+    1: "whitelisted",
+    2: "dao_contract",
+    255: "blacklisted",
+};
+// Post-upgrade users authenticated before this timestamp use the last reverify step.
+const LEGACY_AUTH_CUTOFF = 1772697574;
+function statusLabel(status) {
+    return STATUS_LABELS[status] ?? "unknown";
+}
+function taggedCalldata(data) {
+    return concat([data, CELINA_DATA_SUFFIX]);
+}
+const DEFAULT_RESERVE_SLIPPAGE = 0.5;
+function trimDisplayDecimals(value) {
+    const num = Number(value);
+    if (!Number.isFinite(num)) {
+        return value;
+    }
+    if (Math.abs(num) >= 1000) {
+        return num.toLocaleString(undefined, { maximumFractionDigits: 2 });
+    }
+    if (Math.abs(num) >= 1) {
+        return num.toLocaleString(undefined, { maximumFractionDigits: 4 });
+    }
+    return num.toLocaleString(undefined, { maximumSignificantDigits: 6 });
+}
+function applySlippage(amountOut, slippagePercent) {
+    const bps = BigInt(Math.round(slippagePercent * 100));
+    return (amountOut * (10000n - bps)) / 10000n;
+}
+function tokenAddress(token) {
+    if (token.address === "native") {
+        throw new Error(`${token.symbol} is native CELO; GoodDollar reserve swaps require ERC-20 tokens.`);
+    }
+    return token.address;
+}
+/** GoodDollar IdentityV4 whitelist, reverification, daily UBI claim, and reserve swap preparation. */
+export class GoodDollarService {
+    clientFactory;
+    tokenService;
+    constructor(clientFactory) {
+        this.clientFactory = clientFactory;
+        this.tokenService = new TokenService(clientFactory);
+    }
+    getPublicClient() {
+        return this.clientFactory.getClients().public;
+    }
+    async resolveWhitelistedRoot(address) {
+        const client = this.getPublicClient();
+        const rootResult = await client.readContract({
+            address: GOODDOLLAR_IDENTITY_ADDRESS,
+            abi: goodDollarIdentityAbi,
+            functionName: "getWhitelistedRoot",
+            args: [address],
+        });
+        const root = rootResult;
+        const hasRoot = root !== ZERO_ADDRESS;
+        const identityAddress = hasRoot ? root : address;
+        return {
+            queried: address,
+            root: hasRoot ? root : null,
+            identityAddress,
+            isConnectedWallet: hasRoot && root.toLowerCase() !== address.toLowerCase(),
+        };
+    }
+    async fetchWhitelistingData(identityAddress) {
+        const { public: client } = this.clientFactory.getClients();
+        const contract = GOODDOLLAR_IDENTITY_ADDRESS;
+        const [identityResult, isWhitelisted, maxReverificationPeriodDays, reverifyDaysOptions,] = await Promise.all([
+            client.readContract({
+                address: contract,
+                abi: goodDollarIdentityAbi,
+                functionName: "identities",
+                args: [identityAddress],
+            }),
+            client.readContract({
+                address: contract,
+                abi: goodDollarIdentityAbi,
+                functionName: "isWhitelisted",
+                args: [identityAddress],
+            }),
+            client.readContract({
+                address: contract,
+                abi: goodDollarIdentityAbi,
+                functionName: "authenticationPeriod",
+            }),
+            this.fetchReverifyDaysOptions(client, contract),
+        ]);
+        const [dateAuthenticated, dateAdded, did, whitelistedOnChainId, status, authCount,] = identityResult;
+        const statusNum = Number(status);
+        const dateAuthenticatedNum = Number(dateAuthenticated);
+        const dateAddedNum = Number(dateAdded);
+        const authCountNum = Number(authCount);
+        let currentReverificationPeriodDays = null;
+        if (statusNum === 1 && dateAuthenticatedNum > 0 && reverifyDaysOptions.length > 0) {
+            const effectiveAuthCount = this.effectiveAuthCount(dateAuthenticatedNum, authCountNum, reverifyDaysOptions.length);
+            currentReverificationPeriodDays =
+                reverifyDaysOptions[effectiveAuthCount] ?? null;
+        }
+        const isWhitelistedStatus = statusNum === 1 && dateAddedNum > 0;
+        const reverification = statusNum === 1 && dateAuthenticatedNum > 0 && currentReverificationPeriodDays !== null
+            ? this.buildReverificationProgress(dateAuthenticatedNum, currentReverificationPeriodDays, Number(maxReverificationPeriodDays))
+            : null;
+        return {
+            contract,
+            isWhitelisted,
+            status: statusNum,
+            statusLabel: statusLabel(statusNum),
+            whitelistedOn: isWhitelistedStatus ? formatUnixDate(dateAddedNum) : null,
+            lastAuthenticatedOn: dateAuthenticatedNum > 0 ? formatUnixDate(dateAuthenticatedNum) : null,
+            fieldDescriptions: {
+                whitelistedOn: "When the wallet was first added to the GoodDollar whitelist.",
+                lastAuthenticatedOn: "When the wallet last verified its identity. Periodic reverification is required to remain whitelisted.",
+            },
+            reverification,
+            identity: {
+                dateAuthenticated: dateAuthenticatedNum,
+                dateAdded: dateAddedNum,
+                did,
+                whitelistedOnChainId: Number(whitelistedOnChainId),
+                status: statusNum,
+                authCount: authCountNum,
+            },
+        };
+    }
+    /**
+     * How a wallet links to GoodDollar IdentityV4 (root vs connected account).
+     * @param address - Wallet to inspect
+     */
+    async getIdentityLink(address) {
+        const client = this.getPublicClient();
+        const link = await this.resolveWhitelistedRoot(address);
+        const [connectedTo, isWhitelisted] = await Promise.all([
+            client.readContract({
+                address: GOODDOLLAR_IDENTITY_ADDRESS,
+                abi: goodDollarIdentityAbi,
+                functionName: "connectedAccounts",
+                args: [address],
+            }),
+            client.readContract({
+                address: GOODDOLLAR_IDENTITY_ADDRESS,
+                abi: goodDollarIdentityAbi,
+                functionName: "isWhitelisted",
+                args: [link.identityAddress],
+            }),
+        ]);
+        const connectedToAddr = connectedTo;
+        const isWhitelistedRoot = link.root !== null &&
+            link.root.toLowerCase() === address.toLowerCase();
+        return {
+            address,
+            contract: GOODDOLLAR_IDENTITY_ADDRESS,
+            whitelistedRoot: link.root,
+            isConnectedWallet: link.isConnectedWallet,
+            isWhitelistedRoot,
+            connectedTo: connectedToAddr !== ZERO_ADDRESS ? connectedToAddr : null,
+            checkedAddress: link.identityAddress,
+            isWhitelisted,
+        };
+    }
+    /**
+     * GoodDollar IdentityV4 whitelist status and reverification progress for a wallet.
+     * Resolves connected wallets via Identity `getWhitelistedRoot`.
+     * @param address - Wallet to check against IdentityV4
+     * @returns On-chain status, whitelist dates, field descriptions, and reverification timeline
+     */
+    async getWhitelistingInfo(address) {
+        const link = await this.resolveWhitelistedRoot(address);
+        const data = await this.fetchWhitelistingData(link.identityAddress);
+        return {
+            address,
+            whitelistedRoot: link.root,
+            isConnectedWallet: link.isConnectedWallet,
+            checkedAddress: link.identityAddress,
+            ...data,
+        };
+    }
+    /**
+     * Daily UBI claim eligibility for a wallet against UBISchemeV2 on Celo.
+     * Resolves connected wallets via Identity `getWhitelistedRoot`.
+     */
+    async getUbiClaimEligibility(address) {
+        const client = this.getPublicClient();
+        const ubiContract = GOODDOLLAR_UBI_SCHEME_ADDRESS;
+        const link = await this.resolveWhitelistedRoot(address);
+        const root = link.root;
+        const [claimableAmount, schemePaused, periodStart, estimatedDailyUbi, dailyUbi, ubiPeriodDay, whitelistingData,] = await Promise.all([
+            client.readContract({
+                address: ubiContract,
+                abi: ubiSchemeAbi,
+                functionName: "checkEntitlement",
+                args: [address],
+            }),
+            client.readContract({
+                address: ubiContract,
+                abi: ubiSchemeAbi,
+                functionName: "paused",
+            }),
+            client.readContract({
+                address: ubiContract,
+                abi: ubiSchemeAbi,
+                functionName: "periodStart",
+            }),
+            client.readContract({
+                address: ubiContract,
+                abi: ubiSchemeAbi,
+                functionName: "estimateNextDailyUBI",
+            }),
+            client.readContract({
+                address: ubiContract,
+                abi: ubiSchemeAbi,
+                functionName: "dailyUbi",
+            }),
+            client.readContract({
+                address: ubiContract,
+                abi: ubiSchemeAbi,
+                functionName: "currentDay",
+            }),
+            this.fetchWhitelistingData(link.identityAddress),
+        ]);
+        const claimable = claimableAmount;
+        const periodStartBn = periodStart;
+        const nowSec = BigInt(Math.floor(Date.now() / 1000));
+        const schemeStarted = nowSec >= periodStartBn;
+        const contractDay = ubiPeriodDay;
+        const computedDay = schemeStarted && periodStartBn > 0n
+            ? (nowSec - periodStartBn) / SECONDS_PER_DAY
+            : 0n;
+        let claimedForOnChainDay = false;
+        let lastClaimedSec = 0n;
+        if (root !== null) {
+            const [hasClaimed, lastClaimed] = await Promise.all([
+                client.readContract({
+                    address: ubiContract,
+                    abi: ubiSchemeAbi,
+                    functionName: "hasClaimed",
+                    args: [root],
+                }),
+                client.readContract({
+                    address: ubiContract,
+                    abi: ubiSchemeAbi,
+                    functionName: "lastClaimed",
+                    args: [root],
+                }),
+            ]);
+            claimedForOnChainDay = hasClaimed;
+            lastClaimedSec = lastClaimed;
+        }
+        const periodState = resolveUbiPeriodEligibility({
+            contractDay,
+            computedDay,
+            claimedForOnChainDay,
+            hasRoot: root !== null,
+            schemePaused,
+            schemeStarted,
+            isWhitelisted: whitelistingData.isWhitelisted,
+            claimable,
+        });
+        const { alreadyClaimedToday, inClaimCooldown } = periodState;
+        const nextClaimAt = periodStartBn + (computedDay + 1n) * SECONDS_PER_DAY;
+        const secondsUntilNextClaim = inClaimCooldown && nextClaimAt > nowSec ? nextClaimAt - nowSec : 0n;
+        const reasons = [];
+        if (schemePaused) {
+            reasons.push("scheme paused");
+        }
+        if (!schemeStarted) {
+            reasons.push("scheme not started");
+        }
+        if (root === null) {
+            reasons.push("not whitelisted");
+        }
+        else if (alreadyClaimedToday) {
+            const waitLabel = formatDuration(secondsUntilNextClaim);
+            const atLabel = formatUnixDateTimeUtc(nextClaimAt);
+            reasons.push(`already claimed this period; next claim in ${waitLabel} (${atLabel})`);
+        }
+        else {
+            if (!whitelistingData.isWhitelisted) {
+                if (whitelistingData.reverification?.isReverificationOverdue) {
+                    reasons.push("reverification overdue");
+                }
+                else {
+                    reasons.push("identity not currently whitelisted");
+                }
+            }
+            if (claimable === 0n) {
+                reasons.push("no entitlement available");
+            }
+        }
+        const isEligibleToClaim = periodState.isEligibleToClaim;
+        const lastClaimedAt = lastClaimedSec > 0n ? formatUnixIso(lastClaimedSec) : null;
+        const nextClaimAvailableAt = formatUnixIso(nextClaimAt);
+        const nextClaimAvailableIn = formatDuration(secondsUntilNextClaim);
+        return {
+            address,
+            contract: ubiContract,
+            whitelistedRoot: root,
+            isConnectedWallet: link.isConnectedWallet,
+            isEligibleToClaim,
+            claimableAmount: claimable.toString(),
+            claimableAmountFormatted: claimable > 0n ? `${formatUnits(claimable, G_DOLLAR_DECIMALS)} G$` : "0 G$",
+            alreadyClaimedToday,
+            inClaimCooldown,
+            lastClaimedAt,
+            nextClaimAvailableAt,
+            secondsUntilNextClaim: secondsUntilNextClaim.toString(),
+            nextClaimAvailableIn,
+            ubiPeriodDay: ubiPeriodDay.toString(),
+            schemePaused,
+            schemeStarted,
+            estimatedDailyUbi: estimatedDailyUbi.toString(),
+            estimatedDailyUbiFormatted: `${formatUnits(estimatedDailyUbi, G_DOLLAR_DECIMALS)} G$`,
+            currentDailyUbi: dailyUbi.toString(),
+            currentDailyUbiFormatted: `${formatUnits(dailyUbi, G_DOLLAR_DECIMALS)} G$`,
+            reasons: isEligibleToClaim ? [] : reasons,
+            identity: {
+                checkedAddress: link.identityAddress,
+                isWhitelisted: whitelistingData.isWhitelisted,
+                statusLabel: whitelistingData.statusLabel,
+                reverification: whitelistingData.reverification,
+            },
+        };
+    }
+    /**
+     * Build an unsigned UBISchemeV2 `claim()` transaction for daily G$ UBI.
+     * Validates whitelist, entitlement, and simulates gas before returning steps.
+     */
+    async prepareClaimUbi(from) {
+        const eligibility = await this.getUbiClaimEligibility(from);
+        if (!eligibility.isEligibleToClaim) {
+            const detail = eligibility.reasons.length > 0
+                ? eligibility.reasons.join("; ")
+                : "not eligible to claim";
+            throw new Error(`Cannot claim GoodDollar UBI: ${detail}.`);
+        }
+        const publicClient = this.getPublicClient();
+        const claimData = taggedCalldata(encodeFunctionData({
+            abi: ubiSchemeAbi,
+            functionName: "claim",
+        }));
+        await publicClient.estimateContractGas({
+            account: from,
+            address: GOODDOLLAR_UBI_SCHEME_ADDRESS,
+            abi: ubiSchemeAbi,
+            functionName: "claim",
+        });
+        const summary = eligibility.isConnectedWallet && eligibility.whitelistedRoot
+            ? `Claim daily GoodDollar UBI (${eligibility.claimableAmountFormatted}) via connected wallet → root ${eligibility.whitelistedRoot}`
+            : `Claim daily GoodDollar UBI (${eligibility.claimableAmountFormatted})`;
+        const flow = {
+            network: "mainnet",
+            from,
+            summary,
+            steps: [
+                {
+                    kind: "contract",
+                    to: GOODDOLLAR_UBI_SCHEME_ADDRESS,
+                    data: claimData,
+                    value: "0",
+                    description: "Claim daily GoodDollar UBI",
+                },
+            ],
+        };
+        return serializePreparedFlow(flow);
+    }
+    resolveReservePair(tokenIn, tokenOut) {
+        if (!isGoodDollarUsdReservePair(tokenIn, tokenOut)) {
+            throw new Error(`No GoodDollar reserve route for ${tokenIn} → ${tokenOut}. Supported: GoodDollar ↔ USDm.`);
+        }
+        const resolvedIn = this.tokenService.resolveToken(tokenIn);
+        const resolvedOut = this.tokenService.resolveToken(tokenOut);
+        const tokenInAddr = tokenAddress(resolvedIn);
+        const tokenOutAddr = tokenAddress(resolvedOut);
+        const gdAddr = GOODDOLLAR_TOKEN_ADDRESS.toLowerCase();
+        const collateralAddr = GOODDOLLAR_RESERVE_COLLATERAL.toLowerCase();
+        const inLower = tokenInAddr.toLowerCase();
+        const outLower = tokenOutAddr.toLowerCase();
+        if (!((inLower === gdAddr && outLower === collateralAddr) ||
+            (inLower === collateralAddr && outLower === gdAddr))) {
+            throw new Error(`No GoodDollar reserve route for ${resolvedIn.symbol} → ${resolvedOut.symbol}.`);
+        }
+        return { resolvedIn, resolvedOut, tokenInAddr, tokenOutAddr };
+    }
+    reserveOptions(params) {
+        return {
+            slippageTolerance: params?.slippageTolerance ?? DEFAULT_RESERVE_SLIPPAGE,
+        };
+    }
+    baseReserveQuoteFields(resolvedIn, resolvedOut, amountIn, expectedOutWei, amountSide) {
+        return {
+            protocol: "gooddollar_reserve",
+            network: "mainnet",
+            tokenIn: resolvedIn.symbol,
+            tokenOut: resolvedOut.symbol,
+            amountIn,
+            expectedOut: formatUnits(expectedOutWei, resolvedOut.decimals),
+            amountSide,
+            routeHops: 1,
+            broker: GOODDOLLAR_MENTO_BROKER,
+            exchangeProvider: GOODDOLLAR_MENTO_EXCHANGE_PROVIDER,
+            exchangeId: GOODDOLLAR_CUSD_EXCHANGE_ID,
+        };
+    }
+    async resolveReserveAmount(client, resolvedIn, resolvedOut, tokenInAddr, tokenOutAddr, amount, amountSide = "in") {
+        if (amountSide === "in") {
+            const amountInWei = this.tokenService.parseAmount(amount, resolvedIn.decimals);
+            const expectedOutWei = await client.readContract({
+                address: GOODDOLLAR_MENTO_BROKER,
+                abi: goodDollarBrokerAbi,
+                functionName: "getAmountOut",
+                args: [
+                    GOODDOLLAR_MENTO_EXCHANGE_PROVIDER,
+                    GOODDOLLAR_CUSD_EXCHANGE_ID,
+                    tokenInAddr,
+                    tokenOutAddr,
+                    amountInWei,
+                ],
+            });
+            return {
+                amountIn: amount,
+                amountInWei,
+                expectedOutWei,
+                amountSide: "in",
+            };
+        }
+        const expectedOutWei = this.tokenService.parseAmount(amount, resolvedOut.decimals);
+        const amountInWei = await client.readContract({
+            address: GOODDOLLAR_MENTO_BROKER,
+            abi: goodDollarBrokerAbi,
+            functionName: "getAmountIn",
+            args: [
+                GOODDOLLAR_MENTO_EXCHANGE_PROVIDER,
+                GOODDOLLAR_CUSD_EXCHANGE_ID,
+                tokenInAddr,
+                tokenOutAddr,
+                expectedOutWei,
+            ],
+        });
+        return {
+            amountIn: trimDisplayDecimals(formatUnits(amountInWei, resolvedIn.decimals)),
+            amountInWei,
+            expectedOutWei,
+            amountSide: "out",
+        };
+    }
+    /**
+     * Expected GoodDollar reserve output for G$ ↔ USDm — no wallet required.
+     * Balance checks run on prepare/estimate only.
+     */
+    async getReserveQuote(tokenIn, tokenOut, amount, options) {
+        const { public: client } = this.clientFactory.getClients();
+        const { resolvedIn, resolvedOut, tokenInAddr, tokenOutAddr } = this.resolveReservePair(tokenIn, tokenOut);
+        const amountSide = options?.amountSide ?? "in";
+        const resolved = await this.resolveReserveAmount(client, resolvedIn, resolvedOut, tokenInAddr, tokenOutAddr, amount, amountSide);
+        return this.baseReserveQuoteFields(resolvedIn, resolvedOut, resolved.amountIn, resolved.expectedOutWei, resolved.amountSide);
+    }
+    async buildReserveSwap(from, tokenIn, tokenOut, amount, params) {
+        const { public: client } = this.clientFactory.getClients();
+        const { resolvedIn, resolvedOut, tokenInAddr, tokenOutAddr } = this.resolveReservePair(tokenIn, tokenOut);
+        const recipient = params?.recipient ?? from;
+        const amountSide = params?.amountSide ?? "in";
+        const { slippageTolerance } = this.reserveOptions(params);
+        const resolved = await this.resolveReserveAmount(client, resolvedIn, resolvedOut, tokenInAddr, tokenOutAddr, amount, amountSide);
+        const { amountIn, amountInWei, expectedOutWei } = resolved;
+        await this.tokenService.assertSpendableBalance(from, resolvedIn, amountIn, {
+            spendToken: tokenInAddr,
+        });
+        const amountOutMin = applySlippage(expectedOutWei, slippageTolerance);
+        const swapData = taggedCalldata(encodeFunctionData({
+            abi: goodDollarBrokerAbi,
+            functionName: "swapIn",
+            args: [
+                GOODDOLLAR_MENTO_EXCHANGE_PROVIDER,
+                GOODDOLLAR_CUSD_EXCHANGE_ID,
+                tokenInAddr,
+                tokenOutAddr,
+                amountInWei,
+                amountOutMin,
+            ],
+        }));
+        return {
+            client,
+            from,
+            recipient,
+            resolvedIn,
+            resolvedOut,
+            tokenInAddr,
+            tokenOutAddr,
+            amountIn,
+            amountInWei,
+            expectedOutWei,
+            amountOutMin,
+            swapData,
+            slippageTolerance,
+            amountSide: resolved.amountSide,
+        };
+    }
+    buildReserveApprovalData() {
+        return taggedCalldata(encodeFunctionData({
+            abi: erc20Abi,
+            functionName: "approve",
+            args: [GOODDOLLAR_MENTO_BROKER, maxUint256],
+        }));
+    }
+    async estimateReserveSwapGas(client, from, swapData, tokenInAddr, approvalNeeded) {
+        const swapEstimateRequest = {
+            account: from,
+            to: GOODDOLLAR_MENTO_BROKER,
+            data: swapData,
+            value: 0n,
+        };
+        if (!approvalNeeded) {
+            const gas = await client.estimateGas(swapEstimateRequest);
+            return gas.toString();
+        }
+        for (const mappingSlot of ALLOWANCE_MAPPING_SLOTS) {
+            try {
+                const gas = await client.estimateGas({
+                    ...swapEstimateRequest,
+                    stateOverride: erc20AllowanceStateOverride(tokenInAddr, from, GOODDOLLAR_MENTO_BROKER, maxUint256, mappingSlot),
+                });
+                return gas.toString();
+            }
+            catch (error) {
+                const isLast = mappingSlot === ALLOWANCE_MAPPING_SLOTS.at(-1);
+                if (isLast) {
+                    throw error;
+                }
+            }
+        }
+        throw new Error("Could not estimate GoodDollar reserve swap gas: failed to simulate ERC-20 allowance for this token.");
+    }
+    /**
+     * Simulate gas for a GoodDollar reserve swap from `from`, including approval if needed.
+     */
+    async estimateReserveSwap(from, tokenIn, tokenOut, amount, params) {
+        const built = await this.buildReserveSwap(from, tokenIn, tokenOut, amount, params);
+        const { client, resolvedIn, resolvedOut, tokenInAddr, amountInWei, expectedOutWei, amountOutMin, swapData, slippageTolerance, recipient, } = built;
+        const allowance = await client.readContract({
+            address: tokenInAddr,
+            abi: erc20Abi,
+            functionName: "allowance",
+            args: [from, GOODDOLLAR_MENTO_BROKER],
+        });
+        const approvalNeeded = allowance < amountInWei;
+        const approvalGas = approvalNeeded
+            ? (await client.estimateGas({
+                account: from,
+                to: tokenInAddr,
+                data: this.buildReserveApprovalData(),
+            })).toString()
+            : undefined;
+        const swapGas = await this.estimateReserveSwapGas(client, from, swapData, tokenInAddr, approvalNeeded);
+        const approvalGasBig = approvalGas ? BigInt(approvalGas) : 0n;
+        const totalGas = (approvalGasBig + BigInt(swapGas)).toString();
+        return {
+            ...this.baseReserveQuoteFields(resolvedIn, resolvedOut, built.amountIn, expectedOutWei, built.amountSide),
+            from,
+            recipient,
+            amountOutMin: formatUnits(amountOutMin, resolvedOut.decimals),
+            approvalNeeded,
+            approvalGas,
+            swapGas,
+            totalGas,
+            slippageTolerance,
+        };
+    }
+    /**
+     * Build unsigned GoodDollar reserve swap steps (approve + swapIn when needed).
+     */
+    async prepareReserveSwap(from, tokenIn, tokenOut, amount, params) {
+        const built = await this.buildReserveSwap(from, tokenIn, tokenOut, amount, params);
+        const { client, resolvedIn, resolvedOut, tokenInAddr, amountInWei, expectedOutWei, swapData, recipient, } = built;
+        const displayIn = trimDisplayDecimals(built.amountIn);
+        const displayOut = trimDisplayDecimals(formatUnits(expectedOutWei, resolvedOut.decimals));
+        const steps = [];
+        const allowance = await client.readContract({
+            address: tokenInAddr,
+            abi: erc20Abi,
+            functionName: "allowance",
+            args: [from, GOODDOLLAR_MENTO_BROKER],
+        });
+        if (allowance < amountInWei) {
+            steps.push({
+                kind: "erc20",
+                to: tokenInAddr,
+                data: this.buildReserveApprovalData(),
+                value: "0",
+                description: `Approve ${resolvedIn.symbol} for GoodDollar reserve`,
+            });
+        }
+        steps.push({
+            kind: "contract",
+            to: GOODDOLLAR_MENTO_BROKER,
+            data: swapData,
+            value: "0",
+            description: `Swap ${displayIn} ${resolvedIn.symbol} → ~${displayOut} ${resolvedOut.symbol} via GoodDollar reserve`,
+        });
+        await this.estimateReserveSwapGas(client, from, swapData, tokenInAddr, allowance < amountInWei);
+        const flow = {
+            network: "mainnet",
+            from,
+            summary: `GoodDollar reserve: ${displayIn} ${resolvedIn.symbol} → ${displayOut} ${resolvedOut.symbol}${recipient !== from ? ` (recipient ${recipient})` : ""}`,
+            steps,
+        };
+        return serializePreparedFlow(flow);
+    }
+    effectiveAuthCount(dateAuthenticated, authCount, optionsLength) {
+        if (dateAuthenticated < LEGACY_AUTH_CUTOFF) {
+            return optionsLength - 1;
+        }
+        if (authCount >= optionsLength) {
+            return 0;
+        }
+        return authCount;
+    }
+    async fetchReverifyDaysOptions(client, contract) {
+        const options = [];
+        for (let index = 0; index < 8; index++) {
+            try {
+                const value = await client.readContract({
+                    address: contract,
+                    abi: goodDollarIdentityAbi,
+                    functionName: "reverifyDaysOptions",
+                    args: [BigInt(index)],
+                });
+                options.push(Number(value));
+            }
+            catch {
+                break;
+            }
+        }
+        return options;
+    }
+    buildReverificationProgress(dateAuthenticated, currentReverificationPeriodDays, maxReverificationPeriodDays) {
+        const nowSec = Math.floor(Date.now() / 1000);
+        const daysSinceLastAuthentication = Math.floor((nowSec - dateAuthenticated) / 86400);
+        const daysUntilReverificationRequired = currentReverificationPeriodDays - daysSinceLastAuthentication;
+        const reverificationRequiredTimestamp = dateAuthenticated + currentReverificationPeriodDays * 86400;
+        const isReverificationOverdue = daysUntilReverificationRequired < 0;
+        const reverificationProgressPercent = Math.min(100, Math.max(0, Math.round((daysSinceLastAuthentication / currentReverificationPeriodDays) *
+            100)));
+        return {
+            daysSinceLastAuthentication,
+            currentReverificationPeriodDays,
+            maxReverificationPeriodDays,
+            daysUntilReverificationRequired,
+            reverificationRequiredOn: formatUnixDate(reverificationRequiredTimestamp),
+            reverificationProgressPercent,
+            isReverificationOverdue,
+        };
+    }
+}
+//# sourceMappingURL=gooddollar.service.js.map