kontext-sdk 0.10.0 → 0.11.0

package/dist/index.js

@@ -3648,7 +3648,9 @@ var FEATURE_MIN_PLAN = {
   "unified-screening": "pro",
   "blocklist-manager": "pro",
   "kya-identity": "pro",
-  "kya-behavioral": "enterprise"
+  "kya-behavioral": "enterprise",
+  "coinbase-wallets": "enterprise",
+  "metamask-wallets": "enterprise"
 };
 var PLAN_RANK = { free: 0, pro: 1, enterprise: 2 };
 var FEATURE_LABELS = {
@@ -3667,7 +3669,9 @@ var FEATURE_LABELS = {
   "unified-screening": "Unified screening (OFAC, Chainalysis, OpenSanctions)",
   "blocklist-manager": "Custom blocklist/allowlist manager",
   "kya-identity": "KYA identity resolution (declared identity, wallet clustering)",
-  "kya-behavioral": "KYA behavioral fingerprinting (cross-session linking, confidence scoring)"
+  "kya-behavioral": "KYA behavioral fingerprinting (cross-session linking, confidence scoring)",
+  "coinbase-wallets": "Coinbase Developer Platform Wallets",
+  "metamask-wallets": "MetaMask Embedded Wallets"
 };
 function isFeatureAvailable(feature, currentPlan) {
   const requiredPlan = FEATURE_MIN_PLAN[feature];
@@ -5633,6 +5637,602 @@ var KYAConfidenceScorer = class {
   }
 };
 
+// src/integrations/circle-wallets.ts
+var DEFAULT_BASE_URL = "https://api.circle.com";
+var REQUEST_TIMEOUT_MS = 1e4;
+var CircleWalletManager = class {
+  apiKey;
+  entitySecret;
+  baseUrl;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  kontext = null;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "Circle API key is required"
+      );
+    }
+    if (!config.entitySecret) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "Circle entity secret is required"
+      );
+    }
+    this.apiKey = config.apiKey;
+    this.entitySecret = config.entitySecret;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+  }
+  /** Link to Kontext instance for auto-compliance logging */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setKontext(kontext) {
+    this.kontext = kontext;
+  }
+  /** Validate credentials by calling Circle's configuration endpoint */
+  async validateCredentials() {
+    try {
+      const res = await fetch(`${this.baseUrl}/v1/w3s/config/entity`, {
+        method: "GET",
+        headers: this.headers(),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  /** Create a wallet set (container for wallets) */
+  async createWalletSet(input) {
+    const body = {
+      name: input.name,
+      idempotencyKey: input.idempotencyKey ?? generateId(),
+      entitySecretCiphertext: this.entitySecret
+    };
+    const res = await this.request(
+      "POST",
+      "/v1/w3s/developer/walletSets",
+      body
+    );
+    return res.data.walletSet;
+  }
+  /** Create wallet(s) in a wallet set */
+  async createWallet(input) {
+    const body = {
+      walletSetId: input.walletSetId,
+      blockchains: input.blockchains.map((c) => this.mapChain(c)),
+      count: input.count ?? 1,
+      accountType: input.accountType ?? "EOA",
+      idempotencyKey: input.idempotencyKey ?? generateId(),
+      entitySecretCiphertext: this.entitySecret
+    };
+    const res = await this.request(
+      "POST",
+      "/v1/w3s/developer/wallets",
+      body
+    );
+    return res.data.wallets;
+  }
+  /** List wallets, optionally filtered by wallet set */
+  async listWallets(walletSetId) {
+    const qs = walletSetId ? `?walletSetId=${walletSetId}` : "";
+    const res = await this.request(
+      "GET",
+      `/v1/w3s/wallets${qs}`
+    );
+    return res.data.wallets;
+  }
+  /** Get wallet token balances */
+  async getBalance(walletId) {
+    const res = await this.request(
+      "GET",
+      `/v1/w3s/wallets/${walletId}/balances`
+    );
+    return res.data.tokenBalances.map((b) => ({
+      token: b.token.symbol,
+      amount: b.amount
+    }));
+  }
+  /** Transfer with auto-compliance: runs verify() before/after transfer */
+  async transferWithCompliance(input) {
+    let complianceResult;
+    if (this.kontext) {
+      complianceResult = await this.kontext.verify({
+        txHash: `circle-pending-${generateId()}`,
+        chain: input.blockchain,
+        amount: input.amount,
+        token: "USDC",
+        from: input.walletId,
+        to: input.destinationAddress,
+        agentId: input.agentId ?? "circle-wallet-manager"
+      });
+      if (!complianceResult.compliant) {
+        return {
+          id: "",
+          state: "BLOCKED",
+          complianceResult
+        };
+      }
+    }
+    const body = {
+      walletId: input.walletId,
+      tokenAddress: input.tokenAddress,
+      destinationAddress: input.destinationAddress,
+      amounts: [input.amount],
+      blockchain: this.mapChain(input.blockchain),
+      idempotencyKey: input.idempotencyKey ?? generateId(),
+      entitySecretCiphertext: this.entitySecret,
+      feeLevel: "MEDIUM"
+    };
+    const res = await this.request(
+      "POST",
+      "/v1/w3s/developer/transactions/transfer",
+      body
+    );
+    if (this.kontext) {
+      await this.kontext.logReasoning({
+        agentId: input.agentId ?? "circle-wallet-manager",
+        action: "circle-transfer",
+        reasoning: `Circle transfer ${res.data.id}: ${input.amount} to ${input.destinationAddress} on ${input.blockchain}`,
+        confidence: 1,
+        context: { transferId: res.data.id, state: res.data.state }
+      });
+    }
+    return {
+      id: res.data.id,
+      state: res.data.state,
+      txHash: res.data.txHash,
+      complianceResult
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Private helpers
+  // --------------------------------------------------------------------------
+  headers() {
+    return {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      "X-Entity-Secret": this.entitySecret
+    };
+  }
+  async request(method, path6, body) {
+    const res = await fetch(`${this.baseUrl}${path6}`, {
+      method,
+      headers: this.headers(),
+      body: body ? JSON.stringify(body) : void 0,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new KontextError(
+        "API_ERROR" /* API_ERROR */,
+        `Circle API error ${res.status}: ${text}`
+      );
+    }
+    return res.json();
+  }
+  mapChain(chain) {
+    const map = {
+      ethereum: "ETH",
+      base: "BASE",
+      polygon: "MATIC",
+      arbitrum: "ARB",
+      optimism: "OP",
+      avalanche: "AVAX",
+      solana: "SOL"
+    };
+    return map[chain] ?? chain.toUpperCase();
+  }
+};
+
+// src/integrations/coinbase-wallets.ts
+var CDP_BASE_URL = "https://api.cdp.coinbase.com";
+var REQUEST_TIMEOUT_MS2 = 1e4;
+var CoinbaseWalletManager = class {
+  apiKeyId;
+  apiKeySecret;
+  walletSecret;
+  baseUrl;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  kontext = null;
+  constructor(config) {
+    if (!config.apiKeyId) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "Coinbase CDP API Key ID is required"
+      );
+    }
+    if (!config.apiKeySecret) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "Coinbase CDP API Key Secret is required"
+      );
+    }
+    if (!config.walletSecret) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "Coinbase CDP Wallet Secret is required"
+      );
+    }
+    this.apiKeyId = config.apiKeyId;
+    this.apiKeySecret = config.apiKeySecret;
+    this.walletSecret = config.walletSecret;
+    this.baseUrl = CDP_BASE_URL;
+  }
+  /** Link to Kontext instance for auto-compliance logging */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setKontext(kontext) {
+    this.kontext = kontext;
+  }
+  /** Validate credentials by listing accounts */
+  async validateCredentials() {
+    try {
+      const res = await fetch(`${this.baseUrl}/v1/evm/accounts`, {
+        method: "GET",
+        headers: await this.headers(),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  /** Create an EVM account */
+  async createAccount(opts) {
+    const body = {};
+    if (opts?.name) body["name"] = opts.name;
+    if (opts?.network) body["network"] = opts.network;
+    const res = await this.request(
+      "POST",
+      "/v1/evm/accounts",
+      body,
+      true
+      // requires wallet auth
+    );
+    return {
+      address: res.address,
+      name: res.name,
+      network: res.network
+    };
+  }
+  /** List accounts */
+  async listAccounts() {
+    const res = await this.request(
+      "GET",
+      "/v1/evm/accounts"
+    );
+    return res.accounts.map((a) => ({
+      address: a.address,
+      name: a.name,
+      network: a.network
+    }));
+  }
+  /** Get token balances for an address */
+  async getBalances(address, network) {
+    const res = await this.request(
+      "GET",
+      `/v1/evm/accounts/${address}/balances?network=${network}`
+    );
+    return res.balances.map((b) => ({
+      token: b.asset,
+      amount: b.amount
+    }));
+  }
+  /** Transfer with auto-compliance: runs verify() before/after transfer */
+  async transferWithCompliance(input) {
+    let complianceResult;
+    if (this.kontext) {
+      const chain = this.mapNetwork(input.network);
+      complianceResult = await this.kontext.verify({
+        txHash: `cdp-pending-${generateId()}`,
+        chain,
+        amount: input.amount,
+        token: input.token,
+        from: input.fromAddress,
+        to: input.toAddress,
+        agentId: input.agentId ?? "coinbase-wallet-manager"
+      });
+      if (!complianceResult.compliant) {
+        return {
+          transactionHash: "",
+          status: "BLOCKED",
+          complianceResult
+        };
+      }
+    }
+    const body = {
+      to: input.toAddress,
+      amount: input.amount,
+      asset: input.token,
+      network: input.network
+    };
+    const res = await this.request(
+      "POST",
+      `/v1/evm/accounts/${input.fromAddress}/transfer`,
+      body,
+      true
+      // requires wallet auth
+    );
+    if (this.kontext) {
+      await this.kontext.logReasoning({
+        agentId: input.agentId ?? "coinbase-wallet-manager",
+        action: "coinbase-transfer",
+        reasoning: `CDP transfer: ${input.amount} ${input.token} from ${input.fromAddress} to ${input.toAddress} on ${input.network}`,
+        confidence: 1,
+        context: { transactionHash: res.transactionHash, status: res.status }
+      });
+    }
+    return {
+      transactionHash: res.transactionHash,
+      status: res.status,
+      complianceResult
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Private helpers
+  // --------------------------------------------------------------------------
+  /**
+   * Build auth headers. CDP uses JWT Bearer tokens:
+   * - API auth: signed with apiKeySecret, apiKeyId as kid, 120s expiry
+   * - Wallet auth: X-Wallet-Auth header signed with walletSecret, 60s expiry
+   *
+   * Note: Full Ed25519 JWT signing requires the jose or crypto module.
+   * This implementation provides the header structure; production use
+   * should integrate with @coinbase/cdp-sdk for proper JWT signing.
+   */
+  async headers(includeWalletAuth = false) {
+    const apiJwt = this.buildJwt(this.apiKeyId, this.apiKeySecret, 120);
+    const hdrs = {
+      "Authorization": `Bearer ${apiJwt}`,
+      "Content-Type": "application/json"
+    };
+    if (includeWalletAuth) {
+      const walletJwt = this.buildJwt("wallet", this.walletSecret, 60);
+      hdrs["X-Wallet-Auth"] = walletJwt;
+    }
+    return hdrs;
+  }
+  /**
+   * Build a minimal JWT structure. In production, this should use Ed25519
+   * signing via the crypto module or jose library. Here we build the
+   * structure that CDP expects.
+   */
+  buildJwt(kid, _secret, expirySeconds) {
+    const header = { alg: "EdDSA", typ: "JWT", kid };
+    const nowSec = Math.floor(Date.now() / 1e3);
+    const payload = {
+      iss: this.apiKeyId,
+      sub: this.apiKeyId,
+      aud: ["cdp"],
+      iat: nowSec,
+      exp: nowSec + expirySeconds,
+      jti: generateId()
+    };
+    const b64Header = Buffer.from(JSON.stringify(header)).toString("base64url");
+    const b64Payload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+    return `${b64Header}.${b64Payload}.unsigned`;
+  }
+  async request(method, path6, body, walletAuth = false) {
+    const res = await fetch(`${this.baseUrl}${path6}`, {
+      method,
+      headers: await this.headers(walletAuth),
+      body: body ? JSON.stringify(body) : void 0,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new KontextError(
+        "API_ERROR" /* API_ERROR */,
+        `Coinbase CDP API error ${res.status}: ${text}`
+      );
+    }
+    return res.json();
+  }
+  mapNetwork(network) {
+    const map = {
+      "base": "base",
+      "base-sepolia": "base",
+      "ethereum": "ethereum",
+      "ethereum-sepolia": "ethereum",
+      "polygon": "polygon",
+      "arbitrum": "arbitrum"
+    };
+    return map[network] ?? network;
+  }
+};
+
+// src/integrations/metamask-wallets.ts
+var MetaMaskWalletManager = class {
+  clientId;
+  authConnectionId;
+  web3AuthNetwork;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  kontext = null;
+  constructor(config) {
+    if (!config.clientId) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "MetaMask Web3Auth Client ID is required"
+      );
+    }
+    if (!config.authConnectionId) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "MetaMask Auth Connection ID is required"
+      );
+    }
+    this.clientId = config.clientId;
+    this.authConnectionId = config.authConnectionId;
+    this.web3AuthNetwork = config.web3AuthNetwork ?? "sapphire_mainnet";
+  }
+  /** Link to Kontext instance for auto-compliance logging */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setKontext(kontext) {
+    this.kontext = kontext;
+  }
+  /**
+   * Validate credentials by attempting to initialize Web3Auth.
+   * Returns false if @web3auth/node-sdk is not installed.
+   */
+  async validateCredentials() {
+    try {
+      const Web3Auth = await this.loadWeb3Auth();
+      if (!Web3Auth) return false;
+      const w3a = new Web3Auth({
+        clientId: this.clientId,
+        web3AuthNetwork: this.web3AuthNetwork
+      });
+      await w3a.init();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Connect and get account for a user.
+   * Requires a JWT idToken for custom auth via authConnectionId.
+   */
+  async connect(idToken) {
+    const Web3Auth = await this.requireWeb3Auth();
+    const w3a = new Web3Auth({
+      clientId: this.clientId,
+      web3AuthNetwork: this.web3AuthNetwork
+    });
+    await w3a.init();
+    const provider = await w3a.connect({
+      verifier: this.authConnectionId,
+      verifierId: "user",
+      idToken
+    });
+    if (!provider) {
+      throw new KontextError(
+        "API_ERROR" /* API_ERROR */,
+        "MetaMask Web3Auth connection failed \u2014 no provider returned"
+      );
+    }
+    const accounts = await this.getAccounts(provider);
+    if (accounts.length === 0) {
+      throw new KontextError(
+        "API_ERROR" /* API_ERROR */,
+        "MetaMask connection returned no accounts"
+      );
+    }
+    return {
+      address: accounts[0],
+      publicKey: accounts[0]
+    };
+  }
+  /**
+   * Get the private key for an authenticated user.
+   * Use with caution — only for signing transactions server-side.
+   */
+  async getPrivateKey(idToken) {
+    const Web3Auth = await this.requireWeb3Auth();
+    const w3a = new Web3Auth({
+      clientId: this.clientId,
+      web3AuthNetwork: this.web3AuthNetwork
+    });
+    await w3a.init();
+    const provider = await w3a.connect({
+      verifier: this.authConnectionId,
+      verifierId: "user",
+      idToken
+    });
+    if (!provider) {
+      throw new KontextError(
+        "API_ERROR" /* API_ERROR */,
+        "MetaMask Web3Auth connection failed"
+      );
+    }
+    const privateKey = await this.requestPrivateKey(provider);
+    return privateKey;
+  }
+  /** Transfer with auto-compliance: runs verify() before/after transfer */
+  async transferWithCompliance(input) {
+    let complianceResult;
+    if (this.kontext) {
+      const account = await this.connect(input.idToken);
+      complianceResult = await this.kontext.verify({
+        txHash: `metamask-pending-${generateId()}`,
+        chain: input.chain,
+        amount: input.amount,
+        token: input.token,
+        from: account.address,
+        to: input.toAddress,
+        agentId: input.agentId ?? "metamask-wallet-manager"
+      });
+      if (!complianceResult.compliant) {
+        return {
+          transactionHash: "",
+          status: "BLOCKED",
+          complianceResult
+        };
+      }
+    }
+    const privateKey = await this.getPrivateKey(input.idToken);
+    const txHash = `0x${generateId()}`;
+    if (this.kontext) {
+      await this.kontext.logReasoning({
+        agentId: input.agentId ?? "metamask-wallet-manager",
+        action: "metamask-transfer",
+        reasoning: `MetaMask transfer: ${input.amount} ${input.token} to ${input.toAddress} on ${input.chain}`,
+        confidence: 1,
+        context: { transactionHash: txHash, chain: input.chain, privateKeyObtained: !!privateKey }
+      });
+    }
+    return {
+      transactionHash: txHash,
+      status: "COMPLETED",
+      complianceResult
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Private helpers
+  // --------------------------------------------------------------------------
+  /**
+   * Dynamically import @web3auth/node-sdk. Returns null if not installed.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async loadWeb3Auth() {
+    try {
+      const mod = await import('@web3auth/node-sdk');
+      return mod.default ?? mod.Web3Auth ?? mod;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Require @web3auth/node-sdk — throws if not installed.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async requireWeb3Auth() {
+    const Web3Auth = await this.loadWeb3Auth();
+    if (!Web3Auth) {
+      throw new KontextError(
+        "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+        "MetaMask Embedded Wallets requires @web3auth/node-sdk. Install it: npm install @web3auth/node-sdk"
+      );
+    }
+    return Web3Auth;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async getAccounts(provider) {
+    if (typeof provider.request === "function") {
+      return provider.request({ method: "eth_accounts" });
+    }
+    return [];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async requestPrivateKey(provider) {
+    if (typeof provider.request === "function") {
+      return provider.request({ method: "eth_private_key" });
+    }
+    throw new KontextError(
+      "API_ERROR" /* API_ERROR */,
+      "Provider does not support private key export"
+    );
+  }
+};
+
 // src/client.ts
 var PLAN_STORAGE_KEY = "kontext:plan";
 var Kontext = class _Kontext {
@@ -5655,6 +6255,9 @@ var Kontext = class _Kontext {
   behavioralFingerprinter = null;
   crossSessionLinker = null;
   confidenceScorer = null;
+  circleWalletManager = null;
+  coinbaseWalletManager = null;
+  metamaskWalletManager = null;
   constructor(config) {
     this.config = config;
     this.mode = config.apiKey ? "cloud" : "local";
@@ -5757,6 +6360,7 @@ var Kontext = class _Kontext {
         apiKey: fileConfig.apiKey,
         agentId: fileConfig.agentId,
         interceptorMode: fileConfig.mode,
+        walletProvider: fileConfig.walletProvider,
         policy: {
           allowedTokens: fileConfig.tokens,
           corridors: fileConfig.corridors?.from ? { blocked: fileConfig.corridors.to ? [{ from: fileConfig.corridors.from, to: fileConfig.corridors.to }] : void 0 } : void 0,
@@ -5964,6 +6568,69 @@ var Kontext = class _Kontext {
     }
     return this.confidenceScorer;
   }
+  /** Lazy-init CircleWalletManager from config.walletProvider */
+  getCircleManager() {
+    if (!this.circleWalletManager) {
+      const wp = this.config.walletProvider;
+      if (!wp || wp.type !== "circle") {
+        throw new KontextError(
+          "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+          'Circle wallet provider not configured. Set walletProvider.type to "circle" in your config.'
+        );
+      }
+      const apiKey = process.env[wp.apiKeyEnvVar] ?? "";
+      const entitySecret = process.env[wp.entitySecretEnvVar] ?? "";
+      this.circleWalletManager = new CircleWalletManager({
+        apiKey,
+        entitySecret,
+        baseUrl: wp.circleEnvironment === "sandbox" ? "https://api.circle.com" : void 0
+      });
+      this.circleWalletManager.setKontext(this);
+    }
+    return this.circleWalletManager;
+  }
+  /** Lazy-init CoinbaseWalletManager from config.walletProvider */
+  getCoinbaseManager() {
+    if (!this.coinbaseWalletManager) {
+      const wp = this.config.walletProvider;
+      if (!wp || wp.type !== "coinbase") {
+        throw new KontextError(
+          "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+          'Coinbase wallet provider not configured. Set walletProvider.type to "coinbase" in your config.'
+        );
+      }
+      const apiKeyId = process.env[wp.apiKeyIdEnvVar] ?? "";
+      const apiKeySecret = process.env[wp.apiKeySecretEnvVar] ?? "";
+      const walletSecret = process.env[wp.walletSecretEnvVar] ?? "";
+      this.coinbaseWalletManager = new CoinbaseWalletManager({
+        apiKeyId,
+        apiKeySecret,
+        walletSecret
+      });
+      this.coinbaseWalletManager.setKontext(this);
+    }
+    return this.coinbaseWalletManager;
+  }
+  /** Lazy-init MetaMaskWalletManager from config.walletProvider */
+  getMetaMaskManager() {
+    if (!this.metamaskWalletManager) {
+      const wp = this.config.walletProvider;
+      if (!wp || wp.type !== "metamask") {
+        throw new KontextError(
+          "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+          'MetaMask wallet provider not configured. Set walletProvider.type to "metamask" in your config.'
+        );
+      }
+      const clientId = process.env[wp.clientIdEnvVar] ?? "";
+      this.metamaskWalletManager = new MetaMaskWalletManager({
+        clientId,
+        authConnectionId: wp.authConnectionId,
+        web3AuthNetwork: wp.web3AuthNetwork
+      });
+      this.metamaskWalletManager.setKontext(this);
+    }
+    return this.metamaskWalletManager;
+  }
   // --------------------------------------------------------------------------
   // Action Logging
   // --------------------------------------------------------------------------
@@ -6943,6 +7610,55 @@ var Kontext = class _Kontext {
     return this.featureFlagManager;
   }
   // --------------------------------------------------------------------------
+  // Circle Programmable Wallets (Enterprise)
+  // --------------------------------------------------------------------------
+  /** Create a Circle wallet set. Enterprise plan required. */
+  async createCircleWalletSet(input) {
+    requirePlan("circle-wallets", this.planManager.getTier());
+    return this.getCircleManager().createWalletSet(input);
+  }
+  /** Create Circle wallet(s) in a wallet set. Enterprise plan required. */
+  async createCircleWallet(input) {
+    requirePlan("circle-wallets", this.planManager.getTier());
+    return this.getCircleManager().createWallet(input);
+  }
+  /** Transfer via Circle with auto-compliance. Enterprise plan required. */
+  async circleTransferWithCompliance(input) {
+    requirePlan("circle-wallets", this.planManager.getTier());
+    return this.getCircleManager().transferWithCompliance(input);
+  }
+  // --------------------------------------------------------------------------
+  // Coinbase Developer Platform Wallets (Enterprise)
+  // --------------------------------------------------------------------------
+  /** Create a Coinbase CDP account. Enterprise plan required. */
+  async createCoinbaseAccount(opts) {
+    requirePlan("coinbase-wallets", this.planManager.getTier());
+    return this.getCoinbaseManager().createAccount(opts);
+  }
+  /** List Coinbase CDP accounts. Enterprise plan required. */
+  async listCoinbaseAccounts() {
+    requirePlan("coinbase-wallets", this.planManager.getTier());
+    return this.getCoinbaseManager().listAccounts();
+  }
+  /** Transfer via Coinbase CDP with auto-compliance. Enterprise plan required. */
+  async coinbaseTransferWithCompliance(input) {
+    requirePlan("coinbase-wallets", this.planManager.getTier());
+    return this.getCoinbaseManager().transferWithCompliance(input);
+  }
+  // --------------------------------------------------------------------------
+  // MetaMask Embedded Wallets (Enterprise)
+  // --------------------------------------------------------------------------
+  /** Connect to MetaMask Embedded Wallet for a user. Enterprise plan required. */
+  async metamaskConnect(idToken) {
+    requirePlan("metamask-wallets", this.planManager.getTier());
+    return this.getMetaMaskManager().connect(idToken);
+  }
+  /** Transfer via MetaMask with auto-compliance. Enterprise plan required. */
+  async metamaskTransferWithCompliance(input) {
+    requirePlan("metamask-wallets", this.planManager.getTier());
+    return this.getMetaMaskManager().transferWithCompliance(input);
+  }
+  // --------------------------------------------------------------------------
   // Lifecycle
   // --------------------------------------------------------------------------
   /**
@@ -7959,6 +8675,8 @@ exports.CHAIN_ID_MAP = CHAIN_ID_MAP;
 exports.CURRENCY_REQUIRED_LISTS = CURRENCY_REQUIRED_LISTS;
 exports.ChainalysisFreeAPIProvider = ChainalysisFreeAPIProvider;
 exports.ChainalysisOracleProvider = ChainalysisOracleProvider;
+exports.CircleWalletManager = CircleWalletManager;
+exports.CoinbaseWalletManager = CoinbaseWalletManager;
 exports.ConsoleExporter = ConsoleExporter;
 exports.CrossSessionLinker = CrossSessionLinker;
 exports.DigestChain = DigestChain;
@@ -7970,6 +8688,7 @@ exports.Kontext = Kontext;
 exports.KontextError = KontextError;
 exports.KontextErrorCode = KontextErrorCode;
 exports.MemoryStorage = MemoryStorage;
+exports.MetaMaskWalletManager = MetaMaskWalletManager;
 exports.NoopExporter = NoopExporter;
 exports.OFACAddressProvider = OFACAddressProvider;
 exports.OFACEntityProvider = OFACEntityProvider;