@andrewkimjoseph/celina-sdk 0.9.7 → 0.9.9

package/tests/catalog/domains/self.ts

@@ -1,220 +0,0 @@
-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.request_path ?? 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

@@ -1,74 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

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

package/tests/catalog/operations.ts

@@ -1,53 +0,0 @@
-import { blockchainOperations } from "./domains/blockchain.js";
-import { tokenOperations } from "./domains/token.js";
-import { transactionOperations } from "./domains/transaction.js";
-import {
-  aaveOperations,
-  ensOperations,
-  gooddollarOperations,
-  mentoFxOperations,
-  uniswapOperations,
-} from "./domains/defi.js";
-import {
-  contractOperations,
-  governanceOperations,
-  nftOperations,
-  stakingOperations,
-} from "./domains/chain-ext.js";
-import { selfOperations } from "./domains/self.js";
-import { getMcpToolNames } from "../../src/tools/catalog.js";
-import type { OperationSpec } from "./types.js";
-
-export const OPERATIONS: OperationSpec[] = [
-  ...blockchainOperations,
-  ...tokenOperations,
-  ...transactionOperations,
-  ...mentoFxOperations,
-  ...uniswapOperations,
-  ...aaveOperations,
-  ...ensOperations,
-  ...gooddollarOperations,
-  ...governanceOperations,
-  ...stakingOperations,
-  ...nftOperations,
-  ...contractOperations,
-  ...selfOperations,
-];
-
-export const MCP_OPERATIONS = OPERATIONS.filter(
-  (spec): spec is OperationSpec & { mcp: NonNullable<OperationSpec["mcp"]> } =>
-    Boolean(spec.mcp),
-);
-
-export const SDK_OPERATIONS = OPERATIONS.filter(
-  (spec): spec is OperationSpec & { sdk: NonNullable<OperationSpec["sdk"]> } =>
-    Boolean(spec.sdk),
-);
-
-/** MCP tool names from the SDK tools catalog. */
-export const MCP_TOOL_NAMES = getMcpToolNames();
-
-/** @deprecated Use MCP_TOOL_NAMES — kept for tests that import the operations-derived list. */
-export const MCP_TOOL_NAMES_FROM_OPERATIONS = MCP_OPERATIONS.map(
-  (spec) => spec.mcp.tool,
-);

package/tests/catalog/types.ts

@@ -1,27 +0,0 @@
-import type { CelinaClient } from "@andrewkimjoseph/celina-sdk";
-import type { MainnetFixtures } from "../fixtures/mainnet.js";
-
-export type OperationLayer = "read" | "write" | "prepare";
-
-export type EnvRequirement = "CELO_PRIVATE_KEY" | "SELF_AGENT_PRIVATE_KEY";
-
-export interface OperationSpec {
-  /** Stable id, e.g. `token.getTokenBalance`. */
-  id: string;
-  domain: string;
-  layer: OperationLayer;
-  requiresEnv?: EnvRequirement[];
-  /** On-chain writes (`send_token`, `execute_mento_fx`, Aave supply/withdraw). */
-  requiresWrites?: boolean;
-  /** Self register / deregister / refresh flows. */
-  requiresDestructive?: boolean;
-  sdk?: {
-    invoke: (client: CelinaClient, fx: MainnetFixtures) => Promise<unknown>;
-  };
-  mcp?: {
-    tool: string;
-    arguments: (fx: MainnetFixtures) => Record<string, unknown>;
-  };
-  assert: (result: unknown, fx: MainnetFixtures) => void;
-  skip?: () => string | undefined;
-}

package/tests/fixtures/mainnet.ts

@@ -1,93 +0,0 @@
-import type { CelinaClient } from "@andrewkimjoseph/celina-sdk";
-import { getSignerAddress } from "../helpers/env.js";
-
-export interface MainnetFixtures {
-  wallet: `0x${string}`;
-  usdm: `0x${string}`;
-  saidContract: `0x${string}`;
-  saidOwner: `0x${string}`;
-  saidTokenId: string;
-  validatorGroup: `0x${string}`;
-  proposalId: number;
-  ensName: string;
-  selfAgentId: number;
-  /** Known registered Self agent for read-only verification. */
-  selfAgentAddress: `0x${string}`;
-  erc20SymbolAbi: readonly [
-    {
-      readonly type: "function";
-      readonly name: "symbol";
-      readonly stateMutability: "view";
-      readonly inputs: readonly [];
-      readonly outputs: readonly [{ readonly type: "string" }];
-    },
-  ];
-  knownTxHash: `0x${string}`;
-  latestBlockNumber: bigint;
-  signerAddress?: `0x${string}`;
-  /** Populated by MCP enrichment when SELF_AGENT_PRIVATE_KEY is set. */
-  selfVerifyRequestArgs?: Record<string, unknown>;
-}
-
-export const MAINNET_STATIC = {
-  wallet: "0x471EcE3750Da237f93B8E339c536989b8978a438" as const,
-  usdm: "0x765DE816845861e75A25fCA122bb6898B8B1282a" as const,
-  saidContract: "0xaC3DF9ABf80d0F5c020C06B04Cced27763355944" as const,
-  saidOwner: "0x62fD20ca524C13Ce836Def1c0FF8e5119476868D" as const,
-  saidTokenId: "1",
-  validatorGroup: "0x0861a61Bf679A30680510EcC238ee43B82C5e843" as const,
-  proposalId: 293,
-  ensName: "celina.eth",
-  selfAgentId: 1,
-  selfAgentAddress: "0xC1C860804EFdA544fe79194d1a37e60b846CEdeb" as const,
-  erc20SymbolAbi: [
-    {
-      type: "function",
-      name: "symbol",
-      stateMutability: "view",
-      inputs: [],
-      outputs: [{ type: "string" }],
-    },
-  ] as const,
-};
-
-let cachedFixtures: MainnetFixtures | null = null;
-
-/** Load stable mainnet fixtures, resolving a recent tx hash once per process. */
-export async function getMainnetFixtures(
-  client: CelinaClient,
-): Promise<MainnetFixtures> {
-  if (cachedFixtures) {
-    return cachedFixtures;
-  }
-
-  const status = await client.blockchain.getNetworkStatus();
-  const latestBlockNumber = BigInt(status.blockNumber);
-  const block = await client.blockchain.getBlock(Number(latestBlockNumber), {
-    includeTransactions: true,
-  });
-
-  const txs = block.transactions as Array<{ hash?: `0x${string}` } | string>;
-  const firstTx = txs[0];
-  const knownTxHash =
-    typeof firstTx === "string"
-      ? (firstTx as `0x${string}`)
-      : (firstTx?.hash as `0x${string}`);
-
-  if (!knownTxHash) {
-    throw new Error("Could not resolve a mainnet transaction hash from latest block");
-  }
-
-  cachedFixtures = {
-    ...MAINNET_STATIC,
-    knownTxHash,
-    latestBlockNumber,
-    signerAddress: getSignerAddress(),
-  };
-
-  return cachedFixtures;
-}
-
-export function resetMainnetFixturesCache(): void {
-  cachedFixtures = null;
-}

