@floatonnear/mcp 0.0.0-stage → 0.1.1

package/dist/amounts.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Human decimal strings <-> integer base units.
+ *
+ * Everything here goes through BigInt and string manipulation, never `Number`.
+ * A 6-decimal token amount above ~9 billion already exceeds
+ * Number.MAX_SAFE_INTEGER in base units, and the failure mode of a float path
+ * is silent: the low digits become zeroes, the contract receives a different
+ * amount than the human typed, and every on-chain cap check passes because the
+ * contract never saw the original string.
+ */
+/**
+ * Parse a human amount into base units.
+ *
+ * Throws rather than truncating when the input carries more fractional digits
+ * than the token supports. Truncating would send an amount the human did not
+ * ask for, and nothing downstream could detect it.
+ */
+export declare function toBaseUnits(amount: string, decimals: number): bigint;
+/** Render base units as a canonical human string: no trailing point, no trailing zeroes. */
+export declare function fromBaseUnits(units: bigint, decimals: number): string;

package/dist/amounts.js

@@ -0,0 +1,55 @@
+/**
+ * Human decimal strings <-> integer base units.
+ *
+ * Everything here goes through BigInt and string manipulation, never `Number`.
+ * A 6-decimal token amount above ~9 billion already exceeds
+ * Number.MAX_SAFE_INTEGER in base units, and the failure mode of a float path
+ * is silent: the low digits become zeroes, the contract receives a different
+ * amount than the human typed, and every on-chain cap check passes because the
+ * contract never saw the original string.
+ */
+/** `123` or `123.456`. No sign, no exponent, no separators, no bare point. */
+const DECIMAL = /^\d+(\.\d+)?$/;
+const MAX_DECIMALS = 38;
+function assertDecimals(decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > MAX_DECIMALS) {
+        throw new Error(`decimals must be an integer in 0..=${MAX_DECIMALS}, got ${decimals}`);
+    }
+}
+/**
+ * Parse a human amount into base units.
+ *
+ * Throws rather than truncating when the input carries more fractional digits
+ * than the token supports. Truncating would send an amount the human did not
+ * ask for, and nothing downstream could detect it.
+ */
+export function toBaseUnits(amount, decimals) {
+    assertDecimals(decimals);
+    if (typeof amount !== "string") {
+        throw new Error("amount must be a string, so no float precision is lost before parsing");
+    }
+    if (!DECIMAL.test(amount)) {
+        throw new Error(`invalid amount ${JSON.stringify(amount)}: expected digits with an optional ` +
+            `single decimal point, e.g. "12" or "12.50" (no sign, exponent, or separators)`);
+    }
+    const [whole = "", frac = ""] = amount.split(".");
+    if (frac.length > decimals) {
+        throw new Error(`too many decimal places in ${JSON.stringify(amount)}: the token has ${decimals}, ` +
+            `the amount has ${frac.length}. Refusing to truncate — round it yourself and resend.`);
+    }
+    return BigInt(whole + frac.padEnd(decimals, "0"));
+}
+/** Render base units as a canonical human string: no trailing point, no trailing zeroes. */
+export function fromBaseUnits(units, decimals) {
+    assertDecimals(decimals);
+    if (units < 0n)
+        throw new Error("base units must not be negative");
+    if (decimals === 0)
+        return units.toString();
+    const scale = 10n ** BigInt(decimals);
+    const whole = units / scale;
+    // padStart matters: 1n at 6 decimals is 0.000001, and an unpadded remainder
+    // would render it as 0.1.
+    const frac = (units % scale).toString().padStart(decimals, "0").replace(/0+$/, "");
+    return frac ? `${whole}.${frac}` : whole.toString();
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./amounts.js";
+export * from "./payloads.js";
+export * from "./rpc.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./amounts.js";
+export * from "./payloads.js";
+export * from "./rpc.js";

package/dist/payloads.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Owner-method payload builders.
+ *
+ * Owner methods are NEVER signed by this server. It builds an unsigned payload
+ * and hands it back for the human to approve in their own wallet, so the MCP
+ * server is not in the trust path for anything that changes policy. The only
+ * thing it signs is `request_payment`, with an agent key that is
+ * cryptographically restricted to exactly that method on exactly this vault.
+ *
+ * Validation is duplicated here on purpose. The contract rejects all of these
+ * too, but failing locally costs no gas and no wallet round-trip, and the
+ * message can explain *why* a bound exists.
+ */
+export declare const ONE_YOCTO = "1";
+/** Mirrors `AGENT_ACCOUNT_STORAGE` in the contract: 0.05 NEAR. */
+export declare const AGENT_ACCOUNT_STORAGE_YOCTO: string;
+/** Mirrors `MIN_AGENT_KEY_ALLOWANCE` in the contract: 0.5 NEAR. */
+export declare const MIN_AGENT_KEY_ALLOWANCE_YOCTO: string;
+/**
+ * Gas attached to a payment, for every route.
+ *
+ * Clears the contract's only floor — MIN_GAS_FOR_DISPATCH, 50 Tgas — with ~10x
+ * headroom over the ~9.3 Tgas a MAX_DEPTH payment actually burns. That floor is
+ * mirrored in shared/contract-constants.json and asserted on both sides, so a
+ * change to the contract's requirement cannot silently leave this too low.
+ */
+export declare const DEFAULT_GAS_TGAS = 100;
+export declare const MAX_TOKENS = 4;
+export declare const MAX_RECIPIENTS = 32;
+export declare const MAX_LABEL_LEN = 48;
+export declare const MAX_SUB_LABEL_LEN = 32;
+export declare const MAX_COOLDOWN_SEC: number;
+export declare const MAX_PURGE_LIMIT = 100;
+export interface HumanTokenLimit {
+    token: string;
+    dailyCap: string;
+    perTxCap: string;
+    decimals: number;
+}
+export interface OwnerPayload {
+    receiverId: string;
+    methodName: string;
+    args: Record<string, unknown>;
+    gasTgas: number;
+    depositYocto: string;
+    /** What the human is being asked to approve, in human units. */
+    summary: string;
+    /** Non-empty only when the action is destructive or hard to undo. */
+    warnings: string[];
+}
+export declare function planAddNode(vault: string, parent: number | null, label: string, limits: HumanTokenLimit[], cooldownSec: number, recipients: string[] | null): OwnerPayload;
+export declare function planSetNodeCaps(vault: string, nodeId: number, limits: HumanTokenLimit[]): OwnerPayload;
+export declare function planBindAgent(vault: string, nodeId: number, accountId: string): OwnerPayload;
+export declare function planCreateAgentAccount(vault: string, nodeId: number, subLabel: string, publicKey: string, keyAllowanceNear: string): OwnerPayload;
+export declare function planSetRecipients(vault: string, nodeId: number, recipients: string[] | null): OwnerPayload;
+export declare function planSetCooldown(vault: string, nodeId: number, cooldownSec: number): OwnerPayload;
+export declare function planFreezeNode(vault: string, nodeId: number, frozen: boolean): OwnerPayload;
+export declare function planSetPaused(vault: string, paused: boolean): OwnerPayload;
+export declare function planSetStrictAllocation(vault: string, strict: boolean): OwnerPayload;
+export declare function planPurgeSettled(vault: string, beforeDay: number, limit: number): OwnerPayload;
+/** Registry used by the MCP server, and asserted against the contract's method list. */
+export declare const OWNER_PLANNERS: {
+    readonly add_node: {
+        readonly methodName: "add_node";
+        readonly fn: typeof planAddNode;
+    };
+    readonly set_node_caps: {
+        readonly methodName: "set_node_caps";
+        readonly fn: typeof planSetNodeCaps;
+    };
+    readonly bind_agent: {
+        readonly methodName: "bind_agent";
+        readonly fn: typeof planBindAgent;
+    };
+    readonly create_agent_account: {
+        readonly methodName: "create_agent_account";
+        readonly fn: typeof planCreateAgentAccount;
+    };
+    readonly set_recipients: {
+        readonly methodName: "set_recipients";
+        readonly fn: typeof planSetRecipients;
+    };
+    readonly set_cooldown: {
+        readonly methodName: "set_cooldown";
+        readonly fn: typeof planSetCooldown;
+    };
+    readonly freeze_node: {
+        readonly methodName: "freeze_node";
+        readonly fn: typeof planFreezeNode;
+    };
+    readonly set_paused: {
+        readonly methodName: "set_paused";
+        readonly fn: typeof planSetPaused;
+    };
+    readonly set_strict_allocation: {
+        readonly methodName: "set_strict_allocation";
+        readonly fn: typeof planSetStrictAllocation;
+    };
+    readonly purge_settled: {
+        readonly methodName: "purge_settled";
+        readonly fn: typeof planPurgeSettled;
+    };
+};
+/** A ready-to-run command, so approving does not require trusting this server. */
+export declare function toCliCommand(p: OwnerPayload, network?: string): string;

package/dist/payloads.js

@@ -0,0 +1,292 @@
+/**
+ * Owner-method payload builders.
+ *
+ * Owner methods are NEVER signed by this server. It builds an unsigned payload
+ * and hands it back for the human to approve in their own wallet, so the MCP
+ * server is not in the trust path for anything that changes policy. The only
+ * thing it signs is `request_payment`, with an agent key that is
+ * cryptographically restricted to exactly that method on exactly this vault.
+ *
+ * Validation is duplicated here on purpose. The contract rejects all of these
+ * too, but failing locally costs no gas and no wallet round-trip, and the
+ * message can explain *why* a bound exists.
+ */
+import { toBaseUnits, fromBaseUnits } from "./amounts.js";
+export const ONE_YOCTO = "1";
+/** Mirrors `AGENT_ACCOUNT_STORAGE` in the contract: 0.05 NEAR. */
+export const AGENT_ACCOUNT_STORAGE_YOCTO = (5n * 10n ** 22n).toString();
+/** Mirrors `MIN_AGENT_KEY_ALLOWANCE` in the contract: 0.5 NEAR. */
+export const MIN_AGENT_KEY_ALLOWANCE_YOCTO = (5n * 10n ** 23n).toString();
+/**
+ * Gas attached to a payment, for every route.
+ *
+ * Clears the contract's only floor — MIN_GAS_FOR_DISPATCH, 50 Tgas — with ~10x
+ * headroom over the ~9.3 Tgas a MAX_DEPTH payment actually burns. That floor is
+ * mirrored in shared/contract-constants.json and asserted on both sides, so a
+ * change to the contract's requirement cannot silently leave this too low.
+ */
+export const DEFAULT_GAS_TGAS = 100;
+// Mirrors of the contract's bounds. Duplicated so a bad call fails here rather
+// than costing gas — and pinned against shared/contract-constants.json by
+// constants.test.ts, because a silent drift would turn this validation into a
+// lie that the chain then rejects.
+export const MAX_TOKENS = 4;
+export const MAX_RECIPIENTS = 32;
+export const MAX_LABEL_LEN = 48;
+export const MAX_SUB_LABEL_LEN = 32;
+export const MAX_COOLDOWN_SEC = 7 * 24 * 60 * 60;
+export const MAX_PURGE_LIMIT = 100;
+const NEAR_DECIMALS = 24;
+function limitsToArgs(limits) {
+    if (limits.length === 0)
+        throw new Error("at least one token limit is required");
+    if (limits.length > MAX_TOKENS) {
+        throw new Error(`at most ${MAX_TOKENS} token limits per node (MAX_TOKENS)`);
+    }
+    const seen = new Set();
+    for (const l of limits) {
+        if (seen.has(l.token))
+            throw new Error(`duplicate token ${l.token}`);
+        seen.add(l.token);
+    }
+    return limits.map((l) => {
+        const daily = toBaseUnits(l.dailyCap, l.decimals);
+        const perTx = toBaseUnits(l.perTxCap, l.decimals);
+        if (daily === 0n || perTx === 0n) {
+            throw new Error(`caps must be positive (token ${l.token})`);
+        }
+        if (perTx > daily) {
+            throw new Error(`per-tx cap ${l.perTxCap} exceeds the daily cap ${l.dailyCap} for ${l.token}; ` +
+                `the contract requires per_tx_cap <= daily_cap`);
+        }
+        // snake_case and U128-as-string: the contract's ABI, and a JSON number
+        // would lose precision above 2^53.
+        return { token: l.token, daily_cap: daily.toString(), per_tx_cap: perTx.toString() };
+    });
+}
+/** Human units in the summary, always. Base units here are how a 1000x slip gets approved. */
+function describeLimits(limits) {
+    return limits
+        .map((l) => `${l.token}: ${l.dailyCap}/day, max ${l.perTxCap}/payment`)
+        .join("; ");
+}
+const SUB_LABEL = new RegExp(`^[a-z0-9_-]{1,${MAX_SUB_LABEL_LEN}}$`);
+function assertRecipients(recipients) {
+    if (recipients === null)
+        return;
+    if (recipients.length === 0) {
+        throw new Error("recipients must be a non-empty list, or null to inherit the parent's");
+    }
+    if (recipients.length > MAX_RECIPIENTS) {
+        throw new Error(`at most ${MAX_RECIPIENTS} recipients per node (MAX_RECIPIENTS)`);
+    }
+    if (new Set(recipients).size !== recipients.length) {
+        throw new Error("duplicate recipient");
+    }
+}
+function assertCooldown(cooldownSec) {
+    if (!Number.isInteger(cooldownSec) || cooldownSec < 0) {
+        throw new Error("cooldownSec must be a non-negative integer");
+    }
+    if (cooldownSec > MAX_COOLDOWN_SEC) {
+        throw new Error(`cooldown must be at most ${MAX_COOLDOWN_SEC}s (MAX_COOLDOWN_SEC)`);
+    }
+}
+export function planAddNode(vault, parent, label, limits, cooldownSec, recipients) {
+    if (!label || label.length > MAX_LABEL_LEN) {
+        throw new Error(`label must be 1..=${MAX_LABEL_LEN} characters (MAX_LABEL_LEN)`);
+    }
+    assertCooldown(cooldownSec);
+    assertRecipients(recipients);
+    return {
+        receiverId: vault,
+        methodName: "add_node",
+        args: {
+            parent,
+            label,
+            limits: limitsToArgs(limits),
+            cooldown_sec: cooldownSec,
+            recipients,
+        },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: `Create budget node "${label}" ${parent === null ? "as the ROOT" : `under node ${parent}`}` +
+            ` with ${describeLimits(limits)}` +
+            (cooldownSec ? `, ${cooldownSec}s cooldown between payments` : "") +
+            (recipients ? `, paying only: ${recipients.join(", ")}` : `, inheriting the payee allowlist`),
+        warnings: [],
+    };
+}
+export function planSetNodeCaps(vault, nodeId, limits) {
+    return {
+        receiverId: vault,
+        methodName: "set_node_caps",
+        args: { node_id: nodeId, limits: limitsToArgs(limits) },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: `Set node ${nodeId} caps to ${describeLimits(limits)}`,
+        warnings: [],
+    };
+}
+export function planBindAgent(vault, nodeId, accountId) {
+    return {
+        receiverId: vault,
+        methodName: "bind_agent",
+        args: { node_id: nodeId, account_id: accountId },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: `Let ${accountId} spend from node ${nodeId}`,
+        warnings: [
+            `${accountId} is an EXISTING account whose keys you do not control. ` +
+                `Prefer create_agent_account, which issues a key restricted to request_payment.`,
+        ],
+    };
+}
+export function planCreateAgentAccount(vault, nodeId, subLabel, publicKey, keyAllowanceNear) {
+    if (!SUB_LABEL.test(subLabel)) {
+        throw new Error(`invalid sub_label ${JSON.stringify(subLabel)}: 1..=32 chars of [a-z0-9_-]. ` +
+            `A dot in particular is refused — the account id is DERIVED as ` +
+            `<label>.${vault} so the new account cannot be aimed outside this vault's subtree.`);
+    }
+    if (!publicKey.startsWith("ed25519:") && !publicKey.startsWith("secp256k1:")) {
+        throw new Error("publicKey must be in NEAR form, e.g. ed25519:...");
+    }
+    const allowance = toBaseUnits(keyAllowanceNear, NEAR_DECIMALS);
+    if (allowance < BigInt(MIN_AGENT_KEY_ALLOWANCE_YOCTO)) {
+        throw new Error(`key allowance ${keyAllowanceNear} NEAR is below the usable floor of ` +
+            `${fromBaseUnits(BigInt(MIN_AGENT_KEY_ALLOWANCE_YOCTO), NEAR_DECIMALS)} NEAR. ` +
+            `NEAR reserves the FULL prepaid gas of each call against the key up front and ` +
+            `refunds the remainder, so an allowance sized to expected burn produces a key ` +
+            `that cannot transact at all.`);
+    }
+    const deposit = allowance + BigInt(AGENT_ACCOUNT_STORAGE_YOCTO);
+    const derived = `${subLabel}.${vault}`;
+    return {
+        receiverId: vault,
+        methodName: "create_agent_account",
+        args: {
+            node_id: nodeId,
+            sub_label: subLabel,
+            public_key: publicKey,
+            key_allowance: allowance.toString(),
+        },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: deposit.toString(),
+        summary: `Create agent account ${derived}, bind it to node ${nodeId}, and give it ONE key ` +
+            `that can call only request_payment on ${vault} — it cannot call other methods, ` +
+            `cannot call other contracts, and cannot attach a deposit. ` +
+            `Funding ${fromBaseUnits(deposit, NEAR_DECIMALS)} NEAR ` +
+            `(${keyAllowanceNear} gas allowance + ` +
+            `${fromBaseUnits(BigInt(AGENT_ACCOUNT_STORAGE_YOCTO), NEAR_DECIMALS)} account storage).`,
+        warnings: [],
+    };
+}
+export function planSetRecipients(vault, nodeId, recipients) {
+    assertRecipients(recipients);
+    return {
+        receiverId: vault,
+        methodName: "set_recipients",
+        args: { node_id: nodeId, recipients },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: recipients
+            ? `Node ${nodeId} may pay only: ${recipients.join(", ")}`
+            : `Node ${nodeId} inherits its payee allowlist from the nearest ancestor that sets one`,
+        warnings: recipients
+            ? [
+                `This REPLACES the inherited allowlist for node ${nodeId} and its descendants; ` +
+                    `it does not add to it. Payees it currently inherits will stop being payable.`,
+            ]
+            : [],
+    };
+}
+export function planSetCooldown(vault, nodeId, cooldownSec) {
+    assertCooldown(cooldownSec);
+    return {
+        receiverId: vault,
+        methodName: "set_cooldown",
+        args: { node_id: nodeId, cooldown_sec: cooldownSec },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: cooldownSec
+            ? `Node ${nodeId} must wait ${cooldownSec}s between payments`
+            : `Remove the cooldown on node ${nodeId}`,
+        warnings: [],
+    };
+}
+export function planFreezeNode(vault, nodeId, frozen) {
+    return {
+        receiverId: vault,
+        methodName: "freeze_node",
+        args: { node_id: nodeId, frozen },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: frozen ? `Freeze node ${nodeId}` : `Unfreeze node ${nodeId}`,
+        warnings: frozen
+            ? [`This blocks payments from node ${nodeId} AND every node in its subtree.`]
+            : [],
+    };
+}
+export function planSetPaused(vault, paused) {
+    return {
+        receiverId: vault,
+        methodName: "set_paused",
+        args: { paused },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: paused ? `PAUSE the whole vault` : `Resume the vault`,
+        warnings: paused ? [`This will halt every agent payment until you resume it.`] : [],
+    };
+}
+export function planSetStrictAllocation(vault, strict) {
+    return {
+        receiverId: vault,
+        methodName: "set_strict_allocation",
+        args: { strict },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: strict
+            ? `Require the sum of child caps to fit inside each parent cap (no overcommit)`
+            : `Allow overcommit: child caps may sum above the parent, and children then ` +
+                `contend first-come-first-served for the shared parent pool`,
+        warnings: [],
+    };
+}
+export function planPurgeSettled(vault, beforeDay, limit) {
+    if (!Number.isInteger(limit) || limit < 0 || limit > MAX_PURGE_LIMIT) {
+        throw new Error(`limit must be an integer in 0..=${MAX_PURGE_LIMIT} (MAX_PURGE_LIMIT)`);
+    }
+    return {
+        receiverId: vault,
+        methodName: "purge_settled",
+        args: { before_day: beforeDay, limit },
+        gasTgas: DEFAULT_GAS_TGAS,
+        depositYocto: ONE_YOCTO,
+        summary: `Delete up to ${limit} settled or failed payment records reserved before UTC day ${beforeDay}`,
+        warnings: [
+            `Irreversible: this deletes payment HISTORY. Spend totals are NOT refunded, ` +
+                `but a deleted request id becomes reusable, so a client retrying an id older ` +
+                `than day ${beforeDay} would be paid a second time.`,
+        ],
+    };
+}
+/** Registry used by the MCP server, and asserted against the contract's method list. */
+export const OWNER_PLANNERS = {
+    add_node: { methodName: "add_node", fn: planAddNode },
+    set_node_caps: { methodName: "set_node_caps", fn: planSetNodeCaps },
+    bind_agent: { methodName: "bind_agent", fn: planBindAgent },
+    create_agent_account: { methodName: "create_agent_account", fn: planCreateAgentAccount },
+    set_recipients: { methodName: "set_recipients", fn: planSetRecipients },
+    set_cooldown: { methodName: "set_cooldown", fn: planSetCooldown },
+    freeze_node: { methodName: "freeze_node", fn: planFreezeNode },
+    set_paused: { methodName: "set_paused", fn: planSetPaused },
+    set_strict_allocation: { methodName: "set_strict_allocation", fn: planSetStrictAllocation },
+    purge_settled: { methodName: "purge_settled", fn: planPurgeSettled },
+};
+/** A ready-to-run command, so approving does not require trusting this server. */
+export function toCliCommand(p, network = "testnet") {
+    return (`near contract call-function as-transaction ${p.receiverId} ${p.methodName} ` +
+        `json-args '${JSON.stringify(p.args)}' prepaid-gas '${p.gasTgas}.0 Tgas' ` +
+        `attached-deposit '${p.depositYocto} yoctoNEAR' ` +
+        `sign-as <YOUR-OWNER-ACCOUNT> network-config ${network} sign-with-keychain send`);
+}

package/dist/quote.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Getting a cross-chain quote, and signing the binding the vault verifies.
+ *
+ * A cross-chain payment is an ordinary NEP-141 transfer on NEAR to a ONE-TIME
+ * deposit address; a NEAR Intents solver delivers the destination asset and
+ * prices the far chain's gas into the quote. No MPC signature, no derived
+ * address, no ETH to keep topped up.
+ *
+ * The catch is that the deposit address is unpredictable and single-use, so it
+ * can never be on the vault's payee allowlist. The vault checks the allowlist
+ * against the final payee and then sends the money somewhere it cannot connect
+ * back to that payee. If an agent could choose that address, the allowlist
+ * would be decorative — quote a swap paying yourself and the vault funds it
+ * with every other check passing.
+ *
+ * So a key the vault owner registered signs the binding between payee and
+ * deposit address, and the contract refuses any Intents payment without it.
+ * This module is the holder of that key. It is a TRUSTED PRODUCER: whoever
+ * runs it can redirect any Intents payment the budget allows, which is why it
+ * belongs on the operator's machine and not on the ones agents run on.
+ */
+export declare const ONE_CLICK_URL: string;
+/** Mainnet asset ids, from GET /v0/tokens. Intents has no testnet. */
+export declare const ASSETS: {
+    readonly usdcNear: "nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1";
+    readonly usdcBase: "nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near";
+};
+export interface QuoteBinding {
+    vault: string;
+    requestId: string;
+    token: string;
+    amount: bigint;
+    payee: string;
+    depositAddress: string;
+    deadlineNs: bigint;
+}
+/** Field order is the struct's declaration order; borsh has no field names. */
+export declare function encodeBinding(b: QuoteBinding): Uint8Array;
+export declare function signBinding(b: QuoteBinding, secretKey: Uint8Array): Uint8Array;
+export declare function publicKeyOf(secretKey: Uint8Array): Uint8Array;
+export declare const toBase64: (b: Uint8Array) => string;
+export interface QuoteResult {
+    /** Where the vault must send the NEAR-side tokens. */
+    depositAddress: string;
+    /** What leaves the vault, in base units. */
+    amountIn: bigint;
+    /** What the payee receives on the destination chain, in base units. */
+    amountOut: bigint;
+    deadlineNs: bigint;
+    timeEstimateSec: number;
+}
+/**
+ * Ask 1Click what it costs to deliver `amountOut` to `payee` on the
+ * destination chain.
+ *
+ * EXACT_OUTPUT, deliberately. A payment is a promise about what the PAYEE
+ * receives; EXACT_INPUT would deliver "about a dollar" and leave the agent
+ * unable to settle an invoice. The vault is then charged `amountIn`, which is
+ * what actually leaves it — so the budget governs real outflow, not the
+ * nominal figure.
+ */
+export declare function getQuote(opts: {
+    originAsset?: string;
+    destinationAsset?: string;
+    amountOut: bigint;
+    payee: string;
+    refundTo: string;
+    deadline: Date;
+    slippageBps?: number;
+    jwt?: string;
+    dry?: boolean;
+}): Promise<QuoteResult>;
+/** The `route` argument for a cross-chain payment. */
+export declare function intentsRoute(depositAddress: string, deadlineNs: bigint, signature: Uint8Array): {
+    intents: {
+        deposit_address: string;
+        quote_deadline_ns: string;
+        signature: string;
+    };
+};