@silkysquad/silk 1.0.0

package/src/commands/pay.ts

@@ -0,0 +1,41 @@
+import { Keypair, Transaction } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { loadConfig, getWallet, getApiUrl, getClaimUrl } from '../config.js';
+import { createHttpClient } from '../client.js';
+import { outputSuccess } from '../output.js';
+import { validatePay } from '../validate.js';
+import { resolveRecipient } from '../contacts.js';
+
+export async function pay(recipient: string, amount: string, opts: { memo?: string; wallet?: string }) {
+  recipient = resolveRecipient(recipient);
+  const config = loadConfig();
+  const wallet = getWallet(config, opts.wallet);
+  const client = createHttpClient({ baseUrl: getApiUrl(config) });
+
+  const amountNum = await validatePay(client, recipient, amount, wallet.address);
+
+  // 1. Build unsigned transaction
+  const buildRes = await client.post('/api/tx/create-transfer', {
+    sender: wallet.address,
+    recipient,
+    amount: amountNum,
+    token: 'usdc',
+    memo: opts.memo || '',
+  });
+
+  const { transaction: txBase64, transferPda } = buildRes.data.data;
+
+  // 2. Sign the transaction
+  const tx = Transaction.from(Buffer.from(txBase64, 'base64'));
+  const keypair = Keypair.fromSecretKey(bs58.decode(wallet.privateKey));
+  tx.sign(keypair);
+
+  // 3. Submit signed transaction
+  const submitRes = await client.post('/api/tx/submit', {
+    signedTx: tx.serialize().toString('base64'),
+  });
+
+  const { txid } = submitRes.data.data;
+  const claimUrl = getClaimUrl(config, transferPda);
+  outputSuccess({ action: 'pay', transferPda, txid, amount: amountNum, recipient, claimUrl });
+}

package/src/commands/payments.ts

@@ -0,0 +1,29 @@
+import { loadConfig, getWallet, getApiUrl } from '../config.js';
+import { createHttpClient } from '../client.js';
+import { SdkError } from '../errors.js';
+import { outputSuccess } from '../output.js';
+
+export async function paymentsList(opts: { wallet?: string }) {
+  const config = loadConfig();
+  const wallet = getWallet(config, opts.wallet);
+  const client = createHttpClient({ baseUrl: getApiUrl(config) });
+
+  const res = await client.get(`/api/transfers`, { params: { wallet: wallet.address } });
+  const transfers = res.data.data.transfers;
+
+  outputSuccess({ transfers });
+}
+
+export async function paymentsGet(transferPda: string) {
+  const config = loadConfig();
+  const client = createHttpClient({ baseUrl: getApiUrl(config) });
+
+  const res = await client.get(`/api/transfers/${transferPda}`);
+  const transfer = res.data.data.transfer;
+
+  if (!transfer) {
+    throw new SdkError('TRANSFER_NOT_FOUND', `Transfer not found: ${transferPda}`);
+  }
+
+  outputSuccess({ transfer });
+}

package/src/commands/wallet.ts

