@andrewkimjoseph/celina-sdk 0.2.10 → 0.2.12

package/tests/catalog/domains/chain-ext.ts

@@ -0,0 +1,219 @@
+import { expect } from "vitest";
+import type { OperationSpec } from "../types.js";
+import { assertArray, assertHasKeys } from "../../helpers/assert.js";
+
+export const governanceOperations: OperationSpec[] = [
+  {
+    id: "governance.getGovernanceProposals",
+    domain: "governance",
+    layer: "read",
+    sdk: {
+      invoke: (client) =>
+        client.governance.getGovernanceProposals({ page: 1, pageSize: 5 }),
+    },
+    mcp: {
+      tool: "get_governance_proposals",
+      arguments: () => ({ page: 1, pageSize: 5 }),
+    },
+    assert: (result) => {
+      const obj = assertHasKeys(result, ["proposals", "pagination"]);
+      expect(Array.isArray(obj.proposals)).toBe(true);
+    },
+  },
+  {
+    id: "governance.getProposalDetails",
+    domain: "governance",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.governance.getProposalDetails(fx.proposalId),
+    },
+    mcp: {
+      tool: "get_proposal_details",
+      arguments: (fx) => ({ proposalId: fx.proposalId }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["proposal"]);
+    },
+  },
+];
+
+export const stakingOperations: OperationSpec[] = [
+  {
+    id: "staking.getStakingBalances",
+    domain: "staking",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) => client.staking.getStakingBalances(fx.wallet),
+    },
+    mcp: {
+      tool: "get_staking_balances",
+      arguments: (fx) => ({ address: fx.wallet }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["address", "groups"]);
+    },
+  },
+  {
+    id: "staking.getActivatableStakes",
+    domain: "staking",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) => client.staking.getActivatableStakes(fx.wallet),
+    },
+    mcp: {
+      tool: "get_activatable_stakes",
+      arguments: (fx) => ({ address: fx.wallet }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["activatableGroups"]);
+    },
+  },
+  {
+    id: "staking.getValidatorGroups",
+    domain: "staking",
+    layer: "read",
+    sdk: {
+      invoke: (client) =>
+        client.staking.getValidatorGroups({ page: 1, pageSize: 5 }),
+    },
+    mcp: {
+      tool: "get_validator_groups",
+      arguments: () => ({ page: 1, pageSize: 5 }),
+    },
+    assert: (result) => {
+      const obj = assertHasKeys(result, ["groups"]);
+      assertArray(obj.groups);
+    },
+  },
+  {
+    id: "staking.getValidatorGroupDetails",
+    domain: "staking",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.staking.getValidatorGroupDetails(fx.validatorGroup),
+    },
+    mcp: {
+      tool: "get_validator_group_details",
+      arguments: (fx) => ({ groupAddress: fx.validatorGroup }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["address", "name"]);
+    },
+  },
+  {
+    id: "staking.getTotalStakingInfo",
+    domain: "staking",
+    layer: "read",
+    sdk: {
+      invoke: (client) => client.staking.getTotalStakingInfo(),
+    },
+    mcp: {
+      tool: "get_total_staking_info",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["totalVotes"]);
+    },
+  },
+];
+
+export const nftOperations: OperationSpec[] = [
+  {
+    id: "nft.getNftInfo",
+    domain: "nft",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.nft.getNftInfo(fx.saidContract, fx.saidTokenId),
+    },
+    mcp: {
+      tool: "get_nft_info",
+      arguments: (fx) => ({
+        contractAddress: fx.saidContract,
+        tokenId: fx.saidTokenId,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["contractAddress", "tokenId"]);
+    },
+  },
+  {
+    id: "nft.getNftBalance",
+    domain: "nft",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.nft.getNftBalance(fx.saidContract, fx.saidOwner),
+    },
+    mcp: {
+      tool: "get_nft_balance",
+      arguments: (fx) => ({
+        contractAddress: fx.saidContract,
+        address: fx.saidOwner,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["balance"]);
+    },
+  },
+];
+
+export const contractOperations: OperationSpec[] = [
+  {
+    id: "contract.callFunction",
+    domain: "contract",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.contract.callFunction({
+          contractAddress: fx.usdm,
+          abi: fx.erc20SymbolAbi,
+          functionName: "symbol",
+          functionArgs: [],
+        }),
+    },
+    mcp: {
+      tool: "call_contract_function",
+      arguments: (fx) => ({
+        contractAddress: fx.usdm,
+        abi: fx.erc20SymbolAbi,
+        functionName: "symbol",
+        functionArgs: [],
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["result"]);
+    },
+  },
+  {
+    id: "contract.estimateGas",
+    domain: "contract",
+    layer: "read",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.contract.estimateGas({
+          contractAddress: fx.usdm,
+          abi: fx.erc20SymbolAbi,
+          functionName: "symbol",
+          functionArgs: [],
+          fromAddress: fx.signerAddress ?? fx.wallet,
+        }),
+    },
+    mcp: {
+      tool: "estimate_contract_gas",
+      arguments: (fx) => ({
+        contractAddress: fx.usdm,
+        abi: fx.erc20SymbolAbi,
+        functionName: "symbol",
+        functionArgs: [],
+        fromAddress: fx.signerAddress ?? fx.wallet,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["gasEstimate"]);
+    },
+  },
+];

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,161 @@
+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",
+    mcp: {
+      tool: "verify_self_agent",
+      arguments: (fx) => ({
+        agent_address: fx.selfAgentAddress,
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["verified"]);
+    },
+  },
+  {
+    id: "self.lookupSelfAgent",
+    domain: "self",
+    layer: "read",
+    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"],
+    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,
+    mcp: {
+      tool: "register_self_agent",
+      arguments: () => ({
+        mode: "wallet-free",
+        agent_name: "celina-test",
+      }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["sessionId"]);
+    },
+  },
+  {
+    id: "self.checkSelfRegistration",
+    domain: "self",
+    layer: "read",
+    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"],
+    mcp: {
+      tool: "get_self_identity",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["agentAddress"]);
+    },
+  },
+  {
+    id: "self.refreshSelfProof",
+    domain: "self",
+    layer: "write",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    requiresDestructive: true,
+    mcp: {
+      tool: "refresh_self_proof",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["sessionId"]);
+    },
+  },
+  {
+    id: "self.deregisterSelfAgent",
+    domain: "self",
+    layer: "write",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    requiresDestructive: true,
+    mcp: {
+      tool: "deregister_self_agent",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["sessionId"]);
+    },
+  },
+  {
+    id: "self.signSelfRequest",
+    domain: "self",
+    layer: "read",
+    requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    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"],
+    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"]);
+    },
+  },
+];