@andrewkimjoseph/celina-sdk 0.2.11 → 0.3.1

package/tests/catalog/domains/defi.ts

@@ -0,0 +1,264 @@
+import type { OperationSpec } from "../types.js";
+import { assertHasKeys } from "../../helpers/assert.js";
+
+function fromAddress(fx: Parameters<OperationSpec["assert"]>[1]): `0x${string}` {
+  return fx.signerAddress ?? fx.wallet;
+}
+
+export const mentoFxOperations: OperationSpec[] = [
+  {
+    id: "mentoFx.getFxQuote",
+    domain: "mentoFx",
+    layer: "read",
+    sdk: {
+      invoke: (client) => client.mentoFx.getFxQuote("USDm", "EURm", "1"),
+    },
+    mcp: {
+      tool: "get_mento_fx_quote",
+      arguments: () => ({
+        tokenIn: "USDm",
+        tokenOut: "EURm",
+        amount: "1",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["tokenIn", "tokenOut", "expectedOut"]);
+    },
+  },
+  {
+    id: "mentoFx.estimateFx",
+    domain: "mentoFx",
+    layer: "read",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.mentoFx.estimateFx(fromAddress(fx), "USDm", "EURm", "1"),
+    },
+    mcp: {
+      tool: "estimate_mento_fx",
+      arguments: () => ({
+        tokenIn: "USDm",
+        tokenOut: "EURm",
+        amount: "1",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["fxGas", "expectedOut"]);
+    },
+  },
+  {
+    id: "mentoFx.prepareFx",
+    domain: "mentoFx",
+    layer: "prepare",
+    sdk: {
+      invoke: (client, fx) =>
+        client.mentoFx.prepareFx(fromAddress(fx), "USDm", "EURm", "1"),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["from", "steps", "summary"]);
+    },
+  },
+  {
+    id: "mentoFx.executeFx",
+    domain: "mentoFx",
+    layer: "write",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    requiresWrites: true,
+    mcp: {
+      tool: "execute_mento_fx",
+      arguments: () => ({
+        tokenIn: "USDm",
+        tokenOut: "EURm",
+        amount: "0.01",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["hash"]);
+    },
+  },
+];
+
+export const uniswapOperations: OperationSpec[] = [
+  {
+    id: "uniswap.getSwapQuote",
+    domain: "uniswap",
+    layer: "read",
+    sdk: {
+      invoke: (client) => client.uniswap.getSwapQuote("CELO", "USDC", "0.001"),
+    },
+    mcp: {
+      tool: "get_uniswap_quote",
+      arguments: () => ({
+        tokenIn: "CELO",
+        tokenOut: "USDC",
+        amount: "0.001",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["tokenIn", "tokenOut", "expectedOut", "protocol"]);
+    },
+  },
+  {
+    id: "uniswap.estimateSwap",
+    domain: "uniswap",
+    layer: "read",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.uniswap.estimateSwap(
+          fromAddress(fx),
+          "CELO",
+          "USDC",
+          "0.001",
+        ),
+    },
+    mcp: {
+      tool: "estimate_uniswap_swap",
+      arguments: () => ({
+        tokenIn: "CELO",
+        tokenOut: "USDC",
+        amount: "0.001",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["swapGas", "expectedOut"]);
+    },
+  },
+  {
+    id: "uniswap.prepareSwap",
+    domain: "uniswap",
+    layer: "prepare",
+    sdk: {
+      invoke: (client, fx) =>
+        client.uniswap.prepareSwap(
+          fromAddress(fx),
+          "CELO",
+          "USDC",
+          "0.001",
+        ),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["from", "steps", "summary"]);
+    },
+  },
+  {
+    id: "uniswap.executeSwap",
+    domain: "uniswap",
+    layer: "write",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    requiresWrites: true,
+    mcp: {
+      tool: "execute_uniswap_swap",
+      arguments: () => ({
+        tokenIn: "CELO",
+        tokenOut: "USDC",
+        amount: "0.001",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["hash"]);
+    },
+  },
+];
+
+export const aaveOperations: OperationSpec[] = [
+  {
+    id: "aave.prepareSupply",
+    domain: "aave",
+    layer: "prepare",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.aave.prepareSupply(fromAddress(fx), "USDm", "0.01"),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["from", "steps"]);
+    },
+  },
+  {
+    id: "aave.prepareWithdraw",
+    domain: "aave",
+    layer: "prepare",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.aave.prepareWithdraw(fromAddress(fx), "USDm", "0.01"),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["from", "steps"]);
+    },
+  },
+  {
+    id: "aave.supply",
+    domain: "aave",
+    layer: "write",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    requiresWrites: true,
+    mcp: {
+      tool: "supply_aave",
+      arguments: () => ({
+        token: "USDm",
+        amount: "0.01",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["hash"]);
+    },
+  },
+  {
+    id: "aave.withdraw",
+    domain: "aave",
+    layer: "write",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    requiresWrites: true,
+    mcp: {
+      tool: "withdraw_aave",
+      arguments: () => ({
+        token: "USDm",
+        amount: "0.01",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["hash"]);
+    },
+  },
+];
+
+export const ensOperations: OperationSpec[] = [
+  {
+    id: "ens.resolveEns",
+    domain: "ens",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) => client.ens.resolveEns(fx.ensName, "celo"),
+    },
+    mcp: {
+      tool: "resolve_ens",
+      arguments: (fx) => ({
+        name: fx.ensName,
+        chain: "celo",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["name", "address"]);
+    },
+  },
+];
+
+export const gooddollarOperations: OperationSpec[] = [
+  {
+    id: "gooddollar.getWhitelistingInfo",
+    domain: "gooddollar",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) => client.gooddollar.getWhitelistingInfo(fx.wallet),
+    },
+    mcp: {
+      tool: "get_gooddollar_whitelisting_info",
+      arguments: (fx) => ({ address: fx.wallet }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["isCurrentlyWhitelisted"]);
+    },
+  },
+];

