@fidesbuild/mcp-server 0.6.0 → 0.8.0

package/dist/server.js

@@ -20,6 +20,7 @@ import { Fides, FidesBuilder, Policy, Receipts, accountOf, createFidesClient, fr
 import { createX402, decodePaymentRequired, exactEip3009 } from '@fidesbuild/x402';
 import { netObligations, settle, netRoots, PUBLISH_SELECTOR, NetError } from '@fidesbuild/net';
 import { createSubClient, SubFidesKit, SubAgent, SubFidesError, subDeployments } from '@fidesbuild/sub';
+import { quoteUniswap, checkMandate, swapActions, verifySwap, describeRoute, mandateOf, uniswap, NATIVE, SwapError } from '@fidesbuild/swap';
 export function configFromEnv(env = process.env) {
     const home = env.FIDES_HOME ?? path.join(os.homedir(), '.fides');
     return {
@@ -175,7 +176,7 @@ export function createFidesMcpServer(cfg) {
             ...(outside > 0n ? { warning: `${amount(outside)} sits on the agent key ${agent.address} outside the FIDES: it was sent to the agent address directly instead of to the FIDES Account. FIDES never spends it. To get it back, the owner can import the agent key from ${path.join(cfg.home, 'agent.json')} into a wallet on this computer, add a little ETH for gas, and send it to themselves. Funds for the agent always go to the FIDES Account address.` } : {}),
         };
     }
-    const server = new McpServer({ name: 'fides', version: '0.6.0' }, {
+    const server = new McpServer({ name: 'fides', version: '0.8.0' }, {
         instructions: 'FIDES lets you act with the owner\'s funds only inside limits the owner signed (a FIDES): a budget, allowed contracts and functions, paid services, and an expiry. ' +
             'Funds move from the owner\'s FIDES Account, never from the owner\'s wallet. If no FIDES is set up yet, call fides_setup and give the user the link. Always call fides_plan first and show the user what is inside the FIDES, what is blocked and why, ' +
             'and ask before calling fides_execute. Actions outside the FIDES are blocked before anything is sent. Amounts are in whole token units, like "1.5". ' +
@@ -199,6 +200,7 @@ export function createFidesMcpServer(cfg) {
                 'Send USDG from the FIDES Account, to one address or many, inside the budget. Several transfers go out as one transaction.',
                 'Call contracts the FIDES allows, with the functions it allows.',
                 'Buy from paid APIs that charge per request over x402, paying from the FIDES budget, each capped per service.',
+                'Swap on Uniswap inside a trading mandate the owner signed: tokens it may buy, worst price, most per swap; best route across Robinhood Chain including v4 hook pools, approval and swap as one transaction (fides_swap). The FIDES must allow swaps: fides_setup with swap.',
                 'Hand another agent a slice of the FIDES with its own budget and expiry (fides_delegate, SUB-FIDES); or, as the child, act inside a slice handed to you (fides_sub_plan). The FIDES must allow delegation: fides_setup with delegate: true.',
                 'Settle with FIDES NET: give the payments owed to and from the FIDES Account, and they are netted to final positions and settled in one transaction, with the round published onchain (fides_net). The FIDES must allow NET: fides_setup with net: true.',
                 'Show the budget spent and left, what is allowed, the expiry, and every transaction executed, with explorer links.',
@@ -238,23 +240,64 @@ export function createFidesMcpServer(cfg) {
     });
     server.registerTool('fides_setup', {
         title: 'Set up FIDES',
-        description: 'Use when the user wants to set up FIDES, connect their wallet or sign a new FIDES. Returns this computer\'s agent address and a link to the FIDES app with it filled in, where the user sets the limits and signs. The signed FIDES is then picked up automatically. To let the user buy from paid APIs (fides_pay_request), pass the services with a spending cap each. Paid APIs known to work use the ids "fides-demo", "spraay" and "madeonsol" (fides_help has their URLs and prices); for any other x402 API, the id is any name the user chooses.',
+        description: 'Use when the user wants to set up FIDES, connect their wallet or sign a new FIDES. Returns this computer\'s agent address and a link to the FIDES app with it filled in, where the user sets the limits and signs. The signed FIDES is then picked up automatically. To let the user buy from paid APIs (fides_pay_request), pass the services with a spending cap each. Paid APIs known to work use the ids "fides-demo", "spraay" and "madeonsol" (fides_help has their URLs and prices); for any other paid API, call fides_check_api with its URL and use the service_id it returns. To let the agent call any contract on the chain, pass contracts with the functions it may call by name (fides_inspect_contract lists them and flags the risky ones).',
         inputSchema: {
-            services: z.array(z.object({ id: z.string().describe('A name for the paid service, chosen by the user, e.g. "fides-demo" or "spraay"'), max: z.string().describe('Most the agent may spend on it, in USDG, e.g. "0.1"') })).optional(),
+            services: z.array(z.object({ id: z.string().describe('The service id: "fides-demo", "spraay", "madeonsol", or for any other paid API the service_id fides_check_api returns (its host)'), max: z.string().describe('Most the agent may spend on it, in USDG, e.g. "0.1"') })).optional(),
+            contracts: z.array(z.object({
+                address: z.string().describe('The contract address'),
+                functions: z.array(z.string()).min(1).describe('Function names (e.g. "supply", "withdraw") or 4-byte selectors. fides_inspect_contract lists them'),
+            })).optional().describe('Any contracts on the chain the agent may call, and exactly which functions; everything else on them stays blocked'),
             net: z.boolean().optional().describe('true to allow FIDES NET: lets the FIDES publish netting roots on FidesNetRoots, which fides_net needs'),
             delegate: z.boolean().optional().describe('true to let this agent hand slices of the FIDES to other agents (SUB-FIDES), which fides_delegate needs'),
+            swap: z.object({
+                buy: z.array(z.string()).min(1).describe('Tokens the agent may buy: "ETH", "WETH" or addresses'),
+                max_slippage_percent: z.number().positive().max(50).optional().describe('The worst price it may accept against the quote, in percent. Default 1'),
+                max_per_swap: z.string().optional().describe('The most one swap may spend, in the budget token. Default "1"'),
+            }).optional().describe('Let the agent swap on Uniswap inside a trading mandate the owner signs; fides_swap needs it'),
         },
-    }, async ({ services, net, delegate }) => ok({
-        agent_address: agent.address,
-        link: setupLink + (services ?? []).map((x) => `&service=${encodeURIComponent(x.id)}:${encodeURIComponent(x.max)}`).join('') + (net && netRoots[cfg.chainId] ? `&target=${netRoots[cfg.chainId]}:${PUBLISH_SELECTOR}` : '') + (delegate ? '&delegate=1' : ''),
-        services: services?.length ? services.map((x) => `${x.id}: up to ${x.max} USDG`) : undefined,
-        steps: [
-            'Open the link. It opens the FIDES app with this agent already filled in.',
-            'Connect your wallet. Set the budget, the contracts allowed and the expiry. Start small.',
-            'Sign (free), click Create FIDES Account (a little gas), and send the budget to the FIDES Account address shown.',
-            'Come back and ask me for what you want. I pick up the signed FIDES by myself.',
-        ],
-    }));
+    }, async ({ services, net, delegate, swap, contracts }) => {
+        let targets = '';
+        const added = [];
+        for (const c of contracts ?? []) {
+            if (!isAddress(c.address))
+                return fail(`"${c.address}" is not a contract address.`);
+            const sels = c.functions.filter((x) => /^0x[0-9a-fA-F]{8}$/.test(x)).map((x) => x.toLowerCase());
+            const names = c.functions.filter((x) => !/^0x[0-9a-fA-F]{8}$/.test(x));
+            let label = c.address;
+            if (names.length) {
+                let info;
+                try {
+                    info = await inspect(c.address);
+                }
+                catch (err) {
+                    return fail(`Could not read ${c.address}: ${err?.message ?? err}`);
+                }
+                if (!info.verified)
+                    return fail(`${c.address} is not verified, so its functions cannot be found by name. Give their 4-byte selectors instead.`);
+                label = info.name ?? c.address;
+                for (const n of names) {
+                    const fn = info.functions.find((x) => x.name === n || x.signature.replace(/ \w+(?=[,)])/g, '') === n);
+                    if (!fn)
+                        return fail(`${label} has no function "${n}" that changes anything. It has: ${info.functions.map((x) => x.name).join(', ')}.`);
+                    sels.push(fn.selector);
+                }
+            }
+            targets += `&target=${getAddress(c.address)}:${[...new Set(sels)].join(',')}`;
+            added.push(`${label}: ${c.functions.join(', ')}`);
+        }
+        return ok({
+            agent_address: agent.address,
+            link: setupLink + targets + (services ?? []).map((x) => `&service=${encodeURIComponent(x.id)}:${encodeURIComponent(x.max)}`).join('') + (net && netRoots[cfg.chainId] ? `&target=${netRoots[cfg.chainId]}:${PUBLISH_SELECTOR}` : '') + (delegate ? '&delegate=1' : '') + (swap ? `&swap=${encodeURIComponent(swap.buy.map((t) => (/^weth$/i.test(t) ? uniswap[cfg.chainId]?.weth ?? t : t)).join('|'))}:${Math.round((swap.max_slippage_percent ?? 1) * 100)}:${encodeURIComponent(swap.max_per_swap ?? '1')}` : ''),
+            services: services?.length ? services.map((x) => `${x.id}: up to ${x.max} USDG`) : undefined,
+            contracts: added.length ? added : undefined,
+            steps: [
+                'Open the link. It opens the FIDES app with this agent already filled in.',
+                'Connect your wallet. Set the budget, the contracts allowed and the expiry. Start small.',
+                'Sign (free), click Create FIDES Account (a little gas), and send the budget to the FIDES Account address shown.',
+                'Come back and ask me for what you want. I pick up the signed FIDES by myself.',
+            ],
+        });
+    });
     server.registerTool('fides_use_file', {
         title: 'Use a FIDES file',
         description: 'Only needed if the user has a fides.json file: loads a signed FIDES from a path on this computer, checks that it is for this computer\'s agent key, and keeps a copy. FIDES signed in the app are picked up without this.',
@@ -503,7 +546,13 @@ export function createFidesMcpServer(cfg) {
                 return fail(notLoaded());
             if (!fides.services.length)
                 return fail(`This FIDES allows no paid services. To buy from a paid API, the user signs a new FIDES that includes one: call fides_setup with services, for example [{ id: "fides-demo", max: "0.1" }].`);
-            const id = service ?? (fides.services.length === 1 ? fides.services[0].serviceId : undefined);
+            const host = (() => { try {
+                return new URL(url).host.toLowerCase().replace(/^www\./, '');
+            }
+            catch {
+                return '';
+            } })();
+            const id = service ?? (fides.services.some((x) => x.serviceId === host) ? host : fides.services.length === 1 ? fides.services[0].serviceId : undefined);
             if (!id)
                 return fail(`Say which service this is. The FIDES allows: ${fides.services.map((x) => x.serviceId).join(', ')}.`);
             const rule = fides.services.find((x) => x.serviceId === id);
@@ -600,6 +649,134 @@ export function createFidesMcpServer(cfg) {
         }
     });
     // ---- SUB-FIDES ----
+    // ---- Connect anything ----
+    const lookupBase = () => cfg.api ?? cfg.directory ?? 'https://api.fidesbuilder.xyz';
+    async function inspect(address) {
+        const res = await fetch(`${lookupBase()}/v1/contracts/${address}`);
+        const json = fromJson(await res.text());
+        if (!res.ok || json?.error)
+            throw new Error(json?.error?.message ?? `HTTP ${res.status}`);
+        return json;
+    }
+    server.registerTool('fides_inspect_contract', {
+        title: 'What a contract lets an agent do',
+        description: 'Reads any contract on the chain from its verified source (proxies followed) and lists the functions that change something, in plain words, with risks flagged: "danger" (lasting approvals, handing control to another address, upgrades, debt), "warn" (the agent picks where funds go, or it sends ETH) and "admin" (operator-only; will fail for an agent). Use it before fides_setup with contracts, and recommend only the functions the user needs. Sends nothing.',
+        inputSchema: { address: z.string().describe('The contract address') },
+    }, async ({ address }) => {
+        try {
+            if (!isAddress(address))
+                return fail('That is not a contract address.');
+            const info = await inspect(address);
+            if (!info.verified)
+                return ok({ address: info.address, verified: false, note: 'Not verified on Sourcify, so its functions cannot be read. The user can still allow it by 4-byte selector.' });
+            return ok({
+                name: info.name, address: info.address, verified: true, proxy: info.proxy ?? undefined,
+                functions: info.functions.map((fn) => ({ name: fn.name, does: fn.about || undefined, signature: fn.signature, selector: fn.selector, risks: fn.risks.length ? fn.risks.map((r) => `${r.level}: ${r.why}`) : undefined })),
+                next: 'To allow some of these, call fides_setup with contracts: [{ address, functions: [names] }] and give the user the link.',
+            });
+        }
+        catch (err) {
+            return fail('Could not read the contract: ' + (err?.message ?? err));
+        }
+    });
+    server.registerTool('fides_check_api', {
+        title: 'Can FIDES pay this API?',
+        description: 'Calls a paid API\'s URL once, without paying, and reads its x402 price: whether a FIDES on Robinhood Chain can pay it, the price, who is paid, and the service id and a suggested cap to use with fides_setup. Use it when the user wants the agent to use a paid API that is not one of the known ones. Pays nothing.',
+        inputSchema: { url: z.string().describe('The API URL, https') },
+    }, async ({ url }) => {
+        try {
+            const res = await fetch(`${lookupBase()}/v1/services/probe`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: toJson({ url, budgetToken: (await currentFides().catch(() => null))?.spendLimits[0].asset ?? '0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168' }) });
+            const p = fromJson(await res.text());
+            if (!res.ok || p?.error)
+                return fail(p?.error?.message ?? `HTTP ${res.status}`);
+            if (!p.payable)
+                return ok({ url: p.url, payable: false, why: p.reason, charges_on: p.networks?.length ? p.networks : undefined });
+            const dec = p.offer.decimals ?? 6, sym = p.offer.symbol ?? 'USDG';
+            return ok({
+                url: p.url, payable: true, price: `${formatUnits(BigInt(p.offer.amount), dec)} ${sym} a request`, paid_to: p.offer.payTo, what_it_is: p.description,
+                service_id: p.serviceId, suggested_cap: `${formatUnits(BigInt(p.suggestedCap), dec)} ${sym} (10 requests)`,
+                next: `To allow it, call fides_setup with services: [{ id: "${p.serviceId}", max: "${formatUnits(BigInt(p.suggestedCap), dec)}" }]. Then fides_pay_request with this URL.`,
+            });
+        }
+        catch (err) {
+            return fail('Could not check the API: ' + (err?.message ?? err));
+        }
+    });
+    // ---- Uniswap ----
+    const tokenArg = (t) => (/^eth$/i.test(t) ? 'ETH' : /^weth$/i.test(t) ? uniswap[cfg.chainId]?.weth : isAddress(t) ? getAddress(t) : null);
+    server.registerTool('fides_swap', {
+        title: 'Swap on Uniswap inside the FIDES',
+        description: 'Gets the best route from Uniswap on Robinhood Chain (v2, v3 and v4 pools, including v4 pools with hooks such as the aggregator hooks) for the FIDES Account, checks it against the trading mandate the owner signed (tokens it may buy, worst price, most per swap), and simulates it to measure what would actually arrive. Sends nothing. Returns a plan_id for fides_execute, which sends an exact approval and the swap as one transaction; gas is paid by the relayer. Show the route, the quoted amount and the worst accepted amount to the user before executing. Needs a FIDES that allows swaps: fides_setup with swap.',
+        inputSchema: {
+            token_out: z.string().describe('What to buy: "ETH", "WETH" or a token address'),
+            amount: z.string().describe('How much of the budget token to spend, e.g. "1"'),
+            max_slippage_percent: z.number().positive().optional().describe('Worst price against the quote, in percent. Defaults to the most the FIDES allows'),
+        },
+    }, async ({ token_out, amount, max_slippage_percent }) => {
+        try {
+            const fides = await currentFides();
+            if (!fides)
+                return fail(notLoaded());
+            if (fides.agent.toLowerCase() !== agent.address.toLowerCase())
+                return fail(`The loaded FIDES is for agent ${fides.agent}, not this computer's agent key ${agent.address}.`);
+            const m = mandateOf(fides);
+            if (!m)
+                return fail('This FIDES does not allow swaps. The user signs one that does: call fides_setup with swap, for example { buy: ["ETH"], max_slippage_percent: 1, max_per_swap: "1" }, and give them the link.');
+            const out = tokenArg(token_out);
+            if (!out)
+                return fail('"token_out" must be "ETH", "WETH" or a token address.');
+            const budgetToken = fides.spendLimits[0].asset, tIn = await token(budgetToken);
+            let value;
+            try {
+                value = parseUnits(amount, tIn.decimals);
+            }
+            catch {
+                return fail(`"amount" must be a number of ${tIn.symbol}, like "1".`);
+            }
+            const slippageBps = max_slippage_percent ? Math.round(max_slippage_percent * 100) : m.maxSlippageBps;
+            let q, blocked;
+            if (cfg.api) {
+                const r = await post('/v1/swap/quote', { fides, tokenOut: out, amount: value, slippageBps });
+                q = r.quote;
+                blocked = r.mandate?.allowed ? null : { code: r.mandate.code, message: r.mandate.message };
+            }
+            else {
+                if (!process.env.UNISWAP_API_KEY)
+                    return fail('Swaps need the FIDES API, or UNISWAP_API_KEY when running without it.');
+                q = await quoteUniswap({ apiKey: process.env.UNISWAP_API_KEY, fides, tokenOut: out, amount: value, slippageBps });
+                blocked = checkMandate(fides, q);
+            }
+            const outInfo = q.tokenOut === NATIVE ? { symbol: 'ETH', decimals: 18 } : await token(q.tokenOut);
+            const fmt = (v) => `${formatUnits(v, outInfo.decimals)} ${outInfo.symbol}`;
+            if (blocked)
+                return fail(`Blocked by the trading mandate: ${blocked.message} Nothing was sent.`);
+            const actions = swapActions(q, `swap ${amount} ${tIn.symbol} to ${outInfo.symbol} on Uniswap`);
+            const plan = await new FidesBuilder({ client, fides, agent }).add(actions).build();
+            if (plan.rejected().length) {
+                const r = plan.rejected()[0];
+                return fail(`Blocked by the FIDES: ${REASONS[r.reason ?? ''] ?? r.reason}. Nothing was sent.`);
+            }
+            const v = await verifySwap(client, fides, plan, q);
+            const id = plan.planHash.slice(0, 18);
+            if (v.ok)
+                plans.set(id, { plan, actions, fides, swap: { quote: q, outDecimals: outInfo.decimals, outSymbol: outInfo.symbol } });
+            return ok({
+                plan_id: v.ok ? id : null,
+                ready_to_execute: v.ok,
+                route: describeRoute(q),
+                spend: `${amount} ${tIn.symbol}`,
+                quoted: fmt(q.quotedOut),
+                worst_accepted: `${fmt(q.minOut)} (${q.slippageBps / 100}% below the quote)`,
+                simulated: v.ok ? `would receive ${fmt(v.received)}` : `refused: ${v.reason}`,
+                transactions: `${plan.estimatedSavings().baselineTransactions} onchain write(s) go out as ${plan.estimatedSavings().estimatedTransactions} transaction(s): an exact approval and the swap, nothing left approved`,
+                mandate: `may buy ${m.buy.join(', ')}; worst price ${m.maxSlippageBps / 100}%; most per swap ${formatUnits(m.maxPerSwap, tIn.decimals)} ${tIn.symbol}`,
+                sent: 'nothing has been sent',
+            });
+        }
+        catch (err) {
+            return fail(err instanceof SwapError ? `Uniswap: ${err.message}` : 'Could not get a swap: ' + (err?.shortMessage ?? err?.message ?? err));
+        }
+    });
     server.registerTool('fides_delegate', {
         title: 'Hand another agent a slice of the FIDES (SUB-FIDES)',
         description: 'This agent hands another agent a SUB-FIDES: its own budget, contracts and expiry, inside this FIDES. The child can never exceed it, and everything it spends also counts against this FIDES. This agent signs it; nothing is sent onchain and it costs nothing. The child agent (Claude or an SDK agent running FIDES) finds it by itself, or the user can hand it the file. Needs a FIDES that allows delegation: fides_setup with delegate: true. Confirm the amount and the agent with the user first.',
@@ -729,7 +906,7 @@ export function createFidesMcpServer(cfg) {
             const given = fs.existsSync(subsDir) ? fs.readdirSync(subsDir).filter((n) => n.endsWith('.json')).map((n) => fromJson(fs.readFileSync(path.join(subsDir, n), 'utf8')).sub) : [];
             const now = BigInt(Math.floor(Date.now() / 1000));
             return ok({
-                handed_out: given.map((s) => ({ sub_fides: s.id, child_agent: s.agent, budget: s.spendLimits.map((l) => l.amount.toString()), expires: new Date(Number(s.validUntil) * 1000).toISOString(), expired: now >= s.validUntil })),
+                handed_out: await Promise.all(given.map(async (s) => ({ sub_fides: s.id, child_agent: s.agent, budget: (await Promise.all(s.spendLimits.map(async (l) => { const t = await token(l.asset); return `${formatUnits(l.amount, t.decimals)} ${t.symbol}`; }))).join(', '), expires: new Date(Number(s.validUntil) * 1000).toISOString(), expired: now >= s.validUntil }))),
                 received: (await receivedSubs()).map((x) => ({ sub_fides: x.sub.id, delegated_by: x.parent.agent, expires: new Date(Number(x.sub.validUntil) * 1000).toISOString() })),
             });
         }
@@ -762,9 +939,12 @@ export function createFidesMcpServer(cfg) {
         if (!entry)
             return fail('No plan with that id. Make one with fides_plan first (plans are kept until they are executed or the server restarts).');
         plans.delete(plan_id); // a plan's bundles can be sent once
-        const { plan, actions, fides, net } = entry;
+        const { plan, actions, fides, net, swap } = entry;
         try {
+            const outBalance = () => !swap ? Promise.resolve(0n) : swap.quote.tokenOut === NATIVE ? client.public.getBalance({ address: fides.account }) : client.public.readContract({ address: swap.quote.tokenOut, abi: erc20Abi, functionName: 'balanceOf', args: [fides.account] });
+            const before = await outBalance();
             const bundles = await send(plan, actions, fides);
+            const received = swap ? (await outBalance()) - before : 0n;
             const [spend] = await Policy.remainingSpend(client, fides);
             const t = await token(fides.spendLimits[0].asset);
             const executed = bundles.filter((b) => b.status === 'EXECUTED').length;
@@ -772,6 +952,12 @@ export function createFidesMcpServer(cfg) {
                 result: executed === bundles.length ? 'executed' : executed ? 'partly executed' : 'not executed',
                 transactions: bundles.map((b) => ({ status: b.status.toLowerCase(), transaction: txLink(b.txHash), ...(b.error ? { reason: failure(b.error) } : {}) })),
                 blocked_and_not_sent: plan.rejected().map((a) => `${a.label}: ${REASONS[a.reason ?? ''] ?? a.reason}`),
+                ...(swap && executed === bundles.length ? { best_execution: {
+                        quoted: `${formatUnits(swap.quote.quotedOut, swap.outDecimals)} ${swap.outSymbol}`,
+                        received: `${formatUnits(received, swap.outDecimals)} ${swap.outSymbol}`,
+                        versus_quote: received >= swap.quote.quotedOut ? 'at or better than the quote' : `${(Number(((swap.quote.quotedOut - received) * 10000n) / swap.quote.quotedOut) / 100).toFixed(2)}% below the quote, inside the ${swap.quote.slippageBps / 100}% allowed`,
+                        route: describeRoute(swap.quote),
+                    } } : {}),
                 ...(net && executed === bundles.length ? { netting_record: { contract: netRoots[cfg.chainId], operator: fides.account, epoch: net.epoch.toString(), obligations_root: net.obligationsRoot, settlement_root: net.settlementRoot, contract_link: explorer ? `${explorer}/address/${netRoots[cfg.chainId]}` : undefined } } : {}),
                 budget_remaining: `${formatUnits(spend.remaining, t.decimals)} of ${formatUnits(spend.limit, t.decimals)} ${t.symbol}`,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fidesbuild/mcp-server",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "FIDES as tools for Claude and any MCP client: plan and execute actions inside a signed FIDES, gas paid by the hosted relayer.",
   "keywords": [
     "fides",
@@ -41,6 +41,7 @@
     "zod": "^4.6.5",
     "@fidesbuild/x402": "0.2.0",
     "@fidesbuild/net": "0.2.1",
-    "@fidesbuild/sub": "0.2.0"
+    "@fidesbuild/sub": "0.2.0",
+    "@fidesbuild/swap": "0.2.0"
   }
 }