@@ -0,0 +1,67 @@
+import { Keypair } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { loadConfig, saveConfig, getWallet, getApiUrl } from '../config.js';
+import { createHttpClient } from '../client.js';
+import { SdkError } from '../errors.js';
+import { outputSuccess } from '../output.js';
+
+export async function walletCreate(label: string) {
+  const config = loadConfig();
+
+  if (config.wallets.find((w) => w.label === label)) {
+    throw new SdkError('WALLET_EXISTS', `Wallet "${label}" already exists.`);
+  }
+
+  const keypair = Keypair.generate();
+  const address = keypair.publicKey.toBase58();
+  const privateKey = bs58.encode(keypair.secretKey);
+
+  config.wallets.push({ label, address, privateKey });
+  if (config.wallets.length === 1) {
+    config.defaultWallet = label;
+  }
+
+  saveConfig(config);
+  outputSuccess({ action: 'wallet_created', label, address });
+}
+
+export async function walletList() {
+  const config = loadConfig();
+  const wallets = config.wallets.map((w) => ({
+    label: w.label,
+    address: w.address,
+    default: w.label === config.defaultWallet,
+  }));
+  outputSuccess({ wallets });
+}
+
+export async function walletFund(opts: { sol?: boolean; usdc?: boolean; wallet?: string }) {
+  const config = loadConfig();
+  const wallet = getWallet(config, opts.wallet);
+  const client = createHttpClient({ baseUrl: getApiUrl(config) });
+
+  const doSol = opts.sol || (!opts.sol && !opts.usdc);
+  const doUsdc = opts.usdc || (!opts.sol && !opts.usdc);
+
+  // Determine the token parameter for a single API call
+  let token: string;
+  if (doSol && doUsdc) {
+    token = 'both';
+  } else if (doSol) {
+    token = 'sol';
+  } else {
+    token = 'usdc';
+  }
+
+  const funded: Record<string, unknown> = {};
+
+  try {
+    const res = await client.post('/api/tx/faucet', { wallet: wallet.address, token });
+    if (res.data.data.sol) funded.sol = res.data.data.sol;
+    if (res.data.data.usdc) funded.usdc = res.data.data.usdc;
+  } catch (e: any) {
+    funded.error = { code: e.code || 'FAUCET_FAILED', message: e.message };
+  }
+
+  outputSuccess({ action: 'wallet_funded', wallet: wallet.label, address: wallet.address, funded });
+}

package/src/config.ts

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { SdkError } from './errors.js';
+
+export const CONFIG_DIR = path.join(os.homedir(), '.config', 'silk');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export interface WalletEntry {
+  label: string;
+  address: string;
+  privateKey: string;
+}
+
+export interface AccountInfo {
+  pda: string;
+  owner: string;
+  mint: string;
+  mintDecimals: number;
+  operatorIndex: number;
+  perTxLimit: number;
+  syncedAt: string;
+}
+
+export type SolanaCluster = 'mainnet-beta' | 'devnet';
+
+export interface SilkConfig {
+  wallets: WalletEntry[];
+  defaultWallet: string;
+  preferences: Record<string, unknown>;
+  apiUrl?: string;
+  cluster?: SolanaCluster;
+  account?: AccountInfo;
+  agentId?: string;
+}
+
+function defaultConfig(): SilkConfig {
+  return { wallets: [], defaultWallet: 'main', preferences: {}, cluster: 'mainnet-beta' };
+}
+
+export function loadConfig(): SilkConfig {
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(raw) as SilkConfig;
+  } catch {
+    return defaultConfig();
+  }
+}
+
+export function saveConfig(config: SilkConfig): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export function getWallet(config: SilkConfig, label?: string): WalletEntry {
+  const target = label || config.defaultWallet;
+  const wallet = config.wallets.find((w) => w.label === target);
+  if (!wallet) {
+    throw new SdkError('WALLET_NOT_FOUND', `Wallet "${target}" not found. Run: silk wallet create`);
+  }
+  return wallet;
+}
+
+const CLUSTER_API_URLS: Record<SolanaCluster, string> = {
+  'mainnet-beta': 'https://api.silkyway.ai',
+  'devnet': 'https://devnet-api.silkyway.ai',
+};
+
+export function getCluster(config: SilkConfig): SolanaCluster {
+  return config.cluster || 'mainnet-beta';
+}
+
+export function getApiUrl(config: SilkConfig): string {
+  return config.apiUrl || process.env.SILK_API_URL || CLUSTER_API_URLS[getCluster(config)];
+}
+
+export function ensureAgentId(config: SilkConfig): { agentId: string; created: boolean } {
+  if (config.agentId) {
+    return { agentId: config.agentId, created: false };
+  }
+  const agentId = randomUUID();
+  config.agentId = agentId;
+  return { agentId, created: true };
+}
+
+const APP_BASE_URL = 'https://app.silkyway.so';
+
+export function getClaimUrl(config: SilkConfig, transferPda: string): string {
+  const base = `${APP_BASE_URL}/transfers/${transferPda}`;
+  const cluster = getCluster(config);
+  return cluster === 'devnet' ? `${base}?cluster=devnet` : base;
+}
+
+export function getAgentId(config: SilkConfig): string {
+  const result = ensureAgentId(config);
+  if (result.created) {
+    saveConfig(config);
+  }
+  return result.agentId;
+}