package/tests/catalog/domains/self.ts

@@ -0,0 +1,220 @@
+import type { OperationSpec } from "../types.js";
+import { assertHasKeys } from "../../helpers/assert.js";
+
+const SELF_DEMO_VERIFY_URL =
+  "https://app.ai.self.xyz/api/demo/verify?network=celo-mainnet";
+
+export const selfOperations: OperationSpec[] = [
+  {
+    id: "self.verifySelfAgent",
+    domain: "self",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.self.verifyAgent({ agentAddress: fx.selfAgentAddress }),
+    },
+    mcp: {
+      tool: "verify_self_agent",
+      arguments: (fx) => ({
+        agent_address: fx.selfAgentAddress,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["verified"]);
+    },
+  },
+  {
+    id: "self.lookupSelfAgent",
+    domain: "self",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) => client.self.lookupAgent(fx.selfAgentId),
+    },
+    mcp: {
+      tool: "lookup_self_agent",
+      arguments: (fx) => ({
+        agent_id: fx.selfAgentId,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["agentId"]);
+    },
+  },
+  {
+    id: "self.verifySelfRequest",
+    domain: "self",
+    layer: "read",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) => {
+        const args = fx.selfVerifyRequestArgs ?? {};
+        return client.self.verifyRequest({
+          agentSignature: args.agent_signature as `0x${string}`,
+          agentTimestamp: String(args.agent_timestamp),
+          method: String(args.method),
+          path: String(args.path),
+          body: typeof args.body === "string" ? args.body : undefined,
+          keytype: typeof args.keytype === "string" ? args.keytype : undefined,
+          agentKey: args.agent_key as `0x${string}` | undefined,
+        });
+      },
+    },
+    mcp: {
+      tool: "verify_self_request",
+      arguments: (fx) => fx.selfVerifyRequestArgs ?? {},
+    },
+    skip: () =>
+      process.env.CELINA_TEST_SELF_VERIFY === "1"
+        ? undefined
+        : "Set CELINA_TEST_SELF_VERIFY=1 (MCP suite enriches signed fixture in beforeAll)",
+    assert: (result) => {
+      assertHasKeys(result, ["valid"]);
+    },
+  },
+  {
+    id: "self.registerSelfAgent",
+    domain: "self",
+    layer: "write",
+    requiresDestructive: true,
+    sdk: {
+      invoke: (client) =>
+        client.self.registerAgent({
+          mode: "wallet-free",
+          agentName: "celina-test",
+        }),
+    },
+    mcp: {
+      tool: "register_self_agent",
+      arguments: () => ({
+        mode: "wallet-free",
+        agent_name: "celina-test",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["session_id"]);
+    },
+  },
+  {
+    id: "self.checkSelfRegistration",
+    domain: "self",
+    layer: "read",
+    sdk: {
+      invoke: (client) =>
+        client.self.checkRegistration(
+          process.env.CELINA_TEST_SELF_SESSION ?? "missing-session",
+        ),
+    },
+    mcp: {
+      tool: "check_self_registration",
+      arguments: () => ({
+        session_id: process.env.CELINA_TEST_SELF_SESSION ?? "missing-session",
+      }),
+    },
+    skip: () =>
+      process.env.CELINA_TEST_SELF_SESSION
+        ? undefined
+        : "Set CELINA_TEST_SELF_SESSION to poll a pending Self session",
+    assert: (result) => {
+      assertHasKeys(result, ["status"]);
+    },
+  },
+  {
+    id: "self.getSelfIdentity",
+    domain: "self",
+    layer: "read",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client) => client.self.getIdentity(),
+    },
+    mcp: {
+      tool: "get_self_identity",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      const obj = result as Record<string, unknown>;
+      assertHasKeys(obj, obj.registered === false ? ["registered"] : ["address"]);
+    },
+  },
+  {
+    id: "self.refreshSelfProof",
+    domain: "self",
+    layer: "write",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    requiresDestructive: true,
+    sdk: {
+      invoke: (client) => client.self.refreshProof(),
+    },
+    mcp: {
+      tool: "refresh_self_proof",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["session_id"]);
+    },
+  },
+  {
+    id: "self.deregisterSelfAgent",
+    domain: "self",
+    layer: "write",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    requiresDestructive: true,
+    sdk: {
+      invoke: (client) => client.self.deregisterAgent(),
+    },
+    mcp: {
+      tool: "deregister_self_agent",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["session_id"]);
+    },
+  },
+  {
+    id: "self.signSelfRequest",
+    domain: "self",
+    layer: "read",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client) =>
+        client.self.signRequest({
+          method: "GET",
+          url: SELF_DEMO_VERIFY_URL,
+        }),
+    },
+    mcp: {
+      tool: "sign_self_request",
+      arguments: () => ({
+        method: "GET",
+        url: SELF_DEMO_VERIFY_URL,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["headers"]);
+    },
+  },
+  {
+    id: "self.authenticatedSelfFetch",
+    domain: "self",
+    layer: "read",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client) =>
+        client.self.authenticatedFetch({
+          method: "POST",
+          url: SELF_DEMO_VERIFY_URL,
+          body: JSON.stringify({ ping: true }),
+        }),
+    },
+    mcp: {
+      tool: "authenticated_self_fetch",
+      arguments: () => ({
+        method: "POST",
+        url: SELF_DEMO_VERIFY_URL,
+        body: JSON.stringify({ ping: true }),
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["status"]);
+    },
+  },
+];

