@onride/agent 0.0.0-stage → 0.5.1-rc.0

package/dist/agent/deposits.js

@@ -0,0 +1,309 @@
+import QRCode from "qrcode";
+import { Contract, JsonRpcProvider, FetchRequest, id as eventId } from "ethers";
+import { AgentError } from "./contracts.js";
+import { cash, D, uid, now } from "./domain.js";
+const chains = {
+    Ethereum: "1",
+    Arbitrum: "42161",
+    Base: "8453",
+    Polygon: "137",
+};
+const bridgeUrl = "https://bridge.polymarket.com";
+const validAddress = (value) => typeof value === "string" && /^0x[a-fA-F0-9]{40}$/.test(value);
+export class DepositReads {
+    core;
+    network;
+    request;
+    constructor(core, network, request = fetch) {
+        this.core = core;
+        this.network = network;
+        this.request = request;
+    }
+    async bridge(path, body) {
+        const response = await this.request(`${bridgeUrl}/${path}`, {
+            method: body ? "POST" : "GET",
+            headers: { "Content-Type": "application/json" },
+            ...(body ? { body: JSON.stringify(body) } : {}),
+            signal: AbortSignal.timeout(12000),
+            redirect: "error",
+        });
+        if (!response.ok)
+            throw new AgentError("DEPOSIT_PROVIDER_UNAVAILABLE", "Deposit provider did not return verified funding details.", true, 503);
+        return response.json();
+    }
+    async options() {
+        const routes = this.network === "mainnet"
+            ? [
+                {
+                    market: "perps",
+                    asset: "USDC",
+                    network: "Arbitrum",
+                    destination: "Ride funding wallet",
+                    activation_required: true,
+                },
+            ]
+            : [];
+        const supported = await this.bridge("supported-assets");
+        for (const item of supported.supportedAssets ??
+            supported.supported_assets ??
+            []) {
+            const symbol = item.token?.symbol ?? item.symbol, chain = String(item.chainId ?? item.chain_id);
+            const network = Object.keys(chains).find((n) => chains[n] === chain);
+            if (network &&
+                ["USDC", "USDT"].includes(symbol) &&
+                validAddress(item.token?.address))
+                routes.push({
+                    market: "prediction",
+                    asset: symbol,
+                    network,
+                    min_deposit_usd: item.minCheckoutUsd ?? item.min_deposit_usd ?? null,
+                    destination: "Prediction account",
+                    activation_required: false,
+                });
+        }
+        return {
+            routes,
+            notes: [
+                "Only verified provider routes are offered. Sending to a funding wallet does not fund Hyperliquid until the existing Ride deposit step is completed.",
+            ],
+        };
+    }
+    async walletBalance(address) {
+        const request = new FetchRequest(process.env.RIDE_AGENT_ARBITRUM_RPC_URL ?? "https://arb1.arbitrum.io/rpc");
+        request.timeout = 12000;
+        const rpc = new JsonRpcProvider(request, 42161, { staticNetwork: true });
+        try {
+            if (Number(await rpc.send("eth_chainId", [])) !== 42161)
+                throw new AgentError("DEPOSIT_NETWORK_MISMATCH", "Funding RPC returned a different chain; no deposit address is shown.", true, 503);
+            const token = new Contract("0xaf88d065e77c8cC2239327C5EDb3A432268e5831", ["function balanceOf(address) view returns (uint256)"], rpc);
+            const balance = await token.balanceOf(address);
+            return cash(D(balance.toString()).div(1e6));
+        }
+        finally {
+            rpc.destroy();
+        }
+    }
+    async address(user, input, portfolioId) {
+        if (input.market === "perps") {
+            if (this.network !== "mainnet" ||
+                input.asset !== "USDC" ||
+                input.network !== "Arbitrum")
+                throw new AgentError("UNSUPPORTED_DEPOSIT_ROUTE", "Perps funding currently accepts native USDC on Arbitrum into the Ride funding wallet; complete the venue deposit in Ride.", false, 400);
+            let owned;
+            try {
+                owned = await this.core("perps_wallet", { user_id: user });
+            }
+            catch {
+                owned = await this.core("perps_funding_prepare", { user_id: user });
+            }
+            if (!validAddress(owned.master))
+                throw new AgentError("ACCOUNT_NOT_READY", "Prepare your existing Ride trading account before requesting an address.");
+            return {
+                id: uid("deposit"),
+                market: "perps",
+                asset: "USDC",
+                network: "Arbitrum",
+                address: owned.master,
+                provider: "wallet",
+                created_at: now(),
+                baseline_wallet_usdc: await this.walletBalance(owned.master),
+                ...(input.amount_usdc ? { amount_usdc: cash(input.amount_usdc) } : {}),
+            };
+        }
+        const supported = await this.bridge("supported-assets");
+        const assetContracts = (supported.supportedAssets ?? [])
+            .filter((item) => String(item.chainId) === chains[input.network] &&
+            item.token?.symbol === input.asset &&
+            validAddress(item.token?.address))
+            .map((item) => item.token.address.toLowerCase());
+        const route = (await this.options()).routes.find((r) => r.market === input.market &&
+            r.asset === input.asset &&
+            r.network === input.network);
+        if (!route)
+            throw new AgentError("UNSUPPORTED_DEPOSIT_ROUTE", "This asset/network route is not currently supported by the provider.", false, 400);
+        if (input.amount_usdc &&
+            route.min_deposit_usd &&
+            D(input.amount_usdc).lt(route.min_deposit_usd))
+            throw new AgentError("DEPOSIT_BELOW_MINIMUM", "The amount is below the provider's current deposit minimum.", false, 400);
+        const owned = await this.core("prediction_wallet", {
+            user_id: user,
+            portfolio_id: portfolioId ?? null,
+        });
+        if (!validAddress(owned.wallet))
+            throw new AgentError("ACCOUNT_NOT_READY", "Prepare your existing prediction account in Ride first.");
+        const response = await this.bridge("deposit", { address: owned.wallet });
+        const address = response.address?.evm ?? response.addresses?.evm;
+        if (!validAddress(address))
+            throw new AgentError("DEPOSIT_PROVIDER_UNAVAILABLE", "The provider returned an invalid deposit address.", true, 503);
+        return {
+            id: uid("deposit"),
+            market: "prediction",
+            asset: input.asset,
+            network: input.network,
+            address,
+            provider: "polymarket_bridge",
+            asset_contracts: assetContracts,
+            created_at: now(),
+            ...(input.amount_usdc ? { amount_usdc: cash(input.amount_usdc) } : {}),
+        };
+    }
+    async status(deposit, user) {
+        if (deposit.provider === "wallet") {
+            const balance = await this.walletBalance(deposit.address), received = D(balance).minus(deposit.baseline_wallet_usdc ?? balance);
+            let trading = {
+                trading_balance_usdc: null,
+                available_to_copy: false,
+                trading_observation: "unavailable",
+            };
+            if (user) {
+                const owned = await this.core("perps_wallet", { user_id: user });
+                if (!validAddress(owned.master) ||
+                    owned.master.toLowerCase() !== deposit.address.toLowerCase())
+                    throw new AgentError("FUNDING_WALLET_CHANGED", "This receiving account is no longer the active trading account. Review a new request.");
+                const response = await this.request("https://api.hyperliquid.xyz/info", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        type: "clearinghouseState",
+                        user: owned.master,
+                    }),
+                    signal: AbortSignal.timeout(12000),
+                    redirect: "error",
+                });
+                if (!response.ok)
+                    throw new AgentError("TRADING_BALANCE_UNAVAILABLE", "Trading balance could not be verified.", true, 503);
+                const state = (await response.json());
+                if (typeof state.withdrawable !== "string" ||
+                    !state.marginSummary ||
+                    !Array.isArray(state.assetPositions) ||
+                    !D(state.withdrawable).isFinite() ||
+                    D(state.withdrawable).lt(0))
+                    throw new AgentError("TRADING_BALANCE_UNAVAILABLE", "Trading balance evidence is incomplete.", true, 503);
+                const active = owned.status === 4 || owned.status === "active";
+                trading = {
+                    trading_balance_usdc: cash(state.withdrawable),
+                    trading_observed_at: now(),
+                    available_to_copy: active && D(state.withdrawable).gt(0),
+                    sufficient_for_amount: D(state.withdrawable).gte(deposit.funding?.amount_usdc ?? deposit.amount_usdc ?? "5"),
+                    activation_required: !active,
+                    trading_observation: "verified",
+                };
+            }
+            let fundingReceipt = "unavailable", verifiedCredit = false;
+            const f = deposit.funding;
+            if (f?.transaction_hash) {
+                const response = await this.request(process.env.RIDE_AGENT_ARBITRUM_RPC_URL ??
+                    "https://arb1.arbitrum.io/rpc", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: 1,
+                        method: "eth_getTransactionReceipt",
+                        params: [f.transaction_hash],
+                    }),
+                    signal: AbortSignal.timeout(12000),
+                    redirect: "error",
+                });
+                if (!response.ok)
+                    throw new AgentError("FUNDING_RECEIPT_UNAVAILABLE", "Funding receipt is not available; do not resubmit.", true, 503);
+                const receipt = (await response.json()).result;
+                if (!receipt)
+                    fundingReceipt = "pending";
+                else if (receipt.status === "0x0")
+                    fundingReceipt = "reverted";
+                else if (receipt.status === "0x1" &&
+                    receipt.transactionHash?.toLowerCase() ===
+                        f.transaction_hash.toLowerCase() &&
+                    receipt.to?.toLowerCase() ===
+                        "0x2df1c51e09aecf9cacb7bc98cb1742757f163df7") {
+                    const amountRaw = BigInt(D(f.amount_usdc).times(1e6).toFixed(0));
+                    const transferred = (receipt.logs ?? []).some((log) => log.address?.toLowerCase() ===
+                        "0xaf88d065e77c8cc2239327c5edb3a432268e5831" &&
+                        log.topics?.[0] ===
+                            eventId("Transfer(address,address,uint256)") &&
+                        log.topics?.[1]?.slice(-40).toLowerCase() ===
+                            deposit.address.slice(2).toLowerCase() &&
+                        log.topics?.[2]?.slice(-40).toLowerCase() ===
+                            "2df1c51e09aecf9cacb7bc98cb1742757f163df7" &&
+                        /^0x[a-fA-F0-9]{64}$/.test(log.data) &&
+                        BigInt(log.data) === amountRaw);
+                    if (transferred) {
+                        fundingReceipt = "confirmed";
+                        verifiedCredit =
+                            trading.trading_observation === "verified" &&
+                                D(trading.trading_balance_usdc).gte(D(f.quote.baseline_trading_available_usdc ?? "0").plus(f.amount_usdc));
+                    }
+                }
+            }
+            return {
+                deposit_id: deposit.id,
+                status: trading.available_to_copy
+                    ? "trading_ready"
+                    : D(trading.trading_balance_usdc ?? "0").gt(0)
+                        ? "activation_required"
+                        : received.gt(0)
+                            ? "wallet_balance_increased"
+                            : "awaiting_deposit",
+                wallet_balance_usdc: balance,
+                received_usdc: received.gt(0) ? cash(received) : null,
+                ...trading,
+                funding_status: deposit.funding?.status ?? null,
+                funding_receipt: fundingReceipt,
+                funding_credit_verified: verifiedCredit,
+                transaction_hash: deposit.funding?.transaction_hash ?? null,
+                next_action: trading.available_to_copy
+                    ? "Trading balance is verified. Refresh the saved plan before confirming copying."
+                    : trading.activation_required &&
+                        D(trading.trading_balance_usdc ?? "0").gt(0)
+                        ? "Open the Ride funding confirmation page to activate this funded trading account."
+                        : "Use prepare_deposit with the exact amount to open Ride's funding confirmation page. Wallet receipt alone is not trading credit. Do not repeat an unresolved submission.",
+            };
+        }
+        const response = await this.bridge(`status/${deposit.address}`);
+        const transactions = (response.transactions ?? [])
+            .filter((t) => Number(t.createdTimeMs) >= deposit.created_at &&
+            String(t.fromChainId) === chains[deposit.network] &&
+            !!deposit.asset_contracts?.includes(String(t.fromTokenAddress).toLowerCase()))
+            .map((t) => ({
+            status: String(t.status),
+            at: Number(t.createdTimeMs),
+            transaction_hash: /^0x[a-fA-F0-9]{64}$/.test(t.txHash)
+                ? t.txHash
+                : null,
+        }));
+        return {
+            deposit_id: deposit.id,
+            status: transactions.some((t) => t.status === "COMPLETED")
+                ? "provider_completed"
+                : transactions.some((t) => t.status === "FAILED")
+                    ? "failed"
+                    : transactions.length
+                        ? "processing"
+                        : "awaiting_deposit",
+            transactions,
+            available_to_copy: null,
+            next_action: "Refresh the saved plan; only verified available account collateral can authorize copying.",
+        };
+    }
+}
+export async function depositView(deposit) {
+    return {
+        ...deposit,
+        baseline_wallet_usdc: undefined,
+        asset_contracts: undefined,
+        funding: undefined,
+        qr_data_url: await QRCode.toDataURL(deposit.address, {
+            errorCorrectionLevel: "M",
+            margin: 2,
+            width: 240,
+        }),
+        activation_required: deposit.provider === "wallet",
+        destination: deposit.provider === "wallet"
+            ? "Ride funding wallet"
+            : "Prediction bridge",
+        instructions: deposit.provider === "wallet"
+            ? "Send only native USDC on Arbitrum to this owned funding wallet. Then open the Ride funding confirmation page to move the chosen amount to the trading account, activate it if needed, and verify trading balance."
+            : "Use only the selected supported asset and network. Check provider status before refreshing available collateral.",
+    };
+}