package/src/contacts.ts

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PublicKey } from '@solana/web3.js';
+import { CONFIG_DIR } from './config.js';
+import { SdkError } from './errors.js';
+
+const CONTACTS_FILE = path.join(CONFIG_DIR, 'contacts.json');
+
+export interface Contact {
+  name: string;
+  address: string;
+}
+
+export interface ContactsStore {
+  contacts: Contact[];
+}
+
+export function loadContacts(): ContactsStore {
+  try {
+    const raw = fs.readFileSync(CONTACTS_FILE, 'utf-8');
+    return JSON.parse(raw) as ContactsStore;
+  } catch {
+    return { contacts: [] };
+  }
+}
+
+export function saveContacts(store: ContactsStore): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONTACTS_FILE, JSON.stringify(store, null, 2), 'utf-8');
+}
+
+function isValidSolanaAddress(address: string): boolean {
+  try {
+    new PublicKey(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function addContact(name: string, address: string): void {
+  const normalized = name.toLowerCase();
+
+  if (isValidSolanaAddress(normalized)) {
+    throw new SdkError('INVALID_CONTACT_NAME', 'Contact name cannot be a valid Solana address');
+  }
+
+  if (!isValidSolanaAddress(address)) {
+    throw new SdkError('INVALID_ADDRESS', `"${address}" is not a valid Solana address`);
+  }
+
+  const store = loadContacts();
+  const existing = store.contacts.find((c) => c.name === normalized);
+  if (existing) {
+    throw new SdkError('CONTACT_EXISTS', `Contact "${normalized}" already exists (${existing.address})`);
+  }
+
+  store.contacts.push({ name: normalized, address });
+  saveContacts(store);
+}
+
+export function removeContact(name: string): void {
+  const normalized = name.toLowerCase();
+  const store = loadContacts();
+  const index = store.contacts.findIndex((c) => c.name === normalized);
+  if (index === -1) {
+    throw new SdkError('CONTACT_NOT_FOUND', `Contact "${normalized}" not found`);
+  }
+  store.contacts.splice(index, 1);
+  saveContacts(store);
+}
+
+export function getContact(name: string): Contact | null {
+  const normalized = name.toLowerCase();
+  const store = loadContacts();
+  return store.contacts.find((c) => c.name === normalized) || null;
+}
+
+export function listContacts(): Contact[] {
+  return loadContacts().contacts;
+}
+
+export function resolveRecipient(recipient: string): string {
+  const contact = getContact(recipient);
+  return contact ? contact.address : recipient;
+}
+
+export function initContacts(): boolean {
+  if (fs.existsSync(CONTACTS_FILE)) {
+    return false;
+  }
+  saveContacts({ contacts: [] });
+  return true;
+}

package/src/errors.ts

@@ -0,0 +1,95 @@
+export class SdkError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'SdkError';
+  }
+}
+
+export const ANCHOR_ERROR_MAP: Record<number, { code: string; message: string }> = {
+  6000: { code: 'ANCHOR_MATH_OVERFLOW', message: 'Mathematical overflow occurred' },
+  6001: { code: 'ANCHOR_TRANSFER_NOT_ACTIVE', message: 'Transfer is not in active status' },
+  6002: { code: 'ANCHOR_CANNOT_CLAIM', message: 'Claim deadline has passed' },
+  6003: { code: 'ANCHOR_CONDITIONS_NOT_MET', message: 'Release conditions not met' },
+  6004: { code: 'ANCHOR_INVALID_CONDITION', message: 'Invalid condition parameters' },
+  6005: { code: 'ANCHOR_INSUFFICIENT_FUNDS', message: 'Insufficient funds in vault' },
+  6006: { code: 'ANCHOR_POOL_PAUSED', message: 'Pool is paused' },
+  6007: { code: 'ANCHOR_UNAUTHORIZED', message: 'Unauthorized action' },
+  6008: { code: 'ANCHOR_INVALID_TIME_WINDOW', message: 'Invalid time window' },
+  6009: { code: 'ANCHOR_DEPOSIT_TOO_SMALL', message: 'Deposit amount too small' },
+  6010: { code: 'ANCHOR_INVALID_FEE_CONFIG', message: 'Invalid fee configuration' },
+  6011: { code: 'ANCHOR_INVALID_TRANSFER_FEE', message: 'Invalid transfer fee' },
+  6012: { code: 'ANCHOR_TRANSFER_ALREADY_CLAIMED', message: 'Transfer already claimed' },
+  6013: { code: 'ANCHOR_TRANSFER_ALREADY_CANCELLED', message: 'Transfer already cancelled' },
+  6014: { code: 'ANCHOR_TRANSFER_ALREADY_REJECTED', message: 'Transfer already rejected' },
+  6015: { code: 'ANCHOR_TRANSFER_EXPIRED', message: 'Transfer is expired' },
+  6016: { code: 'ANCHOR_ONLY_SENDER_CAN_CANCEL', message: 'Only sender can cancel transfer' },
+  6017: { code: 'ANCHOR_ONLY_RECIPIENT_CAN_CLAIM', message: 'Only recipient can claim transfer' },
+  6018: { code: 'ANCHOR_ONLY_OPERATOR_CAN_REJECT', message: 'Only operator can reject transfer' },
+  6019: { code: 'ANCHOR_INVALID_MEMO_LENGTH', message: 'Invalid memo length' },
+  6020: { code: 'ANCHOR_CLAIM_DEADLINE_NOT_PASSED', message: 'Claim deadline has not passed' },
+  6021: { code: 'ANCHOR_CALCULATION_ERROR', message: 'Calculation error' },
+  6022: { code: 'ANCHOR_MISSING_ACCOUNT', message: 'Missing required account' },
+  6023: { code: 'ANCHOR_INVALID_MINT', message: 'Invalid mint' },
+  6024: { code: 'ANCHOR_STALE_POOL_VALUE', message: 'Pool value is stale and must be updated' },
+  6025: { code: 'ANCHOR_INVALID_OPERATION', message: 'Invalid operation for this pool type' },
+  6026: { code: 'ANCHOR_OUTSTANDING_TRANSFERS', message: 'Cannot reset pool with outstanding transfers' },
+  6027: { code: 'ANCHOR_INVALID_TRANSFER', message: 'Invalid transfer' },
+  6028: { code: 'ANCHOR_TRANSFER_ALREADY_DECLINED', message: 'Transfer already declined' },
+  6029: { code: 'ANCHOR_ONLY_RECIPIENT_CAN_DECLINE', message: 'Only recipient can decline transfer' },
+};
+
+export const SILKYSIG_ERROR_MAP: Record<number, { code: string; message: string }> = {
+  6000: { code: 'POLICY_UNAUTHORIZED', message: 'Unauthorized: signer is not owner or operator' },
+  6001: { code: 'POLICY_EXCEEDS_TX_LIMIT', message: 'Transfer exceeds operator per-transaction limit' },
+  6002: { code: 'ACCOUNT_PAUSED', message: 'Account is paused' },
+  6003: { code: 'MAX_OPERATORS', message: 'Maximum operators reached' },
+  6004: { code: 'OPERATOR_NOT_FOUND', message: 'Operator not found' },
+  6005: { code: 'OPERATOR_EXISTS', message: 'Operator slot already occupied' },
+  6006: { code: 'MATH_OVERFLOW', message: 'Mathematical overflow' },
+  6007: { code: 'AMOUNT_MUST_BE_POSITIVE', message: 'Amount must be positive' },
+  6008: { code: 'DRIFT_USER_ALREADY_INITIALIZED', message: 'Drift user already initialized' },
+  6009: { code: 'DRIFT_DEPOSIT_FAILED', message: 'Drift deposit failed' },
+  6010: { code: 'DRIFT_WITHDRAW_FAILED', message: 'Drift withdrawal failed' },
+  6011: { code: 'INVALID_DRIFT_USER', message: 'Invalid Drift user account' },
+  6012: { code: 'MISSING_DRIFT_ACCOUNTS', message: 'Missing required Drift accounts' },
+  6013: { code: 'INVALID_DRIFT_PROGRAM', message: 'Invalid Drift program ID' },
+  6014: { code: 'DRIFT_DELETE_USER_FAILED', message: 'Failed to delete Drift user' },
+};
+
+export function toSilkysigError(err: unknown): SdkError {
+  if (err instanceof SdkError) return err;
+
+  const message = err instanceof Error ? err.message : String(err);
+
+  const hexMatch = message.match(/0x([0-9a-fA-F]+)/);
+  if (hexMatch) {
+    const errorCode = parseInt(hexMatch[1], 16);
+    const mapped = SILKYSIG_ERROR_MAP[errorCode];
+    if (mapped) {
+      return new SdkError(mapped.code, mapped.message);
+    }
+  }
+
+  return new SdkError('UNKNOWN_ERROR', message);
+}
+
+export function toSdkError(err: unknown): SdkError {
+  if (err instanceof SdkError) return err;
+
+  const message = err instanceof Error ? err.message : String(err);
+
+  // Parse Anchor hex error codes from simulation messages (e.g. "0x1770")
+  const hexMatch = message.match(/0x([0-9a-fA-F]+)/);
+  if (hexMatch) {
+    const errorCode = parseInt(hexMatch[1], 16);
+    const anchor = ANCHOR_ERROR_MAP[errorCode];
+    if (anchor) {
+      return new SdkError(anchor.code, anchor.message);
+    }
+  }
+
+  return new SdkError('UNKNOWN_ERROR', message);
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export { loadConfig, saveConfig, getWallet, getApiUrl, CONFIG_DIR } from './config.js';
+export type { SilkConfig, WalletEntry } from './config.js';
+export { loadContacts, saveContacts, addContact, removeContact, getContact, listContacts, resolveRecipient, initContacts } from './contacts.js';
+export type { Contact, ContactsStore } from './contacts.js';
+export { createHttpClient } from './client.js';
+export type { ClientConfig } from './client.js';
+export { getTransfer } from './transfers.js';
+export type { TransferInfo, TokenInfo, PoolInfo } from './transfers.js';
+export { SdkError, ANCHOR_ERROR_MAP, toSdkError } from './errors.js';
+export { outputSuccess, outputError, wrapCommand } from './output.js';
+export { validateAddress, validateAmount, fetchTransfer, validateClaim, validateCancel, validatePay } from './validate.js';

package/src/output.ts

@@ -0,0 +1,42 @@
+import { SdkError, toSdkError } from './errors.js';
+
+function isHuman(): boolean {
+  return process.argv.includes('--human');
+}
+
+export function outputSuccess(data: Record<string, unknown>): void {
+  if (isHuman()) {
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value === 'object' && value !== null) {
+        console.log(`${key}:`);
+        for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+          console.log(`  ${k}: ${typeof v === 'object' ? JSON.stringify(v) : v}`);
+        }
+      } else {
+        console.log(`${key}: ${value}`);
+      }
+    }
+    return;
+  }
+  console.log(JSON.stringify({ ok: true, data }));
+}
+
+export function outputError(err: SdkError): never {
+  if (isHuman()) {
+    console.log(`Error [${err.code}]: ${err.message}`);
+  } else {
+    console.log(JSON.stringify({ ok: false, error: err.code, message: err.message }));
+  }
+  process.exit(1);
+}
+
+export function wrapCommand<T extends (...args: any[]) => Promise<void>>(fn: T): T {
+  const wrapped = async (...args: any[]) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      outputError(toSdkError(err));
+    }
+  };
+  return wrapped as unknown as T;
+}