package/tests/catalog/domains/token.ts

@@ -0,0 +1,74 @@
+import { expect } from "vitest";
+import type { OperationSpec } from "../types.js";
+import { assertHasKeys } from "../../helpers/assert.js";
+
+export const tokenOperations: OperationSpec[] = [
+  {
+    id: "token.getBalances",
+    domain: "token",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.token.getBalances(fx.wallet, ["CELO", "USDm"]),
+    },
+    mcp: {
+      tool: "get_celo_balances",
+      arguments: (fx) => ({
+        address: fx.wallet,
+        tokens: ["CELO", "USDm"],
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["address", "balances"]);
+    },
+  },
+  {
+    id: "token.getStablecoinBalances",
+    domain: "token",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) => client.token.getStablecoinBalances(fx.wallet),
+    },
+    mcp: {
+      tool: "get_stablecoin_balances",
+      arguments: (fx) => ({ address: fx.wallet }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["address", "stablecoins"]);
+    },
+  },
+  {
+    id: "token.getTokenInfo",
+    domain: "token",
+    layer: "read",
+    sdk: {
+      invoke: (client) => client.token.getTokenInfo("USDm"),
+    },
+    mcp: {
+      tool: "get_token_info",
+      arguments: () => ({ token: "USDm" }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["symbol", "decimals"]);
+    },
+  },
+  {
+    id: "token.getTokenBalance",
+    domain: "token",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.token.getTokenBalance("USDm", fx.wallet),
+    },
+    mcp: {
+      tool: "get_token_balance",
+      arguments: (fx) => ({
+        token: "USDm",
+        address: fx.wallet,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["formatted", "symbol"]);
+    },
+  },
+];

