@router402/sdk 0.3.0

package/dist/index.js

@@ -0,0 +1,491 @@
+// src/config.ts
+import { KERNEL_V3_1 } from "@zerodev/sdk/constants";
+
+// src/types.ts
+class SmartAccountError extends Error {
+  type;
+  constructor(type, message) {
+    super(message);
+    this.name = "SmartAccountError";
+    this.type = type;
+  }
+}
+
+// src/config.ts
+var ENTRY_POINT_ADDRESS = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+var DEFAULT_SESSION_KEY_VALIDITY = 365 * 24 * 60 * 60;
+var KERNEL_VERSION = KERNEL_V3_1;
+var DEFAULT_API_BASE_URL = "https://api.router402.xyz";
+function resolveConfig(config) {
+  const chain = config.chain;
+  const chainId = chain?.id;
+  const pimlicoUrl = config.pimlicoApiKey && chainId ? `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${config.pimlicoApiKey}` : undefined;
+  return {
+    chain,
+    chainId,
+    pimlicoApiKey: config.pimlicoApiKey,
+    pimlicoUrl,
+    entryPointVersion: config.entryPointVersion ?? "0.7",
+    sessionKeyValidityPeriod: config.sessionKeyValidityPeriod ?? DEFAULT_SESSION_KEY_VALIDITY,
+    apiBaseUrl: config.apiBaseUrl ?? DEFAULT_API_BASE_URL
+  };
+}
+function validateSmartAccountConfig(config) {
+  if (!config.chain) {
+    throw new SmartAccountError("NOT_CONFIGURED", "Chain is required for smart account operations. Provide `chain` in the configuration.");
+  }
+  if (!config.pimlicoApiKey) {
+    throw new SmartAccountError("NOT_CONFIGURED", "Pimlico API key is required for smart account operations. Provide `pimlicoApiKey` in the configuration.");
+  }
+}
+function validateConfig(_config) {}
+// src/kernel.ts
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import {
+  deserializePermissionAccount,
+  serializePermissionAccount,
+  toPermissionValidator
+} from "@zerodev/permissions";
+import {
+  toSignatureCallerPolicy,
+  toSudoPolicy,
+  toTimestampPolicy
+} from "@zerodev/permissions/policies";
+import { toECDSASigner } from "@zerodev/permissions/signers";
+import { addressToEmptyAccount, createKernelAccount } from "@zerodev/sdk";
+import { getEntryPoint } from "@zerodev/sdk/constants";
+import { createSmartAccountClient } from "permissionless";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import { createPublicClient, http } from "viem";
+import { entryPoint07Address } from "viem/account-abstraction";
+import { privateKeyToAccount } from "viem/accounts";
+function createKernelPublicClient(config) {
+  return createPublicClient({
+    chain: config.chain,
+    transport: http()
+  });
+}
+function createPimlicoPaymasterClient(config) {
+  return createPimlicoClient({
+    chain: config.chain,
+    transport: http(config.pimlicoUrl),
+    entryPoint: {
+      address: entryPoint07Address,
+      version: "0.7"
+    }
+  });
+}
+async function createEcdsaValidator(walletClient, config) {
+  if (!walletClient.account) {
+    throw new SmartAccountError("USER_REJECTED", "Wallet client account is not available.");
+  }
+  const publicClient = createKernelPublicClient(config);
+  const entryPoint = getEntryPoint(config.entryPointVersion);
+  const ownerClient = walletClient;
+  return signerToEcdsaValidator(publicClient, {
+    signer: ownerClient,
+    entryPoint,
+    kernelVersion: KERNEL_VERSION
+  });
+}
+async function createKernelAccountFromWallet(walletClient, config) {
+  const publicClient = createKernelPublicClient(config);
+  const entryPoint = getEntryPoint(config.entryPointVersion);
+  const ecdsaValidator = await createEcdsaValidator(walletClient, config);
+  return createKernelAccount(publicClient, {
+    plugins: {
+      sudo: ecdsaValidator
+    },
+    entryPoint,
+    kernelVersion: KERNEL_VERSION
+  });
+}
+function createKernelSmartAccountClient(account, config) {
+  const pimlicoClient = createPimlicoPaymasterClient(config);
+  return createSmartAccountClient({
+    account,
+    chain: config.chain,
+    bundlerTransport: http(config.pimlicoUrl),
+    paymaster: pimlicoClient,
+    userOperation: {
+      estimateFeesPerGas: async () => {
+        const prices = await pimlicoClient.getUserOperationGasPrice();
+        return prices.fast;
+      }
+    }
+  });
+}
+async function getKernelAccountAddress(walletClient, config) {
+  const account = await createKernelAccountFromWallet(walletClient, config);
+  return account.address;
+}
+async function isKernelAccountDeployed(address, config) {
+  const publicClient = createKernelPublicClient(config);
+  const code = await publicClient.getCode({ address });
+  return code !== undefined && code !== "0x";
+}
+async function createSessionKeyApproval(walletClient, sessionKeyAddress, config, expiresAt, allowedCallers) {
+  const publicClient = createKernelPublicClient(config);
+  const entryPoint = getEntryPoint(config.entryPointVersion);
+  const ecdsaValidator = await createEcdsaValidator(walletClient, config);
+  const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
+  const emptySessionKeySigner = await toECDSASigner({ signer: emptyAccount });
+  const validUntil = Math.floor(expiresAt / 1000);
+  const policies = [
+    toSudoPolicy({}),
+    toTimestampPolicy({ validUntil }),
+    ...allowedCallers && allowedCallers.length > 0 ? [toSignatureCallerPolicy({ allowedCallers })] : []
+  ];
+  const permissionPlugin = await toPermissionValidator(publicClient, {
+    entryPoint,
+    signer: emptySessionKeySigner,
+    policies,
+    kernelVersion: KERNEL_VERSION
+  });
+  const sessionKeyAccount = await createKernelAccount(publicClient, {
+    entryPoint,
+    plugins: {
+      sudo: ecdsaValidator,
+      regular: permissionPlugin
+    },
+    kernelVersion: KERNEL_VERSION
+  });
+  return serializePermissionAccount(sessionKeyAccount);
+}
+async function createKernelClientFromSessionKey(sessionKeyPrivateKey, serializedApproval, config) {
+  const publicClient = createKernelPublicClient(config);
+  const entryPoint = getEntryPoint(config.entryPointVersion);
+  const sessionKeyAccount = privateKeyToAccount(sessionKeyPrivateKey);
+  const sessionKeySigner = await toECDSASigner({
+    signer: sessionKeyAccount
+  });
+  const kernelAccount = await deserializePermissionAccount(publicClient, entryPoint, KERNEL_VERSION, serializedApproval, sessionKeySigner);
+  return createKernelSmartAccountClient(kernelAccount, config);
+}
+// src/sdk.ts
+import { encodeFunctionData, erc20Abi } from "viem";
+
+// src/session-keys.ts
+import { generatePrivateKey, privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+function generateSessionKey(smartAccountAddress, ownerAddress, config) {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount2(privateKey);
+  const now = Date.now();
+  const validityPeriodMs = config.sessionKeyValidityPeriod * 1000;
+  return {
+    privateKey,
+    publicKey: account.address,
+    createdAt: now,
+    expiresAt: now + validityPeriodMs,
+    smartAccountAddress,
+    ownerAddress,
+    isApproved: false
+  };
+}
+function isSessionKeyExpired(sessionKey) {
+  return Date.now() > sessionKey.expiresAt;
+}
+function isSessionKeyValid(sessionKey) {
+  if (!sessionKey)
+    return false;
+  if (isSessionKeyExpired(sessionKey))
+    return false;
+  if (!sessionKey.isApproved || !sessionKey.serializedSessionKey)
+    return false;
+  return true;
+}
+function canUseSessionKey(sessionKey) {
+  return sessionKey.isApproved && !!sessionKey.serializedSessionKey && !isSessionKeyExpired(sessionKey);
+}
+function getSessionKeyRemainingTime(sessionKey) {
+  const remaining = sessionKey.expiresAt - Date.now();
+  return Math.max(0, remaining);
+}
+function getSessionKeyAccount(sessionKey) {
+  return privateKeyToAccount2(sessionKey.privateKey);
+}
+function exportSessionKeyForBackend(sessionKey, chainId) {
+  if (!sessionKey.isApproved || !sessionKey.serializedSessionKey) {
+    return null;
+  }
+  return {
+    privateKey: sessionKey.privateKey,
+    serializedSessionKey: sessionKey.serializedSessionKey,
+    smartAccountAddress: sessionKey.smartAccountAddress,
+    chainId
+  };
+}
+function markSessionKeyApproved(sessionKey, serializedSessionKey) {
+  return {
+    ...sessionKey,
+    isApproved: true,
+    serializedSessionKey
+  };
+}
+
+// src/transactions.ts
+async function sendOwnerTransaction(walletClient, calls, config) {
+  try {
+    const account = await createKernelAccountFromWallet(walletClient, config);
+    const client = createKernelSmartAccountClient(account, config);
+    const userOpHash = await client.sendUserOperation({
+      calls: calls.map((call) => ({
+        to: call.to,
+        data: call.data ?? "0x",
+        value: call.value ?? 0n
+      }))
+    });
+    const receipt = await client.waitForUserOperationReceipt({
+      hash: userOpHash
+    });
+    return {
+      success: true,
+      txHash: receipt.receipt.transactionHash,
+      userOpHash
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function sendSessionKeyTransaction(sessionKeyPrivateKey, serializedApproval, calls, config) {
+  try {
+    const client = await createKernelClientFromSessionKey(sessionKeyPrivateKey, serializedApproval, config);
+    const userOpHash = await client.sendUserOperation({
+      calls: calls.map((call) => ({
+        to: call.to,
+        data: call.data ?? "0x",
+        value: call.value ?? 0n
+      }))
+    });
+    const receipt = await client.waitForUserOperationReceipt({
+      hash: userOpHash
+    });
+    return {
+      success: true,
+      txHash: receipt.receipt.transactionHash,
+      userOpHash
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+// src/sdk.ts
+class Router402Sdk {
+  config;
+  token = null;
+  constructor(userConfig) {
+    this.config = resolveConfig(userConfig);
+    if (userConfig.token) {
+      this.token = userConfig.token;
+    }
+  }
+  requireSmartAccountConfig() {
+    validateSmartAccountConfig(this.config);
+    return this.config;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getChainId() {
+    const config = this.requireSmartAccountConfig();
+    return config.chainId;
+  }
+  async getSmartAccountAddress(walletClient) {
+    const config = this.requireSmartAccountConfig();
+    return getKernelAccountAddress(walletClient, config);
+  }
+  async isSmartAccountDeployed(address) {
+    const config = this.requireSmartAccountConfig();
+    return isKernelAccountDeployed(address, config);
+  }
+  async getSmartAccountInfo(walletClient, eoaAddress) {
+    const config = this.requireSmartAccountConfig();
+    const account = await createKernelAccountFromWallet(walletClient, config);
+    const isDeployed = await account.isDeployed();
+    return {
+      address: account.address,
+      eoaAddress,
+      isDeployed,
+      chainId: config.chainId
+    };
+  }
+  async getSmartAccountBalance(address) {
+    const config = this.requireSmartAccountConfig();
+    const publicClient = createKernelPublicClient(config);
+    return publicClient.getBalance({ address });
+  }
+  async deploySmartAccount(walletClient) {
+    this.requireSmartAccountConfig();
+    const address = await this.getSmartAccountAddress(walletClient);
+    return this.sendOwnerTransaction(walletClient, [
+      { to: address, value: 0n }
+    ]);
+  }
+  async sendOwnerTransaction(walletClient, calls) {
+    const config = this.requireSmartAccountConfig();
+    return sendOwnerTransaction(walletClient, calls, config);
+  }
+  async sendSessionKeyTransaction(sessionKey, calls) {
+    const config = this.requireSmartAccountConfig();
+    if (isSessionKeyExpired(sessionKey)) {
+      throw new SmartAccountError("SESSION_KEY_EXPIRED", "Session key has expired");
+    }
+    if (!sessionKey.isApproved || !sessionKey.serializedSessionKey) {
+      throw new SmartAccountError("SESSION_KEY_NOT_APPROVED", "Session key is not approved or missing serialized data");
+    }
+    return sendSessionKeyTransaction(sessionKey.privateKey, sessionKey.serializedSessionKey, calls, config);
+  }
+  async sendSessionKeyTransactionFromBackend(sessionKeyData, calls) {
+    const config = this.requireSmartAccountConfig();
+    return sendSessionKeyTransaction(sessionKeyData.privateKey, sessionKeyData.serializedSessionKey, calls, config);
+  }
+  generateSessionKey(smartAccountAddress, ownerAddress) {
+    const config = this.requireSmartAccountConfig();
+    return generateSessionKey(smartAccountAddress, ownerAddress, config);
+  }
+  async approveSessionKey(walletClient, sessionKey, allowedCallers) {
+    const config = this.requireSmartAccountConfig();
+    const callers = allowedCallers ?? sessionKey.allowedCallers;
+    const serializedApproval = await createSessionKeyApproval(walletClient, sessionKey.publicKey, config, sessionKey.expiresAt, callers);
+    return {
+      ...markSessionKeyApproved(sessionKey, serializedApproval),
+      allowedCallers: callers
+    };
+  }
+  isSessionKeyValid(sessionKey) {
+    return isSessionKeyValid(sessionKey);
+  }
+  canUseSessionKey(sessionKey) {
+    return canUseSessionKey(sessionKey);
+  }
+  isSessionKeyExpired(sessionKey) {
+    return isSessionKeyExpired(sessionKey);
+  }
+  getSessionKeyRemainingTime(sessionKey) {
+    return getSessionKeyRemainingTime(sessionKey);
+  }
+  exportSessionKeyForBackend(sessionKey) {
+    const config = this.requireSmartAccountConfig();
+    return exportSessionKeyForBackend(sessionKey, config.chainId);
+  }
+  async enableSessionKeyOnChain(sessionKey, usdcAddress, smartAccountAddress) {
+    const config = this.requireSmartAccountConfig();
+    if (!sessionKey.isApproved || !sessionKey.serializedSessionKey) {
+      throw new SmartAccountError("SESSION_KEY_NOT_APPROVED", "Session key must be approved before enabling on-chain");
+    }
+    const approveData = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [smartAccountAddress, BigInt(0)]
+    });
+    return sendSessionKeyTransaction(sessionKey.privateKey, sessionKey.serializedSessionKey, [{ to: usdcAddress, value: BigInt(0), data: approveData }], config);
+  }
+  async setupAccount(walletClient, eoaAddress, options) {
+    this.requireSmartAccountConfig();
+    const { usdcAddress, existingSessionKey, onStatus } = options;
+    onStatus?.("initializing");
+    const info = await this.getSmartAccountInfo(walletClient, eoaAddress);
+    if (!info.isDeployed) {
+      onStatus?.("deploying");
+      const deployResult = await this.deploySmartAccount(walletClient);
+      if (!deployResult.success) {
+        throw new SmartAccountError("DEPLOYMENT_FAILED", "Failed to deploy Smart Account");
+      }
+      info.isDeployed = true;
+    }
+    let sessionKey;
+    if (existingSessionKey && this.canUseSessionKey(existingSessionKey)) {
+      sessionKey = existingSessionKey;
+    } else {
+      onStatus?.("creating_session_key");
+      const newKey = this.generateSessionKey(info.address, eoaAddress);
+      onStatus?.("approving_session_key");
+      sessionKey = await this.approveSessionKey(walletClient, newKey);
+      if (!sessionKey.serializedSessionKey) {
+        throw new SmartAccountError("SESSION_KEY_NOT_APPROVED", "Failed to approve session key");
+      }
+    }
+    onStatus?.("enabling_session_key");
+    const enableResult = await this.enableSessionKeyOnChain(sessionKey, usdcAddress, info.address);
+    if (!enableResult.success) {
+      throw new SmartAccountError("UNKNOWN_ERROR", `Failed to enable session key on-chain: ${enableResult.error}`);
+    }
+    onStatus?.("complete");
+    return { info, sessionKey, enableResult };
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  async chat(prompt, options) {
+    if (!this.token) {
+      throw new SmartAccountError("NOT_CONFIGURED", "JWT token is required. Pass `token` in the constructor or call setToken() before using chat().");
+    }
+    const body = {
+      model: options?.model ?? "anthropic/claude-opus-4.6",
+      messages: [{ role: "user", content: prompt }],
+      ...options?.temperature !== undefined && {
+        temperature: options.temperature
+      },
+      ...options?.max_tokens !== undefined && {
+        max_tokens: options.max_tokens
+      }
+    };
+    const response = await fetch(`${this.config.apiBaseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => null);
+      const error = errorData?.error;
+      const message = error?.message ?? `Chat request failed with status ${response.status}`;
+      throw new SmartAccountError("UNKNOWN_ERROR", message);
+    }
+    const data = await response.json();
+    return data.choices[0].message.content;
+  }
+}
+function createRouter402Sdk(config) {
+  return new Router402Sdk(config);
+}
+export {
+  validateSmartAccountConfig,
+  validateConfig,
+  sendSessionKeyTransaction,
+  sendOwnerTransaction,
+  resolveConfig,
+  markSessionKeyApproved,
+  isSessionKeyValid,
+  isSessionKeyExpired,
+  isKernelAccountDeployed,
+  getSessionKeyRemainingTime,
+  getSessionKeyAccount,
+  getKernelAccountAddress,
+  generateSessionKey,
+  exportSessionKeyForBackend,
+  createSessionKeyApproval,
+  createRouter402Sdk,
+  createPimlicoPaymasterClient,
+  createKernelSmartAccountClient,
+  createKernelPublicClient,
+  createKernelClientFromSessionKey,
+  createKernelAccountFromWallet,
+  createEcdsaValidator,
+  canUseSessionKey,
+  SmartAccountError,
+  Router402Sdk,
+  KERNEL_VERSION,
+  ENTRY_POINT_ADDRESS,
+  DEFAULT_SESSION_KEY_VALIDITY,
+  DEFAULT_API_BASE_URL
+};

package/dist/kernel.d.ts

@@ -0,0 +1,49 @@
+import { createKernelAccount } from "@zerodev/sdk";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import type { Address, Chain, Hex, PublicClient, Transport, WalletClient } from "viem";
+import type { SmartAccountResolvedConfig as ResolvedConfig } from "./types";
+/**
+ * Create a public client for kernel account operations.
+ */
+export declare function createKernelPublicClient(config: ResolvedConfig): PublicClient<Transport, Chain>;
+/**
+ * Create a Pimlico client for bundler and paymaster operations.
+ */
+export declare function createPimlicoPaymasterClient(config: ResolvedConfig): ReturnType<typeof createPimlicoClient>;
+/**
+ * Create an ECDSA validator from a wallet client.
+ */
+export declare function createEcdsaValidator(walletClient: WalletClient, config: ResolvedConfig): Promise<import("@zerodev/sdk").KernelValidator<"ECDSAValidator">>;
+/**
+ * Create a Kernel Smart Account instance from a wallet client (owner).
+ */
+export declare function createKernelAccountFromWallet(walletClient: WalletClient, config: ResolvedConfig): Promise<import("@zerodev/sdk").CreateKernelAccountReturnType<"0.7">>;
+/**
+ * Create a Smart Account Client with Pimlico bundler and paymaster.
+ */
+export declare function createKernelSmartAccountClient<TAccount extends Awaited<ReturnType<typeof createKernelAccount>>>(account: TAccount, config: ResolvedConfig): import("permissionless").SmartAccountClient<import("viem").HttpTransport<undefined, false>, Chain, TAccount, undefined, undefined>;
+/**
+ * Get the Kernel Smart Account address for a wallet.
+ */
+export declare function getKernelAccountAddress(walletClient: WalletClient, config: ResolvedConfig): Promise<Address>;
+/**
+ * Check if the Kernel Smart Account is deployed.
+ */
+export declare function isKernelAccountDeployed(address: Address, config: ResolvedConfig): Promise<boolean>;
+/**
+ * Create a session key approval (serialized permission account).
+ * This creates an approval that the session key holder can use to send transactions.
+ *
+ * @param walletClient - The owner wallet client
+ * @param sessionKeyAddress - The session key's public address
+ * @param config - Resolved SDK configuration
+ * @param expiresAt - Expiry timestamp in milliseconds (enforced on-chain via toTimestampPolicy)
+ * @param allowedCallers - Optional array of addresses allowed to use this session key (enforced on-chain via toSignatureCallerPolicy)
+ */
+export declare function createSessionKeyApproval(walletClient: WalletClient, sessionKeyAddress: Address, config: ResolvedConfig, expiresAt: number, allowedCallers?: Address[]): Promise<string>;
+/**
+ * Deserialize and create a kernel client from a session key.
+ * Used by the backend or frontend to send transactions with the session key.
+ */
+export declare function createKernelClientFromSessionKey(sessionKeyPrivateKey: Hex, serializedApproval: string, config: ResolvedConfig): Promise<import("permissionless").SmartAccountClient<import("viem").HttpTransport<undefined, false>, Chain, import("@zerodev/sdk").CreateKernelAccountReturnType<"0.7">, undefined, undefined>>;
+//# sourceMappingURL=kernel.d.ts.map

package/dist/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../src/kernel.ts"],"names":[],"mappings":"AAYA,OAAO,EAAyB,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAG1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAEV,OAAO,EACP,KAAK,EACL,GAAG,EACH,YAAY,EACZ,SAAS,EACT,YAAY,EACb,MAAM,MAAM,CAAC;AAKd,OAAO,KAAK,EAAE,0BAA0B,IAAI,cAAc,EAAE,MAAM,SAAS,CAAC;AAG5E;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,cAAc,GACrB,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,CAKhC;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,cAAc,GACrB,UAAU,CAAC,OAAO,mBAAmB,CAAC,CASxC;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,cAAc,qEAsBvB;AAED;;GAEG;AACH,wBAAsB,6BAA6B,CACjD,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,cAAc,wEAavB;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,SAAS,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,EAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,sIAe1C;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,OAAO,CAAC,CAGlB;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,OAAO,CAAC,CAIlB;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,YAAY,EAAE,YAAY,EAC1B,iBAAiB,EAAE,OAAO,EAC1B,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,OAAO,EAAE,GACzB,OAAO,CAAC,MAAM,CAAC,CAyCjB;AAED;;;GAGG;AACH,wBAAsB,gCAAgC,CACpD,oBAAoB,EAAE,GAAG,EACzB,kBAAkB,EAAE,MAAM,EAC1B,MAAM,EAAE,cAAc,kMAsBvB"}

package/dist/sdk.d.ts

@@ -0,0 +1,153 @@
+import type { Address, WalletClient } from "viem";
+import type { CallData, ChatOptions, ResolvedConfig, Router402Config, SessionKeyData, SessionKeyForBackend, SetupAccountOptions, SetupAccountResult, SmartAccountInfo, TransactionExecutionResult } from "./types.js";
+/**
+ * Router402 SDK - Main entry point for chat completions and smart account operations
+ *
+ * Usage (chat only):
+ * ```typescript
+ * const sdk = new Router402Sdk({ token: "your-jwt-token" });
+ * const response = await sdk.chat("What is ERC-4337?");
+ * ```
+ *
+ * Usage (with smart accounts):
+ * ```typescript
+ * const sdk = new Router402Sdk({
+ *   chain: baseSepolia,
+ *   pimlicoApiKey: "your-api-key",
+ *   token: "your-jwt-token",
+ * });
+ * ```
+ */
+export declare class Router402Sdk {
+    private config;
+    private token;
+    constructor(userConfig: Router402Config);
+    /**
+     * Ensures chain and pimlicoApiKey are configured.
+     * Returns the config with smart account fields guaranteed.
+     * Throws SmartAccountError if not configured.
+     */
+    private requireSmartAccountConfig;
+    /**
+     * Get the resolved configuration
+     */
+    getConfig(): ResolvedConfig;
+    /**
+     * Get the chain ID (requires chain to be configured)
+     */
+    getChainId(): number;
+    /**
+     * Get the deterministic smart account address for a wallet
+     */
+    getSmartAccountAddress(walletClient: WalletClient): Promise<Address>;
+    /**
+     * Check if a smart account is deployed on-chain
+     */
+    isSmartAccountDeployed(address: Address): Promise<boolean>;
+    /**
+     * Get complete smart account information
+     */
+    getSmartAccountInfo(walletClient: WalletClient, eoaAddress: Address): Promise<SmartAccountInfo>;
+    /**
+     * Get the ETH balance of a smart account
+     */
+    getSmartAccountBalance(address: Address): Promise<bigint>;
+    /**
+     * Deploy a smart account (sends a no-op transaction to trigger deployment)
+     */
+    deploySmartAccount(walletClient: WalletClient): Promise<TransactionExecutionResult>;
+    /**
+     * Send a transaction using the owner wallet
+     */
+    sendOwnerTransaction(walletClient: WalletClient, calls: CallData[]): Promise<TransactionExecutionResult>;
+    /**
+     * Send a transaction using a session key
+     */
+    sendSessionKeyTransaction(sessionKey: SessionKeyData, calls: CallData[]): Promise<TransactionExecutionResult>;
+    /**
+     * Send a transaction using raw session key data (for backend use)
+     */
+    sendSessionKeyTransactionFromBackend(sessionKeyData: SessionKeyForBackend, calls: CallData[]): Promise<TransactionExecutionResult>;
+    /**
+     * Generate a new session key pair
+     */
+    generateSessionKey(smartAccountAddress: Address, ownerAddress: Address): SessionKeyData;
+    /**
+     * Approve a session key (requires owner signature)
+     * Returns the updated session key with approval data.
+     *
+     * The session key's expiresAt is enforced on-chain via toTimestampPolicy.
+     * If allowedCallers are provided (or already set on the session key),
+     * only those addresses can submit transactions with this session key.
+     *
+     * @param walletClient - The owner wallet client
+     * @param sessionKey - The session key to approve
+     * @param allowedCallers - Optional addresses allowed to use this session key (enforced on-chain)
+     */
+    approveSessionKey(walletClient: WalletClient, sessionKey: SessionKeyData, allowedCallers?: Address[]): Promise<SessionKeyData>;
+    /**
+     * Check if a session key is valid and can be used
+     */
+    isSessionKeyValid(sessionKey: SessionKeyData | undefined): boolean;
+    /**
+     * Check if a session key can be used for transactions
+     */
+    canUseSessionKey(sessionKey: SessionKeyData): boolean;
+    /**
+     * Check if a session key is expired
+     */
+    isSessionKeyExpired(sessionKey: SessionKeyData): boolean;
+    /**
+     * Get remaining validity time for a session key in milliseconds
+     */
+    getSessionKeyRemainingTime(sessionKey: SessionKeyData): number;
+    /**
+     * Export session key data for backend use
+     */
+    exportSessionKeyForBackend(sessionKey: SessionKeyData): SessionKeyForBackend | null;
+    /**
+     * Enable a session key on-chain by sending a dummy ERC20 approve transaction.
+     * The first UserOp through `sendSessionKeyTransaction` activates the
+     * permission validator module on-chain via the `enableSignature` mechanism.
+     *
+     * @param sessionKey - An approved session key with serializedSessionKey
+     * @param usdcAddress - The USDC contract address on the target chain
+     * @param smartAccountAddress - The smart account address (used as the spender in the dummy approve)
+     */
+    enableSessionKeyOnChain(sessionKey: SessionKeyData, usdcAddress: Address, smartAccountAddress: Address): Promise<TransactionExecutionResult>;
+    /**
+     * Full account setup flow: get info → deploy → generate session key → approve → enable on-chain.
+     *
+     * This method orchestrates all the steps needed to set up a smart account with a session key.
+     * It does NOT handle storage or backend authorization — those are app-specific concerns.
+     *
+     * @param walletClient - The owner wallet client
+     * @param eoaAddress - The owner EOA address
+     * @param options - Setup options including USDC address and optional callbacks
+     */
+    setupAccount(walletClient: WalletClient, eoaAddress: Address, options: SetupAccountOptions): Promise<SetupAccountResult>;
+    /**
+     * Set the JWT token for authenticated API requests
+     */
+    setToken(token: string): void;
+    /**
+     * Send a chat completion request to the Router402 API.
+     *
+     * @param prompt - The user message to send
+     * @param options - Optional model, temperature, and max_tokens overrides
+     * @returns The assistant's response content
+     *
+     * @example
+     * ```typescript
+     * sdk.setToken(jwtToken);
+     * const response = await sdk.chat("What is ERC-4337?");
+     * console.log(response);
+     * ```
+     */
+    chat(prompt: string, options?: ChatOptions): Promise<string>;
+}
+/**
+ * Create a new Router402Sdk instance
+ */
+export declare function createRouter402Sdk(config: Router402Config): Router402Sdk;
+//# sourceMappingURL=sdk.d.ts.map