package/src/transfers.ts

@@ -0,0 +1,49 @@
+import { AxiosInstance } from 'axios';
+import { createHttpClient, ClientConfig } from './client.js';
+import { SdkError } from './errors.js';
+
+export interface TokenInfo {
+  mint: string;
+  name: string;
+  symbol: string;
+  decimals: number;
+}
+
+export interface PoolInfo {
+  poolPda: string;
+  poolId: string;
+  operatorKey: string;
+  feeBps: number;
+}
+
+export interface TransferInfo {
+  transferPda: string;
+  sender: string;
+  recipient: string;
+  amount: string;
+  amountRaw: string;
+  status: string;
+  memo?: string;
+  token: TokenInfo;
+  pool: PoolInfo;
+  createTxid: string;
+  claimTxid?: string;
+  cancelTxid?: string;
+  claimableAfter?: string;
+  claimableUntil?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export async function getTransfer(
+  transferPda: string,
+  config?: ClientConfig,
+): Promise<TransferInfo> {
+  const client = createHttpClient(config);
+  const res = await client.get(`/api/transfers/${transferPda}`);
+  const transfer = res.data.data.transfer;
+  if (!transfer) {
+    throw new SdkError('TRANSFER_NOT_FOUND', `Transfer not found: ${transferPda}`);
+  }
+  return transfer as TransferInfo;
+}

package/src/validate.ts

@@ -0,0 +1,80 @@
+import { PublicKey } from '@solana/web3.js';
+import { AxiosInstance } from 'axios';
+import { SdkError } from './errors.js';
+import { TransferInfo } from './transfers.js';
+
+export function validateAddress(address: string, field: string): void {
+  try {
+    new PublicKey(address);
+  } catch {
+    throw new SdkError('INVALID_ADDRESS', `Invalid ${field} address: ${address}`);
+  }
+}
+
+export function validateAmount(amount: string): number {
+  const num = parseFloat(amount);
+  if (isNaN(num) || num <= 0) {
+    throw new SdkError('INVALID_AMOUNT', `Amount must be a positive number, got: ${amount}`);
+  }
+  return num;
+}
+
+export async function fetchTransfer(client: AxiosInstance, transferPda: string): Promise<TransferInfo> {
+  const res = await client.get(`/api/transfers/${transferPda}`);
+  const transfer = res.data?.data?.transfer;
+  if (!transfer) {
+    throw new SdkError('TRANSFER_NOT_FOUND', `Transfer not found: ${transferPda}`);
+  }
+  return transfer as TransferInfo;
+}
+
+export async function validateClaim(client: AxiosInstance, transferPda: string, claimerAddress: string): Promise<void> {
+  const transfer = await fetchTransfer(client, transferPda);
+
+  if (transfer.status !== 'ACTIVE') {
+    throw new SdkError('TRANSFER_NOT_ACTIVE', `Transfer is ${transfer.status}, not ACTIVE`);
+  }
+
+  if (transfer.recipient !== claimerAddress) {
+    throw new SdkError('NOT_RECIPIENT', `Wallet ${claimerAddress} is not the recipient. Recipient is ${transfer.recipient}`);
+  }
+
+  const now = Date.now();
+  if (transfer.claimableAfter && now < new Date(transfer.claimableAfter).getTime()) {
+    throw new SdkError('CLAIM_WINDOW_NOT_OPEN', `Claim window opens at ${transfer.claimableAfter}`);
+  }
+  if (transfer.claimableUntil && now > new Date(transfer.claimableUntil).getTime()) {
+    throw new SdkError('CLAIM_WINDOW_CLOSED', `Claim window closed at ${transfer.claimableUntil}`);
+  }
+}
+
+export async function validateCancel(client: AxiosInstance, transferPda: string, cancellerAddress: string): Promise<void> {
+  const transfer = await fetchTransfer(client, transferPda);
+
+  if (transfer.status !== 'ACTIVE') {
+    throw new SdkError('TRANSFER_NOT_ACTIVE', `Transfer is ${transfer.status}, not ACTIVE`);
+  }
+
+  if (transfer.sender !== cancellerAddress) {
+    throw new SdkError('NOT_SENDER', `Wallet ${cancellerAddress} is not the sender. Sender is ${transfer.sender}`);
+  }
+}
+
+export async function validatePay(client: AxiosInstance, recipient: string, amount: string, senderAddress: string): Promise<number> {
+  validateAddress(recipient, 'recipient');
+  const amountNum = validateAmount(amount);
+
+  try {
+    const res = await client.get(`/api/wallet/${senderAddress}/balance`);
+    const tokens = res.data?.data?.tokens || [];
+    const usdc = tokens.find((t: any) => t.symbol === 'USDC');
+    if (usdc && parseFloat(usdc.balance) < amountNum) {
+      throw new SdkError('INSUFFICIENT_BALANCE', `Insufficient USDC balance: ${usdc.balance} < ${amountNum}`);
+    }
+  } catch (err) {
+    if (err instanceof SdkError) throw err;
+    // Balance check is best-effort; don't fail if the API is unreachable
+  }
+
+  return amountNum;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}