package/tests/catalog/domains/transaction.ts

@@ -0,0 +1,111 @@
+import { parseEther } from "viem";
+import type { OperationSpec } from "../types.js";
+import { assertHasKeys } from "../../helpers/assert.js";
+
+function fromAddress(fx: Parameters<OperationSpec["assert"]>[1]): `0x${string}` {
+  return fx.signerAddress ?? fx.wallet;
+}
+
+export const transactionOperations: OperationSpec[] = [
+  {
+    id: "transaction.getGasFeeData",
+    domain: "transaction",
+    layer: "read",
+    sdk: {
+      invoke: (client) => client.transaction.getGasFeeData(),
+    },
+    mcp: {
+      tool: "get_gas_fee_data",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["network"]);
+    },
+  },
+  {
+    id: "transaction.estimateTransaction",
+    domain: "transaction",
+    layer: "read",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.transaction.estimateTransaction({
+          from: fromAddress(fx),
+          to: fx.wallet,
+          value: parseEther("0.001").toString(),
+        }),
+    },
+    mcp: {
+      tool: "estimate_transaction",
+      arguments: (fx) => ({
+        from: fromAddress(fx),
+        to: fx.wallet,
+        value: parseEther("0.001").toString(),
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["gasLimit"]);
+    },
+  },
+  {
+    id: "transaction.estimateSend",
+    domain: "transaction",
+    layer: "read",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.transaction.estimateSend(
+          fromAddress(fx),
+          fx.wallet,
+          "CELO",
+          "0.001",
+        ),
+    },
+    mcp: {
+      tool: "estimate_send",
+      arguments: () => ({
+        to: "0x471EcE3750Da237f93B8E339c536989b8978a438",
+        token: "CELO",
+        amount: "0.001",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["gas"]);
+    },
+  },
+  {
+    id: "transaction.prepareSend",
+    domain: "transaction",
+    layer: "prepare",
+    sdk: {
+      invoke: (client, fx) =>
+        client.transaction.prepareSend(
+          fromAddress(fx),
+          fx.wallet,
+          "CELO",
+          "0.001",
+        ),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["from", "steps", "summary"]);
+    },
+  },
+  {
+    id: "transaction.sendToken",
+    domain: "transaction",
+    layer: "write",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    requiresWrites: true,
+    mcp: {
+      tool: "send_token",
+      arguments: () => ({
+        to: "0x471EcE3750Da237f93B8E339c536989b8978a438",
+        token: "CELO",
+        amount: "0.000001",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["hash"]);
+    },
+  },
+];

package/tests/catalog/index.ts

@@ -0,0 +1,7 @@
+export type { OperationSpec, OperationLayer, EnvRequirement } from "./types.js";
+export {
+  OPERATIONS,
+  MCP_OPERATIONS,
+  SDK_OPERATIONS,
+  MCP_TOOL_NAMES,
+} from "./operations.js";