package/tests/helpers/assert.ts

@@ -1,30 +0,0 @@
-import { expect } from "vitest";
-
-export function assertDefined(result: unknown): asserts result is NonNullable<unknown> {
-  expect(result).toBeDefined();
-  expect(result).not.toBeNull();
-}
-
-export function assertObject(result: unknown): Record<string, unknown> {
-  assertDefined(result);
-  expect(typeof result).toBe("object");
-  expect(Array.isArray(result)).toBe(false);
-  return result as Record<string, unknown>;
-}
-
-export function assertArray(result: unknown): unknown[] {
-  assertDefined(result);
-  expect(Array.isArray(result)).toBe(true);
-  return result as unknown[];
-}
-
-export function assertHasKeys(
-  result: unknown,
-  keys: string[],
-): Record<string, unknown> {
-  const obj = assertObject(result);
-  for (const key of keys) {
-    expect(obj).toHaveProperty(key);
-  }
-  return obj;
-}

package/tests/helpers/env.ts

@@ -1,38 +0,0 @@
-import { privateKeyToAccount } from "viem/accounts";
-
-export interface TestConfig {
-  rpcUrl: string;
-  ethRpcUrl?: string;
-}
-
-export function hasCeloWallet(): boolean {
-  return Boolean(process.env.CELO_PRIVATE_KEY);
-}
-
-export function hasSelfAgentKey(): boolean {
-  return Boolean(process.env.SELF_AGENT_PRIVATE_KEY);
-}
-
-export function allowsTestWrites(): boolean {
-  return process.env.CELINA_TEST_WRITES === "1";
-}
-
-export function allowsDestructiveTests(): boolean {
-  return process.env.CELINA_TEST_DESTRUCTIVE === "1";
-}
-
-export function getSignerAddress(): `0x${string}` | undefined {
-  const key = process.env.CELO_PRIVATE_KEY;
-  if (!key) {
-    return undefined;
-  }
-  return privateKeyToAccount(key as `0x${string}`).address;
-}
-
-/** RPC URLs aligned with celina-mcp `loadConfig()`. */
-export function loadTestConfig(): TestConfig {
-  return {
-    rpcUrl: process.env.CELO_RPC_URL_MAINNET ?? "https://forno.celo.org",
-    ethRpcUrl: process.env.ETH_RPC_URL_MAINNET,
-  };
-}

package/tests/helpers/gating.ts

@@ -1,36 +0,0 @@
-import type { OperationSpec } from "../catalog/types.js";
-import {
-  allowsDestructiveTests,
-  allowsTestWrites,
-  hasCeloWallet,
-  hasSelfAgentKey,
-} from "./env.js";
-
-const ENV_CHECKS: Record<
-  NonNullable<OperationSpec["requiresEnv"]>[number],
-  () => boolean
-> = {
-  CELO_PRIVATE_KEY: hasCeloWallet,
-  SELF_AGENT_PRIVATE_KEY: hasSelfAgentKey,
-};
-
-/** Returns a skip reason when the operation should not run, otherwise undefined. */
-export function getOperationSkipReason(spec: OperationSpec): string | undefined {
-  if (spec.requiresDestructive && !allowsDestructiveTests()) {
-    return "Set CELINA_TEST_DESTRUCTIVE=1 to run destructive Self lifecycle tests";
-  }
-
-  if (spec.requiresWrites && !allowsTestWrites()) {
-    return "Set CELINA_TEST_WRITES=1 to run on-chain write tests";
-  }
-
-  if (spec.requiresEnv) {
-    for (const requirement of spec.requiresEnv) {
-      if (!ENV_CHECKS[requirement]()) {
-        return `Missing ${requirement}`;
-      }
-    }
-  }
-
-  return spec.skip?.() ?? undefined;
-}