+ );
+}
+
+/** A small (i) that explains a term on hover or keyboard focus. */
+export function InfoTip({ children }: { children: ReactNode }) {
+ return (
+
+ );
+}
+
+/** "How this works" panel: closed by default, so a page stays short for people who know it. */
+export function Explain({
+ title = "How this works",
+ children,
+ open,
+}: {
+ title?: ReactNode;
+ children: ReactNode;
+ open?: boolean;
+}) {
+ return (
+
+ );
+}
+
+export function Callout({
+ tone = "info",
+ title,
+ children,
+}: {
+ tone?: "info" | "tip" | "warn" | "good";
+ title?: ReactNode;
+ children: ReactNode;
+}) {
+ const t = {
+ info: "border-ink-200 bg-ink-50 text-ink-800",
+ tip: "border-sand-400 bg-sand-100 text-ink-900",
+ warn: "border-warn/40 bg-warn/10 text-ink-900",
+ good: "border-good/30 bg-good/10 text-ink-900",
+ }[tone];
+ return (
+
+ );
+}
+
+/** Numbered steps; `done` ticks a step off, `current` highlights it. */
+export function Steps({
+ items,
+}: {
+ items: { title: ReactNode; body?: ReactNode; done?: boolean; current?: boolean }[];
+}) {
+ return (
+
+ );
+}
+
+/** A live "what will happen" box next to a form. */
+export function Preview({
+ title = "What will happen",
+ children,
+}: {
+ title?: ReactNode;
+ children: ReactNode;
+}) {
+ return (
+
+ );
+}
+
+/** One line of a Preview or a breakdown: label on the left, value on the right. */
+export function Row({ label, value, strong }: { label: ReactNode; value: ReactNode; strong?: boolean }) {
+ return (
+
+ );
+}
+
+export function Progress({ value, tone = "ink" }: { value: number; tone?: "ink" | "good" | "warn" }) {
+ const pct = Math.max(0, Math.min(100, value));
+ const t = { ink: "bg-ink-700", good: "bg-good", warn: "bg-warn" }[tone];
+ return (
+
);
}
export function SimulatedBanner({ children }: { children?: ReactNode }) {
return (
-
+
SIMULATED (testnet){" "}
{children ?? "Mock USDC on NEAR testnet. No real money moves."}
);
}
+// ---------- errors ----------
+
+/** Contract and network errors, translated into what to do next. */
+const ERROR_HINTS: [RegExp, string][] = [
+ [/ERR_COOLDOWN/, "The 120-second waiting period isn't over yet. Wait for the countdown, then claim."],
+ [/ERR_HANDLE_TAKEN/, "Someone already registered this handle. Pick another one."],
+ [/ERR_ALREADY_REGISTERED/, "This wallet is already a merchant. Reload the page."],
+ [/ERR_BOUNDS_LIMIT/, "The amount must be between 50 USDC and the offer's limit."],
+ [/ERR_OFFER_EXPIRED/, "Offers are valid for 1 hour. Request a new one."],
+ [/ERR_OFFER_NOT_OPEN/, "This offer was already used or replaced. Request a new one."],
+ [/ERR_ACTIVE_LOAN/, "You already have a loan. Repay it before taking another."],
+ [/ERR_DEFAULTED/, "This merchant has a defaulted loan, so new loans are blocked."],
+ [
+ /ERR_LIQUIDITY|ERR_UTILIZATION/,
+ "The vault doesn't have enough free cash right now. Try a smaller amount.",
+ ],
+ [/ERR_DAILY_CAP/, "Today's limit for first-time borrowers is used up. Try again tomorrow (UTC)."],
+ [/ERR_NOTHING_TO_CLAIM/, "There is nothing to claim yet."],
+ [/ERR_INSUFFICIENT_SHARES/, "You don't have that many shares."],
+ [/rate limited/i, "Too many requests in a minute. Wait a moment and try again."],
+ [/test USDC in the last 10 minutes/, "The faucet gives each account 1,000 test USDC every 10 minutes."],
+ [
+ /Failed to fetch|NetworkError|fetch failed|Load failed/i,
+ "The backend may be waking up (free hosting sleeps when idle). Wait a minute and try again.",
+ ],
+ [/User (rejected|cancelled)|rejected the request/i, "You cancelled it in your wallet. Nothing happened."],
+];
+
export function ErrorText({ error }: { error: unknown }) {
if (!error) return null;
+ const msg = error instanceof Error ? error.message : String(error);
+ const hint = ERROR_HINTS.find(([re]) => re.test(msg))?.[1];
return (
-
- {error instanceof Error ? error.message : String(error)}
-
+
+ {hint &&
{hint}
}
+
{msg}
+
);
}
diff --git a/apps/web/lib/live.ts b/apps/web/lib/live.ts
new file mode 100644
index 0000000..39ad626
--- /dev/null
+++ b/apps/web/lib/live.ts
@@ -0,0 +1,30 @@
+"use client";
+// Live numbers for previews: the vault (chain), the INR rate (the gateway's oracle) and its limits.
+import { useEffect, useState } from "react";
+import { credit, gateway } from "./chain";
+import { GATEWAY_URL } from "./env";
+import { useAsync } from "./useAsync";
+
+/** Paise per USDC from the gateway's FX oracle; null while loading or if the backend is asleep. */
+export function useLiveRate(): { ratePpu: number | null; sources: string[] } {
+ const [r, setR] = useState<{ ratePpu: number | null; sources: string[] }>({ ratePpu: null, sources: [] });
+ useEffect(() => {
+ let live = true;
+ fetch(`${GATEWAY_URL}/health`)
+ .then((res) => res.json() as Promise<{ oracle?: { rate_ppu?: number; sources?: string[] } }>)
+ .then((b) => {
+ if (live && b.oracle?.rate_ppu) setR({ ratePpu: b.oracle.rate_ppu, sources: b.oracle.sources ?? [] });
+ })
+ .catch(() => undefined);
+ return () => {
+ live = false;
+ };
+ }, []);
+ return r;
+}
+
+export const useVault = () => useAsync(() => credit.vault(), []);
+export const useGatewayLimits = () => useAsync(() => gateway.limits(), []);
+
+/** A typical rate when the oracle can't be reached, clearly labelled as such where it is used. */
+export const FALLBACK_RATE_PPU = 10_000;
diff --git a/apps/web/lib/sim.ts b/apps/web/lib/sim.ts
new file mode 100644
index 0000000..275c10b
--- /dev/null
+++ b/apps/web/lib/sim.ts
@@ -0,0 +1,228 @@
+// Previews of what the protocol will do, computed in the browser. Each function mirrors the
+// contracts' integer maths exactly (settlement split, credit router/loans/vault, shared/fx) or calls
+// the underwriter's own scoring package, so a preview matches the chain to the last micro-USDC.
+// They only predict: the contracts and the underwriter agent decide.
+import {
+ decide,
+ features,
+ scoringPolicy,
+ SCALE,
+ type Decision,
+ type Features,
+ type Grade,
+} from "@runway/scoring";
+import { PROFILE } from "./env";
+
+export const BPS = 10_000n;
+/** contracts/shared consts.rs: protects the share price from donation and rounding attacks. */
+export const VIRTUAL_OFFSET = 1_000_000n;
+const POLICY = PROFILE.policy;
+
+const min = (a: bigint, b: bigint) => (a < b ? a : b);
+const ceilDiv = (a: bigint, b: bigint) => (a + b - 1n) / b;
+
+// ---------- payment split (contracts/settlement on_balance) ----------
+
+/** repay = floor(inflow × repay_bps / 10,000); the merchant gets the rest. No loan → repay = 0. */
+export function splitPayment(inflow: bigint, repayBps: number | null | undefined) {
+ const repay = repayBps ? (inflow * BigInt(repayBps)) / BPS : 0n;
+ return { repay, merchant: inflow - repay };
+}
+
+// ---------- loans (contracts/credit loans.rs) ----------
+
+/** accept_offer: drawing less than the limit scales the repay share down (never below the minimum). */
+export function drawTerms(offer: { limit: bigint; feeBps: number; repayBps: number }, amount: bigint) {
+ const scaled = Number(ceilDiv(BigInt(offer.repayBps) * amount, offer.limit));
+ const repayBps = Math.max(scaled, POLICY.repayBpsMin);
+ const fee = (amount * BigInt(offer.feeBps)) / BPS;
+ return { repayBps, fee, owed: amount + fee };
+}
+
+/** The least that must be repaid in each loan period to avoid a missed period. */
+export const periodRequirement = (owed: bigint, remaining: bigint = owed) =>
+ min((owed * BigInt(POLICY.minPeriodRepayBps)) / BPS, remaining);
+
+export interface LoanBook {
+ principal: bigint;
+ owed: bigint;
+ repaid: bigint;
+ principalRepaid: bigint;
+}
+
+export interface RepayStep {
+ inflow: bigint;
+ /** the settlement account's repay part */
+ repayPart: bigint;
+ /** what the loan actually took (never more than is still owed) */
+ applied: bigint;
+ principalPart: bigint;
+ feePart: bigint;
+ toReserve: bigint;
+ toLenders: bigint;
+ toMerchant: bigint;
+ repaidAfter: bigint;
+ remainingAfter: bigint;
+ done: boolean;
+}
+
+/** One settled payment against an open loan: settlement split, then credit apply_regular. */
+export function applyPayment(
+ loan: LoanBook,
+ inflow: bigint,
+ repayBps: number,
+): { step: RepayStep; loan: LoanBook } {
+ const { repay } = splitPayment(inflow, repayBps);
+ const a = min(repay, loan.owed - loan.repaid);
+ const repaid = loan.repaid + a;
+ const principalRepaid = repaid === loan.owed ? loan.principal : (repaid * loan.principal) / loan.owed;
+ const principalPart = principalRepaid - loan.principalRepaid;
+ const feePart = a - principalPart;
+ const toReserve = (feePart * BigInt(POLICY.protocolFeeShareBps)) / BPS;
+ const next = { ...loan, repaid, principalRepaid };
+ return {
+ loan: next,
+ step: {
+ inflow,
+ repayPart: repay,
+ applied: a,
+ principalPart,
+ feePart,
+ toReserve,
+ toLenders: a - toReserve,
+ toMerchant: inflow - a,
+ repaidAfter: repaid,
+ remainingAfter: loan.owed - repaid,
+ done: repaid === loan.owed,
+ },
+ };
+}
+
+/** A whole loan: draw, then each payment in order until it is repaid. */
+export function simulateLoan(principal: bigint, feeBps: number, repayBps: number, payments: bigint[]) {
+ const fee = (principal * BigInt(feeBps)) / BPS;
+ let loan: LoanBook = { principal, owed: principal + fee, repaid: 0n, principalRepaid: 0n };
+ const steps: RepayStep[] = [];
+ for (const p of payments) {
+ if (loan.repaid === loan.owed) {
+ steps.push({
+ inflow: p,
+ repayPart: 0n,
+ applied: 0n,
+ principalPart: 0n,
+ feePart: 0n,
+ toReserve: 0n,
+ toLenders: 0n,
+ toMerchant: p,
+ repaidAfter: loan.repaid,
+ remainingAfter: 0n,
+ done: true,
+ });
+ continue;
+ }
+ const r = applyPayment(loan, p, repayBps);
+ loan = r.loan;
+ steps.push(r.step);
+ }
+ return { fee, owed: principal + fee, steps, loan };
+}
+
+/** Unpaid principal × 50%: what a Delinquent loan sets aside (lowers the vault value meanwhile). */
+export const provisionFor = (principal: bigint, principalRepaid: bigint) =>
+ ((principal - principalRepaid) * BigInt(POLICY.delinquencyProvisionBps)) / BPS;
+
+/** Default: the reserve covers the unpaid principal first; lenders lose only the rest. */
+export function defaultLoss(unpaidPrincipal: bigint, reserve: bigint) {
+ const fromReserve = min(reserve, unpaidPrincipal);
+ return { fromReserve, toLenders: unpaidPrincipal - fromReserve };
+}
+
+// ---------- vault (contracts/credit lib.rs, vault.rs) ----------
+
+export const sharesForDeposit = (amount: bigint, totalShares: bigint, totalAssets: bigint) =>
+ (amount * (totalShares + VIRTUAL_OFFSET)) / (totalAssets + VIRTUAL_OFFSET);
+
+export const assetsForShares = (shares: bigint, totalShares: bigint, totalAssets: bigint) =>
+ (shares * (totalAssets + VIRTUAL_OFFSET)) / (totalShares + VIRTUAL_OFFSET);
+
+/** Share price × 1e6, as `get_vault.share_price_1e6` reports it. */
+export const sharePrice1e6 = (totalShares: bigint, totalAssets: bigint) =>
+ assetsForShares(1_000_000n, totalShares, totalAssets);
+
+// ---------- underwriting (the agent's own @runway/scoring) ----------
+
+const WEIGHTS = { stability: 35, history: 25, diversity: 15, trend: 15, corr: 10 };
+const clamp01 = (v: bigint) => (v < 0n ? 0n : v > SCALE ? SCALE : v);
+const frac = (v: bigint) => Number(v) / Number(SCALE);
+
+export interface OfferEstimate {
+ features: Features;
+ /** points from each part of the score (they add up to the score) */
+ parts: { stability: number; history: number; diversity: number; trend: number; corr: number };
+ score: number;
+ decision: Decision;
+}
+
+export const POLICY_FOR_SCORING = scoringPolicy({
+ anchoredCaps: POLICY.anchoredCaps,
+ unanchoredCaps: POLICY.unanchoredCaps,
+ minLoan: POLICY.minLoan,
+ maxExposurePerMerchant: POLICY.maxExposurePerMerchant,
+ repayBpsMin: POLICY.repayBpsMin,
+ repayBpsMax: POLICY.repayBpsMax,
+});
+
+/** Completed revenue windows (oldest first, micro-USDC) → the offer the underwriter would compute. */
+export function estimateOffer(
+ windows: bigint[],
+ o: { repaid?: number; anchored?: boolean; statementMedian?: bigint; defaulted?: boolean } = {},
+): OfferEstimate {
+ const inputs = {
+ buckets: windows,
+ repaid: o.repaid ?? 0,
+ defaulted: o.defaulted ?? false,
+ frozen: false,
+ anchored: o.anchored ?? false,
+ statementMedian: o.statementMedian,
+ };
+ const f = features(inputs);
+ const parts = {
+ stability: WEIGHTS.stability * frac(clamp01(SCALE - f.CV)),
+ history: (WEIGHTS.history * Math.min(inputs.repaid, 4)) / 4,
+ diversity: f.Ctop === null ? 0 : WEIGHTS.diversity * frac(clamp01(SCALE - f.Ctop)),
+ trend: WEIGHTS.trend * frac(clamp01(f.T - SCALE / 2n)),
+ corr: WEIGHTS.corr * frac(f.corr),
+ };
+ return {
+ features: f,
+ parts,
+ score: parts.stability + parts.history + parts.diversity + parts.trend + parts.corr,
+ decision: decide(f, inputs, POLICY_FOR_SCORING),
+ };
+}
+
+export const GRADE_FEE_BPS: Record
= { A: 400, B: 700, C: 1000 };
+export const MIN_ACTIVE_WINDOWS = POLICY_FOR_SCORING.minActiveBuckets;
+export const MIN_MEDIAN_REVENUE = POLICY_FOR_SCORING.minRevenue;
+
+// ---------- revenue windows ----------
+
+/** The 5-minute (testnet) window that `now` falls in, aligned to the clock like the contract's buckets. */
+export function windowClock(nowMs: number, bucketSec = PROFILE.bucketSec) {
+ const nowSec = Math.floor(nowMs / 1000);
+ const index = Math.floor(nowSec / bucketSec);
+ const endsAtSec = (index + 1) * bucketSec;
+ return { index, startsAtSec: index * bucketSec, endsAtSec, secondsLeft: endsAtSec - nowSec };
+}
+
+export const mmss = (sec: number) => {
+ const s = Math.max(0, Math.floor(sec));
+ return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+};
+
+/** "12.5" → micro-USDC, tolerant of commas; null when not a number. */
+export function microOf(text: string): bigint | null {
+ const m = /^(\d{1,12})(?:\.(\d{1,6}))?$/.exec(text.replace(/,/g, "").trim());
+ if (!m) return null;
+ return BigInt(m[1]!) * 1_000_000n + BigInt((m[2] ?? "").padEnd(6, "0"));
+}
diff --git a/apps/web/next.config.ts b/apps/web/next.config.ts
index de52714..4917e6c 100644
--- a/apps/web/next.config.ts
+++ b/apps/web/next.config.ts
@@ -3,7 +3,7 @@ import type { NextConfig } from "next";
const config: NextConfig = {
reactStrictMode: true,
// Workspace packages ship TypeScript sources with NodeNext-style ".js" import specifiers.
- transpilePackages: ["@runway/sdk", "@runway/config", "@runway/fx"],
+ transpilePackages: ["@runway/sdk", "@runway/config", "@runway/fx", "@runway/scoring"],
webpack: (cfg) => {
cfg.resolve.extensionAlias = { ".js": [".ts", ".tsx", ".js"] };
return cfg;
diff --git a/apps/web/package.json b/apps/web/package.json
index e9ec93b..a5866ec 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -21,6 +21,7 @@
"@noble/hashes": "2.4.0",
"@runway/config": "workspace:*",
"@runway/fx": "workspace:*",
+ "@runway/scoring": "workspace:*",
"@runway/sdk": "workspace:*",
"@tanstack/react-query": "5.107.1",
"near-api-js": "5.1.1",
diff --git a/apps/web/test/sim.test.ts b/apps/web/test/sim.test.ts
new file mode 100644
index 0000000..84f80c4
--- /dev/null
+++ b/apps/web/test/sim.test.ts
@@ -0,0 +1,131 @@
+// The previews must reproduce the contracts' integer maths and the underwriter's scoring exactly.
+// Expected values are worked out by hand from contracts/credit (router.rs, loans.rs, lib.rs),
+// contracts/settlement and @runway/scoring.
+import { describe, expect, it } from "vitest";
+import {
+ applyPayment,
+ assetsForShares,
+ defaultLoss,
+ drawTerms,
+ estimateOffer,
+ microOf,
+ periodRequirement,
+ provisionFor,
+ sharePrice1e6,
+ sharesForDeposit,
+ simulateLoan,
+ splitPayment,
+ windowClock,
+} from "../lib/sim";
+
+const u = (n: number) => BigInt(Math.round(n * 1_000_000));
+
+describe("payment split", () => {
+ it("takes floor(inflow × repay_bps / 10,000) while a loan is open", () => {
+ expect(splitPayment(u(400), 917)).toEqual({ repay: u(36.68), merchant: u(363.32) });
+ expect(splitPayment(u(99.5), 917)).toEqual({ repay: 9_124_150n, merchant: 90_375_850n });
+ });
+ it("takes nothing without a loan", () => {
+ expect(splitPayment(u(400), null)).toEqual({ repay: 0n, merchant: u(400) });
+ });
+});
+
+describe("loan accounting (apply_regular)", () => {
+ it("splits each repayment into principal and fee, 10% of the fee to the reserve", () => {
+ const loan = { principal: u(100), owed: u(110), repaid: 0n, principalRepaid: 0n };
+ const a = applyPayment(loan, u(400), 917);
+ expect(a.step).toMatchObject({
+ applied: u(36.68),
+ principalPart: 33_345_454n,
+ feePart: 3_334_546n,
+ toReserve: 333_454n,
+ toMerchant: u(363.32),
+ remainingAfter: u(73.32),
+ done: false,
+ });
+ const b = applyPayment(a.loan, u(99.5), 917);
+ expect(b.step).toMatchObject({ applied: 9_124_150n, principalPart: 8_294_682n, toReserve: 82_946n });
+ const c = applyPayment(b.loan, u(1200), 917);
+ expect(c.step).toMatchObject({
+ repayPart: u(110.04),
+ applied: 64_195_850n,
+ principalPart: 58_359_864n,
+ toReserve: 583_598n,
+ toMerchant: 1_135_804_150n,
+ done: true,
+ });
+ // The whole fee of 10: 9.000002 to lenders, 0.999998 to the reserve.
+ const reserve = a.step.toReserve + b.step.toReserve + c.step.toReserve;
+ expect(reserve).toBe(999_998n);
+ const toCash = a.step.toLenders + b.step.toLenders + c.step.toLenders;
+ expect(toCash - u(100)).toBe(9_000_002n);
+ });
+
+ it("never takes more than is owed; later payments go to the merchant in full", () => {
+ const r = simulateLoan(u(100), 1000, 917, [u(1200), u(400)]);
+ expect(r.steps[0]).toMatchObject({ applied: u(110), toMerchant: u(1090), done: true });
+ expect(r.steps[1]).toMatchObject({ applied: 0n, toMerchant: u(400) });
+ });
+
+ it("scales the repay share when drawing less than the limit", () => {
+ expect(drawTerms({ limit: u(100), feeBps: 1000, repayBps: 917 }, u(100))).toEqual({
+ repayBps: 917,
+ fee: u(10),
+ owed: u(110),
+ });
+ expect(drawTerms({ limit: u(100), feeBps: 1000, repayBps: 917 }, u(60)).repayBps).toBe(551);
+ expect(drawTerms({ limit: u(100), feeBps: 1000, repayBps: 600 }, u(50)).repayBps).toBe(500);
+ });
+
+ it("requires 10% of the owed amount per period, provisions 50% when delinquent", () => {
+ expect(periodRequirement(u(110))).toBe(u(11));
+ expect(periodRequirement(u(110), u(5))).toBe(u(5));
+ expect(provisionFor(u(100), 0n)).toBe(u(50));
+ expect(defaultLoss(u(100), u(30))).toEqual({ fromReserve: u(30), toLenders: u(70) });
+ });
+});
+
+describe("vault shares", () => {
+ it("mints and redeems at (assets + 1) / (shares + 1)", () => {
+ expect(sharesForDeposit(u(10_000), 0n, 0n)).toBe(u(10_000));
+ expect(sharePrice1e6(u(10_000), 10_009_000_002n)).toBe(1_000_899n);
+ expect(assetsForShares(u(1_000), u(10_000), 10_009_000_002n)).toBe(1_000_899_910n);
+ // The live testnet deposit of 200 USDC at price 1.000899 minted 199.820179 shares.
+ expect(sharesForDeposit(u(200), u(10_000), 10_009_000_002n)).toBe(199_820_179n);
+ });
+});
+
+describe("offer estimate (the underwriter's scoring)", () => {
+ it("three equal 400 USDC windows: grade C, limit 100, fee 10%, repay share 9.17%", () => {
+ const e = estimateOffer([u(400), u(400), u(400)]);
+ expect(e.score).toBeCloseTo(42.5, 5);
+ expect(e.decision).toMatchObject({
+ kind: "offer",
+ grade: "C",
+ limit: u(100),
+ feeBps: 1000,
+ repayBps: 917,
+ });
+ });
+ it("declines a merchant with fewer than 3 windows", () => {
+ expect(estimateOffer([u(400), u(400)]).decision).toMatchObject({ kind: "decline", reason: "too_new" });
+ });
+ it("declines unsteady revenue (an empty window after the payments)", () => {
+ const e = estimateOffer([u(400), u(400), u(400), 0n]);
+ expect(e.decision).toMatchObject({ kind: "decline", reason: "low_score" });
+ });
+ it("declines a median below 300 USDC", () => {
+ expect(estimateOffer([u(100), u(100), u(100)]).decision).toMatchObject({ reason: "low_revenue" });
+ });
+});
+
+describe("helpers", () => {
+ it("aligns windows to the clock", () => {
+ const w = windowClock(Date.UTC(2026, 10, 13, 10, 7, 30), 300);
+ expect(w.secondsLeft).toBe(150);
+ });
+ it("parses amounts", () => {
+ expect(microOf("1,200.5")).toBe(u(1200.5));
+ expect(microOf("abc")).toBeNull();
+ });
+});
diff --git a/docs/JUDGES.md b/docs/JUDGES.md
index 1d3daaa..15cbcba 100644
--- a/docs/JUDGES.md
+++ b/docs/JUDGES.md
@@ -12,6 +12,11 @@ browser (it loads through a service worker), and Pinata's free public gateway re
The backend sleeps when idle (free hosting). If a page says the agent is unavailable, wait a minute and
reload. [docs/TESTING.md](TESTING.md) is the full test plan, with the expected result of every step.
+The site explains itself: every page says what it does and previews the result before you confirm. It also
+has **Docs** (`/docs`: guides for merchants, lenders and customers, the rupee flows, worked examples with
+every balance, a glossary) and a **Simulator** (`/simulator`: the offer, repayment, lender and rupee maths,
+using the same code as the contracts and the underwriter).
+
## 1. A wallet (2 minutes)
Install Meteor Wallet (or use MyNearWallet), switch it to **testnet**, create an account, and get free
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a145e60..87972e4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -75,6 +75,9 @@ importers:
'@runway/fx':
specifier: workspace:*
version: link:../../packages/fx
+ '@runway/scoring':
+ specifier: workspace:*
+ version: link:../../packages/scoring
'@runway/sdk':
specifier: workspace:*
version: link:../../packages/sdk