@andrewkimjoseph/celina-sdk 0.2.12 → 0.4.0

package/tests/catalog/domains/carbon.ts

@@ -0,0 +1,409 @@
+import type { OperationSpec } from "../types.js";
+import { assertHasKeys } from "../../helpers/assert.js";
+
+const CARBON_WALLET = "0x0000000000000000000000000000000000000001" as const;
+const CELO = "0x471EcE3750Da237a93B120cEadFa0b8eA6E3E25";
+const USDC = "0xcebA9300f2b948710d2653dd7D87747AdA2aA3b";
+
+function carbonRead(
+  id: string,
+  tool: string,
+  invoke: OperationSpec["sdk"]["invoke"],
+  args: () => Record<string, unknown>,
+  keys: string[],
+): OperationSpec {
+  return {
+    id,
+    domain: "carbon",
+    layer: "read",
+    sdk: { invoke },
+    mcp: { tool, arguments: args },
+    assert: (result) => assertHasKeys(result, keys),
+  };
+}
+
+function carbonPrepare(
+  id: string,
+  tool: string,
+  invoke: OperationSpec["sdk"]["invoke"],
+  args: () => Record<string, unknown>,
+): OperationSpec {
+  return {
+    id,
+    domain: "carbon",
+    layer: "prepare",
+    sdk: { invoke },
+    mcp: { tool, arguments: args },
+    assert: (result) => assertHasKeys(result, ["status", "warnings"]),
+    skip: () =>
+      "Carbon prepare tools require valid strategy params; run manually with funded wallet",
+  };
+}
+
+export const carbonOperations: OperationSpec[] = [
+  carbonRead(
+    "carbon.getStrategies",
+    "get_carbon_strategies",
+    (c) => c.carbon.getStrategies(CARBON_WALLET),
+    () => ({ wallet_address: CARBON_WALLET }),
+    ["status", "warnings"],
+  ),
+  {
+    ...carbonRead(
+      "carbon.getStrategy",
+      "get_carbon_strategy",
+      (c) => c.carbon.getStrategy("1"),
+      () => ({ strategy_id: "1" }),
+      ["status", "warnings"],
+    ),
+    skip: () =>
+      "Requires an existing Carbon strategy id on Celo (set CELINA_CARBON_STRATEGY_ID)",
+  },
+  {
+    ...carbonRead(
+      "carbon.getTradeQuote",
+      "get_carbon_trade_quote",
+      (c) =>
+        c.carbon.getTradeQuote({
+          source_token: CELO,
+          target_token: USDC,
+          amount: 1,
+          is_trade_by_target: false,
+        }),
+      () => ({
+        source_token: CELO,
+        target_token: USDC,
+        amount: 1,
+        is_trade_by_target: false,
+      }),
+      ["status", "warnings"],
+    ),
+    skip: () =>
+      "Carbon get_trade_quote on Celo may fail upstream (ENS); run manually when API is healthy",
+  },
+  carbonRead(
+    "carbon.explorePair",
+    "explore_carbon_pair",
+    (c) => c.carbon.explorePair({ base_token: CELO, quote_token: USDC }),
+    () => ({ base_token: CELO, quote_token: USDC }),
+    ["status", "chain"],
+  ),
+  carbonRead(
+    "carbon.resolveToken",
+    "resolve_carbon_token",
+    (c) => c.carbon.resolveToken("USDC"),
+    () => ({ token: "USDC" }),
+    ["status", "warnings"],
+  ),
+  carbonRead(
+    "carbon.getActivity",
+    "get_carbon_activity",
+    (c) => c.carbon.getActivity({ wallet_address: CARBON_WALLET }),
+    () => ({ wallet_address: CARBON_WALLET }),
+    ["status", "warnings"],
+  ),
+  {
+    ...carbonRead(
+      "carbon.findOpportunities",
+      "find_carbon_opportunities",
+      (c) => c.carbon.findOpportunities({ base_token: CELO, quote_token: USDC }),
+      () => ({ base_token: CELO, quote_token: USDC }),
+      ["status", "warnings"],
+    ),
+    skip: () =>
+      "Carbon find_opportunities may require market data on Celo; run manually when API returns opportunities",
+  },
+  carbonRead(
+    "carbon.getProtocolStats",
+    "get_carbon_protocol_stats",
+    (c) => c.carbon.getProtocolStats({ period_days: 7 }),
+    () => ({ period_days: 7 }),
+    ["status", "chain"],
+  ),
+  {
+    ...carbonRead(
+      "carbon.getPriceHistory",
+      "get_carbon_price_history",
+      (c) =>
+        c.carbon.getPriceHistory({
+          base_token: CELO,
+          quote_token: USDC,
+          period_days: 7,
+        }),
+      () => ({ base_token: CELO, quote_token: USDC, period_days: 7 }),
+      ["status", "warnings"],
+    ),
+    skip: () =>
+      "Carbon get_price_history may return 400 for some Celo pairs; run manually when API is healthy",
+  },
+  {
+    ...carbonRead(
+      "carbon.simulateStrategy",
+      "simulate_carbon_strategy",
+    (c) =>
+      c.carbon.simulateStrategy({
+        base_token: CELO,
+        quote_token: USDC,
+        days: 7,
+        buy_price_low: 0.1,
+        buy_price_high: 0.2,
+        buy_budget: 10,
+        sell_price_low: 0.3,
+        sell_price_high: 0.4,
+        sell_budget: 5,
+      }),
+    () => ({
+      base_token: CELO,
+      quote_token: USDC,
+      days: 7,
+      buy_price_low: 0.1,
+      buy_price_high: 0.2,
+      buy_budget: 10,
+      sell_price_low: 0.3,
+      sell_price_high: 0.4,
+      sell_budget: 5,
+    }),
+    ["status", "warnings"],
+    ),
+    skip: () =>
+      "Carbon simulate_strategy may return 400 upstream on Celo; run manually when API is healthy",
+  },
+  carbonRead(
+    "carbon.help",
+    "carbon_help",
+    (c) => c.carbon.help("create_limit_order"),
+    () => ({ topic: "create_limit_order" }),
+    ["status"],
+  ),
+  carbonRead(
+    "carbon.learn",
+    "carbon_learn",
+    (c) => c.carbon.learn("recurring_strategy"),
+    () => ({ topic: "recurring_strategy" }),
+    ["status"],
+  ),
+  carbonPrepare(
+    "carbon.prepareLimitOrder",
+    "prepare_carbon_limit_order",
+    (c) =>
+      c.carbon.prepareLimitOrder({
+        wallet_address: CARBON_WALLET,
+        base_token: CELO,
+        quote_token: USDC,
+        direction: "buy",
+        price: 0.5,
+        budget: 10,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      base_token: CELO,
+      quote_token: USDC,
+      direction: "buy",
+      price: 0.5,
+      budget: 10,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareRangeOrder",
+    "prepare_carbon_range_order",
+    (c) =>
+      c.carbon.prepareRangeOrder({
+        wallet_address: CARBON_WALLET,
+        base_token: CELO,
+        quote_token: USDC,
+        direction: "buy",
+        price_low: 0.4,
+        price_high: 0.6,
+        budget: 10,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      base_token: CELO,
+      quote_token: USDC,
+      direction: "buy",
+      price_low: 0.4,
+      price_high: 0.6,
+      budget: 10,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareRecurringStrategy",
+    "prepare_carbon_recurring_strategy",
+    (c) =>
+      c.carbon.prepareRecurringStrategy({
+        wallet_address: CARBON_WALLET,
+        base_token: CELO,
+        quote_token: USDC,
+        buy_price_low: 0.4,
+        buy_price_high: 0.5,
+        buy_budget: 10,
+        sell_price_low: 0.6,
+        sell_price_high: 0.7,
+        sell_budget: 5,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      base_token: CELO,
+      quote_token: USDC,
+      buy_price_low: 0.4,
+      buy_price_high: 0.5,
+      buy_budget: 10,
+      sell_price_low: 0.6,
+      sell_price_high: 0.7,
+      sell_budget: 5,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareConcentratedStrategy",
+    "prepare_carbon_concentrated_strategy",
+    (c) =>
+      c.carbon.prepareConcentratedStrategy({
+        wallet_address: CARBON_WALLET,
+        base_token: CELO,
+        quote_token: USDC,
+        spread_percentage: 1,
+        buy_budget: 10,
+        sell_budget: 5,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      base_token: CELO,
+      quote_token: USDC,
+      spread_percentage: 1,
+      buy_budget: 10,
+      sell_budget: 5,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareFullRangeStrategy",
+    "prepare_carbon_full_range_strategy",
+    (c) =>
+      c.carbon.prepareFullRangeStrategy({
+        wallet_address: CARBON_WALLET,
+        base_token: CELO,
+        quote_token: USDC,
+        spread_percentage: 5,
+        buy_budget: 10,
+        sell_budget: 5,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      base_token: CELO,
+      quote_token: USDC,
+      spread_percentage: 5,
+      buy_budget: 10,
+      sell_budget: 5,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareRepriceStrategy",
+    "prepare_carbon_reprice_strategy",
+    (c) =>
+      c.carbon.prepareRepriceStrategy({
+        wallet_address: CARBON_WALLET,
+        strategy_id: "1",
+        buy_price_low: 0.4,
+        buy_price_high: 0.5,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      strategy_id: "1",
+      buy_price_low: 0.4,
+      buy_price_high: 0.5,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareEditStrategy",
+    "prepare_carbon_edit_strategy",
+    (c) =>
+      c.carbon.prepareEditStrategy({
+        wallet_address: CARBON_WALLET,
+        strategy_id: "1",
+        buy_budget: 10,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      strategy_id: "1",
+      buy_budget: 10,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareDepositBudget",
+    "prepare_carbon_deposit_budget",
+    (c) =>
+      c.carbon.prepareDepositBudget({
+        wallet_address: CARBON_WALLET,
+        strategy_id: "1",
+        buy_budget: 5,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      strategy_id: "1",
+      buy_budget: 5,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.prepareWithdrawBudget",
+    "prepare_carbon_withdraw_budget",
+    (c) =>
+      c.carbon.prepareWithdrawBudget({
+        wallet_address: CARBON_WALLET,
+        strategy_id: "1",
+        buy_budget: 1,
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      strategy_id: "1",
+      buy_budget: 1,
+    }),
+  ),
+  carbonPrepare(
+    "carbon.preparePauseStrategy",
+    "prepare_carbon_pause_strategy",
+    (c) =>
+      c.carbon.preparePauseStrategy({
+        wallet_address: CARBON_WALLET,
+        strategy_id: "1",
+      }),
+    () => ({ wallet_address: CARBON_WALLET, strategy_id: "1" }),
+  ),
+  carbonPrepare(
+    "carbon.prepareResumeStrategy",
+    "prepare_carbon_resume_strategy",
+    (c) =>
+      c.carbon.prepareResumeStrategy({
+        wallet_address: CARBON_WALLET,
+        strategy_id: "1",
+      }),
+    () => ({ wallet_address: CARBON_WALLET, strategy_id: "1" }),
+  ),
+  carbonPrepare(
+    "carbon.prepareDeleteStrategy",
+    "prepare_carbon_delete_strategy",
+    (c) =>
+      c.carbon.prepareDeleteStrategy({
+        wallet_address: CARBON_WALLET,
+        strategy_id: "1",
+      }),
+    () => ({ wallet_address: CARBON_WALLET, strategy_id: "1" }),
+  ),
+  carbonPrepare(
+    "carbon.prepareTrade",
+    "prepare_carbon_trade",
+    (c) =>
+      c.carbon.prepareTrade({
+        wallet_address: CARBON_WALLET,
+        source_token: CELO,
+        target_token: USDC,
+        amount: "1",
+        min_return: "0",
+      }),
+    () => ({
+      wallet_address: CARBON_WALLET,
+      source_token: CELO,
+      target_token: USDC,
+      amount: "1",
+      min_return: "0",
+    }),
+  ),
+];

package/tests/catalog/domains/defi.ts

@@ -261,4 +261,47 @@ export const gooddollarOperations: OperationSpec[] = [
       assertHasKeys(result, ["isCurrentlyWhitelisted"]);
     },
   },
+  {
+    id: "gooddollar.getUbiClaimEligibility",
+    domain: "gooddollar",
+    layer: "read",
+    sdk: {
+      invoke: (client, fx) =>
+        client.gooddollar.getUbiClaimEligibility(fx.wallet),
+    },
+    mcp: {
+      tool: "get_gooddollar_ubi_entitlement",
+      arguments: (fx) => ({ address: fx.wallet }),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["isEligibleToClaim", "claimableAmount"]);
+    },
+  },
+  {
+    id: "gooddollar.prepareClaimUbi",
+    domain: "gooddollar",
+    layer: "prepare",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client, fx) =>
+        client.gooddollar.prepareClaimUbi(fromAddress(fx)),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["from", "steps"]);
+    },
+  },
+  {
+    id: "gooddollar.claimDailyUbi",
+    domain: "gooddollar",
+    layer: "write",
+    requiresEnv: ["CELO_PRIVATE_KEY"],
+    requiresWrites: true,
+    mcp: {
+      tool: "claim_daily_gooddollar_ubi",
+      arguments: () => ({}),
+    },
+    assert: (result) => {
+      assertHasKeys(result, ["hash"]);
+    },
+  },
 ];

package/tests/catalog/domains/self.ts

@@ -9,6 +9,10 @@ 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) => ({
@@ -23,6 +27,9 @@ export const selfOperations: OperationSpec[] = [
     id: "self.lookupSelfAgent",
     domain: "self",
     layer: "read",
+    sdk: {
+      invoke: (client, fx) => client.self.lookupAgent(fx.selfAgentId),
+    },
     mcp: {
       tool: "lookup_self_agent",
       arguments: (fx) => ({
@@ -38,6 +45,20 @@ export const selfOperations: OperationSpec[] = [
     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 ?? {},
@@ -55,6 +76,13 @@ export const selfOperations: OperationSpec[] = [
     domain: "self",
     layer: "write",
     requiresDestructive: true,
+    sdk: {
+      invoke: (client) =>
+        client.self.registerAgent({
+          mode: "wallet-free",
+          agentName: "celina-test",
+        }),
+    },
     mcp: {
       tool: "register_self_agent",
       arguments: () => ({
@@ -63,13 +91,19 @@ export const selfOperations: OperationSpec[] = [
       }),
     },
     assert: (result) => {
-      assertHasKeys(result, ["sessionId"]);
+      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: () => ({
@@ -89,12 +123,16 @@ export const selfOperations: OperationSpec[] = [
     domain: "self",
     layer: "read",
     requiresEnv: ["SELF_AGENT_PRIVATE_KEY"],
+    sdk: {
+      invoke: (client) => client.self.getIdentity(),
+    },
     mcp: {
       tool: "get_self_identity",
       arguments: () => ({}),
     },
     assert: (result) => {
-      assertHasKeys(result, ["agentAddress"]);
+      const obj = result as Record<string, unknown>;
+      assertHasKeys(obj, obj.registered === false ? ["registered"] : ["address"]);
     },
   },
   {
@@ -103,12 +141,15 @@ export const selfOperations: OperationSpec[] = [
     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, ["sessionId"]);
+      assertHasKeys(result, ["session_id"]);
     },
   },
   {
@@ -117,12 +158,15 @@ export const selfOperations: OperationSpec[] = [
     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, ["sessionId"]);
+      assertHasKeys(result, ["session_id"]);
     },
   },
   {
@@ -130,6 +174,13 @@ export const selfOperations: OperationSpec[] = [
     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: () => ({
@@ -146,6 +197,14 @@ export const selfOperations: OperationSpec[] = [
     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: () => ({

package/tests/catalog/operations.ts

@@ -15,6 +15,7 @@ import {
   stakingOperations,
 } from "./domains/chain-ext.js";
 import { selfOperations } from "./domains/self.js";
+import { carbonOperations } from "./domains/carbon.js";
 import type { OperationSpec } from "./types.js";
 
 export const OPERATIONS: OperationSpec[] = [
@@ -31,6 +32,7 @@ export const OPERATIONS: OperationSpec[] = [
   ...nftOperations,
   ...contractOperations,
   ...selfOperations,
+  ...carbonOperations,
 ];
 
 export const MCP_OPERATIONS = OPERATIONS.filter(