package/dist/agent/discovery.js

@@ -0,0 +1,205 @@
+import { AgentError } from "./contracts.js";
+import { recommend, eligibleCandidates, fingerprint, now, uid, cash, D, maximumUserLeverage, } from "./domain.js";
+import { compatibility } from "./conversational.js";
+export function choosePlanPreferences(p, pool, selected) {
+    if (selected)
+        return {
+            ...p,
+            portfolio_kind: selected.length === 1 ? "single" : "basket",
+            basket_size: selected.length,
+        };
+    if (p.portfolio_kind === "single" || p.basket_size != null)
+        return {
+            ...p,
+            portfolio_kind: p.portfolio_kind === "single" || p.basket_size === 1
+                ? "single"
+                : "basket",
+        };
+    // Prefer up to four feasible sleeves. This is a disclosed suggestion, never a minimum count.
+    for (let count = 4; count >= 1; count--) {
+        const trial = {
+            ...p,
+            portfolio_kind: count === 1 ? "single" : "basket",
+            basket_size: count,
+        };
+        try {
+            recommend(trial, pool);
+            return trial;
+        }
+        catch (e) {
+            if (!(e instanceof AgentError) || e.code !== "NO_EXECUTABLE_PLAN")
+                throw e;
+        }
+    }
+    return { ...p, portfolio_kind: "single", basket_size: 1 };
+}
+export function saveDiscovery(s, pref, pool) {
+    const at = now();
+    s.discovery = {
+        id: uid("discovery"),
+        preference_hash: fingerprint(pref),
+        created_at: at,
+        expires_at: Math.min(at + 5 * 60_000, ...pool.filter((c) => c.expires_at > at).map((c) => c.expires_at)),
+        candidates: pool,
+    };
+}
+export function traderRow(c) {
+    return {
+        trader_id: c.id,
+        nickname: c.handle,
+        market: c.market,
+        score: c.score,
+        score_version: c.score_version,
+        assets: c.assets,
+        style: c.style,
+        historical_roi_pct: c.source_roi_pct,
+        historical_drawdown_pct: c.source_drawdown_pct,
+        metric_window: c.metric_window ?? null,
+        metric_provenance: c.metric_provenance ?? null,
+        metric_unavailable_reason: c.metric_unavailable_reason ?? null,
+        eligibility: c.eligibility,
+        scored_at: c.scored_at,
+    };
+}
+export function browse(s, pref, args, user, cursor) {
+    const snapshot = s.discovery;
+    if (!snapshot ||
+        snapshot.expires_at <= now() ||
+        snapshot.preference_hash !== fingerprint(pref))
+        throw new AgentError("DISCOVERY_REFRESH_REQUIRED", "The candidate snapshot expired or preferences changed. Call recommend_traders to refresh; your choices and saved plan remain available.", true);
+    const sort = args.sort_by ?? "score", direction = args.direction ?? (sort === "drawdown" ? "asc" : "desc");
+    const query = fingerprint({
+        snapshot: snapshot.id,
+        sort,
+        direction,
+        compare_ids: args.compare_ids,
+    });
+    const decoded = args.cursor ? cursor.decode(user, args.cursor) : null;
+    if (decoded && (decoded.id !== query || decoded.at < 0))
+        throw new AgentError("INVALID_CURSOR", "Restart this sort or comparison without a cursor; the saved plan is unchanged.");
+    const allowed = eligibleCandidates(pref, snapshot.candidates);
+    const ids = args.compare_ids;
+    const rows = ids
+        ? snapshot.candidates.filter((c) => ids.includes(c.id))
+        : allowed;
+    const metric = (c) => sort === "score"
+        ? c.score
+        : sort === "drawdown"
+            ? c.source_drawdown_pct
+            : c.source_roi_pct;
+    rows.sort((a, b) => {
+        const av = metric(a), bv = metric(b);
+        if (av == null && bv == null)
+            return a.id.localeCompare(b.id);
+        if (av == null)
+            return 1;
+        if (bv == null)
+            return -1;
+        return ((direction === "asc" ? av - bv : bv - av) || a.id.localeCompare(b.id));
+    });
+    const offset = decoded?.at ?? 0, limit = args.limit ?? 5, page = rows.slice(offset, offset + limit);
+    const next = offset + page.length;
+    return {
+        candidates: page,
+        candidate_table: page.map(traderRow),
+        candidates_meta: {
+            total: rows.length,
+            returned: page.length,
+            offset,
+            has_more: next < rows.length,
+            next_cursor: next < rows.length ? cursor.encode(user, next, query) : null,
+            sort_by: sort,
+            direction,
+            snapshot_at: snapshot.created_at,
+            expires_at: snapshot.expires_at,
+            scope: "Entire current verified source pool, not just this page. The production Perps source profiles at most the top 30 by Copy Score; this is not all market traders.",
+            historical_metric_note: "Source history is not follower profit. Compare periods and score versions before drawing conclusions; unknown periods are unavailable, never assumed equal.",
+            period_comparable: page.length > 0 &&
+                page.every((c) => c.metric_window != null) &&
+                new Set(page.map((c) => fingerprint(c.metric_window))).size === 1,
+        },
+        missing_trader_ids: ids?.filter((id) => !rows.some((c) => c.id === id)) ?? [],
+        selected_trader_ids: s.selected_trader_ids ?? [],
+        saved_plan_id: s.plans.at(-1)?.id ?? null,
+        plan_unchanged: true,
+        comparison: ids
+            ? {
+                rows: page.map((c) => ({
+                    ...traderRow(c),
+                    matches_preferences: allowed.some((a) => a.id === c.id),
+                })),
+                overlaps: compatibility({
+                    allocations: rows.map((c) => ({ trader: c, amount_usdc: "1" })),
+                }).pairs,
+                historical_loss_correlation: null,
+            }
+            : null,
+    };
+}
+export function conversationView(plan, collection, candidates, selectedByUser) {
+    return {
+        presentation: "native_conversation",
+        preference_collection: collection,
+        recommended_portfolio: plan?.allocations.map((a) => ({
+            ...traderRow(a.trader),
+            amount_usdc: a.amount_usdc,
+            leverage_mode: a.leverage_mode ?? "cap",
+            leverage_cap: a.leverage_cap,
+            maximum_leverage_cap: maximumUserLeverage(a.trader),
+            reason: `Copy Score ${a.trader.score}; ${a.trader.style}; ${a.trader.assets.join("/")}; ${plan.allocations.length === 1 ? "single-trader concentration" : `capital spread across ${plan.allocations.length} selected traders`}.`,
+        })) ?? [],
+        candidate_table: candidates.slice(0, 5).map(traderRow),
+        selection_origin: selectedByUser ? "user" : "system_recommendation",
+        planning_constraints: {
+            max_traders: 8,
+            minimum_allocation_usdc: candidates.length && candidates.every((c) => c.market === "prediction")
+                ? "50"
+                : null,
+            perps_product_minimum_usdc: null,
+            prediction_product_minimum_usdc: "50",
+            type: "Positive Perps USDC allocation; live venue minimums apply to each sized order, not to allocated collateral. Prediction allocation rules are unchanged.",
+            order_minimum_validation: "after_netting_and_quantity_rounding_at_execution",
+            leverage_mode: plan?.allocations.some((a) => a.leverage_mode === "follow_source")
+                ? "follow_source"
+                : "cap",
+            follow_source_leverage_supported: true,
+            follow_source_requires_risk_cap: false,
+            follow_source_requires_venue_limits: true,
+            risk_controls_required: true,
+            maximum_agent_leverage: null,
+            maximum_custom_leverage_cap: 40,
+            default_perps_leverage_cap: null,
+            custom_leverage_cap_supported: true,
+        },
+        final_review: plan
+            ? {
+                budget_usdc: plan.preferences.budget_usdc,
+                allocated_usdc: cash(plan.allocations.reduce((n, a) => n.plus(a.amount_usdc), D(0))),
+                unallocated_usdc: cash(D(plan.preferences.budget_usdc).minus(plan.allocations.reduce((n, a) => n.plus(a.amount_usdc), D(0)))),
+                market: plan.preferences.market,
+                selected_markets: [
+                    ...new Set(plan.allocations.map((a) => a.trader.market)),
+                ],
+                portfolio_loss_trigger_pct: plan.preferences.loss_trigger_pct,
+                portfolio_loss_trigger_usdc: cash(D(plan.preferences.budget_usdc)
+                    .times(plan.preferences.loss_trigger_pct)
+                    .div(100)),
+                traders: plan.allocations.map((a) => ({
+                    trader_id: a.trader.id,
+                    amount_usdc: a.amount_usdc,
+                    copy_mode: a.copy_mode ?? "ride_recommends",
+                    leverage_cap: a.leverage_cap,
+                    leverage_mode: a.leverage_mode ?? "cap",
+                    maximum_leverage_cap: maximumUserLeverage(a.trader),
+                    stop_loss_pct: a.stop_loss_pct,
+                    loss_policy: a.loss_policy ?? "exit",
+                    emergency_exit_pct: a.emergency_exit_pct ?? null,
+                })),
+                funds_verified: false,
+                execution_authorized: false,
+                requires_ride_confirmation: true,
+            }
+            : null,
+        instruction: "Show two compact chat tables: recommended portfolio (trader, amount, reason) and top 5 candidates (ID, score, assets, style, history). A follow_source allocation with leverage_cap null follows verified source leverage without an extra user cap by default; say this explicitly. A numeric cap is user-editable independently of the recommendation (Perps 1–40x), and null clears it. Actual leverage still respects the approved optional cap, fresh venue limits, budget and risk checks. Never invent a 3x or 10x default cap. Disclose defaults and risk settings. Offer accept/customize; browse_traders pages or compares without replacing the plan. No funding needed for this preview. Missing history is unavailable. Best means prioritized within current conditions, not highest guaranteed returns.",
+    };
+}