@shuffle-protocol/sdk 0.1.0

package/dist/cli/config.d.ts

@@ -0,0 +1,50 @@
+/**
+ * CLI Configuration Management
+ *
+ * Handles loading Solana wallet from CLI config, network selection,
+ * and encryption keypair management.
+ */
+import { Connection } from "@solana/web3.js";
+import * as anchor from "@coral-xyz/anchor";
+import { ShuffleClient } from "../client";
+export interface CLIConfig {
+    network: "devnet" | "localnet";
+    connection: Connection;
+    wallet: anchor.Wallet;
+    keypairPath: string;
+    mockMode: boolean;
+    shuffleClient: ShuffleClient | null;
+    encryptionPrivateKey: Uint8Array;
+    userProfile?: string;
+}
+/**
+ * Load saved config from ~/.shuffle/config.json
+ */
+export declare function loadSavedConfig(): {
+    network?: "devnet" | "localnet";
+};
+/**
+ * Save config to ~/.shuffle/config.json
+ */
+export declare function saveConfig(key: string, value: string): void;
+/**
+ * Get a saved config value
+ */
+export declare function getSavedConfig(key: string): string | undefined;
+/**
+ * Initialize CLI configuration
+ */
+export declare function loadConfig(opts: {
+    network?: string;
+    keypair?: string;
+    mock?: boolean;
+    user?: string;
+}): Promise<CLIConfig>;
+/**
+ * Get current config (must call loadConfig first)
+ */
+export declare function getConfig(): CLIConfig;
+/**
+ * Get CLI version from package.json
+ */
+export declare function getVersion(): string;

package/dist/cli/config.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * CLI Configuration Management
+ *
+ * Handles loading Solana wallet from CLI config, network selection,
+ * and encryption keypair management.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSavedConfig = loadSavedConfig;
+exports.saveConfig = saveConfig;
+exports.getSavedConfig = getSavedConfig;
+exports.loadConfig = loadConfig;
+exports.getConfig = getConfig;
+exports.getVersion = getVersion;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const web3_js_1 = require("@solana/web3.js");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const client_1 = require("../client");
+const devnet_1 = require("./devnet");
+const encryption_1 = require("../encryption");
+let config = null;
+/**
+ * Get the base shuffle directory
+ */
+function getShuffleDir() {
+    return path.join(os.homedir(), ".shuffle");
+}
+/**
+ * Get the directory for a user profile (null = default user)
+ */
+function getUserDir(profile) {
+    const shuffleDir = getShuffleDir();
+    if (!profile || profile === "default") {
+        return shuffleDir;
+    }
+    return path.join(shuffleDir, "users", profile);
+}
+/**
+ * Load Solana keypair from profile or custom path
+ */
+function loadKeypair(customPath, profile) {
+    // Try custom path first
+    if (customPath && fs.existsSync(customPath)) {
+        const raw = JSON.parse(fs.readFileSync(customPath, "utf-8"));
+        return { keypair: web3_js_1.Keypair.fromSecretKey(Uint8Array.from(raw)), path: customPath };
+    }
+    // For named profiles, use profile-specific keypair
+    if (profile && profile !== "default") {
+        const userDir = getUserDir(profile);
+        const profileKeypairPath = path.join(userDir, "keypair.json");
+        if (fs.existsSync(profileKeypairPath)) {
+            const raw = JSON.parse(fs.readFileSync(profileKeypairPath, "utf-8"));
+            return { keypair: web3_js_1.Keypair.fromSecretKey(Uint8Array.from(raw)), path: profileKeypairPath };
+        }
+        // Create new keypair for this profile
+        if (!fs.existsSync(userDir)) {
+            fs.mkdirSync(userDir, { recursive: true });
+        }
+        const newKeypair = web3_js_1.Keypair.generate();
+        fs.writeFileSync(profileKeypairPath, JSON.stringify(Array.from(newKeypair.secretKey)));
+        console.log(`Created new keypair for profile '${profile}': ${newKeypair.publicKey.toBase58()}`);
+        return { keypair: newKeypair, path: profileKeypairPath };
+    }
+    // Try Solana CLI default path
+    const defaultPath = path.join(os.homedir(), ".config", "solana", "id.json");
+    if (fs.existsSync(defaultPath)) {
+        const raw = JSON.parse(fs.readFileSync(defaultPath, "utf-8"));
+        return { keypair: web3_js_1.Keypair.fromSecretKey(Uint8Array.from(raw)), path: defaultPath };
+    }
+    throw new Error("No Solana keypair found!\n" +
+        "Run: solana-keygen new\n" +
+        "Or specify: shuffle --keypair /path/to/keypair.json <command>");
+}
+/**
+ * Load or create encryption keypair (profile-specific if profile is set)
+ */
+function loadOrCreateEncryptionKey(profile) {
+    const userDir = getUserDir(profile);
+    const encryptionPath = path.join(userDir, "encryption.json");
+    if (fs.existsSync(encryptionPath)) {
+        const raw = JSON.parse(fs.readFileSync(encryptionPath, "utf-8"));
+        return Uint8Array.from(raw.privateKey);
+    }
+    // Create new keypair
+    const keypair = (0, encryption_1.generateEncryptionKeypair)();
+    if (!fs.existsSync(userDir)) {
+        fs.mkdirSync(userDir, { recursive: true });
+    }
+    fs.writeFileSync(encryptionPath, JSON.stringify({
+        privateKey: Array.from(keypair.privateKey),
+        publicKey: Array.from(keypair.publicKey),
+    }));
+    return keypair.privateKey;
+}
+/**
+ * Get RPC URL for network
+ */
+function getRpcUrl(network) {
+    if (network === "localnet") {
+        return "http://127.0.0.1:8899";
+    }
+    return (0, web3_js_1.clusterApiUrl)("devnet");
+}
+/**
+ * Path to persistent config file
+ */
+function getConfigPath() {
+    return path.join(os.homedir(), ".shuffle", "config.json");
+}
+/**
+ * Load saved config from ~/.shuffle/config.json
+ */
+function loadSavedConfig() {
+    try {
+        const configPath = getConfigPath();
+        if (fs.existsSync(configPath)) {
+            return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        }
+    }
+    catch {
+        // Ignore errors, return empty config
+    }
+    return {};
+}
+/**
+ * Save config to ~/.shuffle/config.json
+ */
+function saveConfig(key, value) {
+    const shuffleDir = path.join(os.homedir(), ".shuffle");
+    const configPath = getConfigPath();
+    if (!fs.existsSync(shuffleDir)) {
+        fs.mkdirSync(shuffleDir, { recursive: true });
+    }
+    const existing = loadSavedConfig();
+    const updated = { ...existing, [key]: value };
+    fs.writeFileSync(configPath, JSON.stringify(updated, null, 2));
+}
+/**
+ * Get a saved config value
+ */
+function getSavedConfig(key) {
+    const saved = loadSavedConfig();
+    return saved[key];
+}
+/**
+ * Initialize CLI configuration
+ */
+async function loadConfig(opts) {
+    // Use saved config as defaults if --network/--mock not provided
+    const savedConfig = loadSavedConfig();
+    const network = opts.network || savedConfig.network || "devnet";
+    const savedMock = savedConfig.mock === "true";
+    const mockMode = opts.mock !== undefined ? opts.mock : savedMock || devnet_1.MOCK_MODE;
+    const userProfile = opts.user;
+    const { keypair, path: keypairPath } = loadKeypair(opts.keypair, userProfile);
+    const wallet = new anchor.Wallet(keypair);
+    const connection = new web3_js_1.Connection(getRpcUrl(network), "confirmed");
+    const encryptionPrivateKey = loadOrCreateEncryptionKey(userProfile);
+    let shuffleClient = null;
+    // Select program ID based on network
+    const programId = network === "localnet"
+        ? devnet_1.LOCALNET_CONFIG.programId
+        : devnet_1.DEVNET_CONFIG.programId;
+    if (!mockMode) {
+        try {
+            shuffleClient = await client_1.ShuffleClient.create({
+                connection,
+                wallet,
+                programId,
+                clusterOffset: 0,
+            });
+            shuffleClient.initEncryption(encryptionPrivateKey);
+        }
+        catch (e) {
+            // Will use mock mode if client creation fails
+            console.warn(`Failed to connect to Shuffle protocol: ${e.message?.slice(0, 50)}`);
+        }
+    }
+    config = {
+        network,
+        connection,
+        wallet,
+        keypairPath,
+        mockMode: mockMode || !shuffleClient,
+        shuffleClient,
+        encryptionPrivateKey,
+        userProfile,
+    };
+    return config;
+}
+/**
+ * Get current config (must call loadConfig first)
+ */
+function getConfig() {
+    if (!config) {
+        throw new Error("Config not loaded. This is a bug.");
+    }
+    return config;
+}
+/**
+ * Get CLI version from package.json
+ */
+function getVersion() {
+    try {
+        const pkgPath = path.join(__dirname, "..", "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return pkg.version || "0.1.0";
+    }
+    catch {
+        return "0.1.0";
+    }
+}

package/dist/cli/devnet.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Devnet Configuration and Mock Mode
+ *
+ * Contains easily-updatable constants for devnet deployment.
+ * When MOCK_MODE is true, all operations simulate responses.
+ */
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Set to false for live blockchain interaction
+ */
+export declare const MOCK_MODE = false;
+/**
+ * Localnet program configuration (from arcium test)
+ * UPDATE THIS when network restarts!
+ */
+export declare const LOCALNET_CONFIG: {
+    programId: PublicKey;
+    rpcUrl: string;
+};
+/**
+ * Devnet program and token configuration
+ */
+export declare const DEVNET_CONFIG: {
+    programId: PublicKey;
+    rpcUrl: string;
+    clusterOffset: number;
+    mints: {
+        USDC: PublicKey;
+        TSLA: PublicKey;
+        SPY: PublicKey;
+        AAPL: PublicKey;
+    };
+    faucetAuthority: PublicKey | null;
+};
+/**
+ * Simulated delay for mock operations (milliseconds)
+ */
+export declare const MOCK_DELAY: {
+    fast: number;
+    medium: number;
+    slow: number;
+};
+/**
+ * Mock state for simulating operations
+ */
+export interface MockState {
+    accountExists: boolean;
+    balances: {
+        usdc: bigint;
+        tsla: bigint;
+        spy: bigint;
+        aapl: bigint;
+    };
+    pendingOrder: {
+        batchId: number;
+        pairId: number;
+        direction: number;
+        amount: bigint;
+    } | null;
+    batchId: number;
+}
+/**
+ * Get current mock state
+ */
+export declare function getMockState(): MockState;
+/**
+ * Update mock state
+ */
+export declare function updateMockState(updates: Partial<MockState>): void;
+/**
+ * Reset mock state
+ */
+export declare function resetMockState(): void;
+/**
+ * Simulate async delay
+ */
+export declare function mockDelay(type: keyof typeof MOCK_DELAY): Promise<void>;
+/**
+ * Generate a fake transaction signature
+ */
+export declare function mockSignature(): string;

package/dist/cli/devnet.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Devnet Configuration and Mock Mode
+ *
+ * Contains easily-updatable constants for devnet deployment.
+ * When MOCK_MODE is true, all operations simulate responses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOCK_DELAY = exports.DEVNET_CONFIG = exports.LOCALNET_CONFIG = exports.MOCK_MODE = void 0;
+exports.getMockState = getMockState;
+exports.updateMockState = updateMockState;
+exports.resetMockState = resetMockState;
+exports.mockDelay = mockDelay;
+exports.mockSignature = mockSignature;
+const web3_js_1 = require("@solana/web3.js");
+// ============================================================================
+// DEVNET CONSTANTS - Update these when contracts are deployed
+// ============================================================================
+/**
+ * Set to false for live blockchain interaction
+ */
+exports.MOCK_MODE = false;
+/**
+ * Localnet program configuration (from arcium test)
+ * UPDATE THIS when network restarts!
+ */
+exports.LOCALNET_CONFIG = {
+    programId: new web3_js_1.PublicKey("BzaakuSahkVtEXKqZnD9tSPBoiJCMLa1nzQHUjtY1xRM"),
+    rpcUrl: "http://127.0.0.1:8899",
+};
+/**
+ * Devnet program and token configuration
+ */
+exports.DEVNET_CONFIG = {
+    // Program ID from successful devnet deployment (2026-02-01)
+    programId: new web3_js_1.PublicKey("BzaakuSahkVtEXKqZnD9tSPBoiJCMLa1nzQHUjtY1xRM"),
+    rpcUrl: "https://devnet.helius-rpc.com/?api-key=a8e1a5ce-29c6-4356-b3f9-54c1c650ac08",
+    // Arcium cluster offset for v0.6.3 (required for account derivations)
+    clusterOffset: 456,
+    // Token mints - deployed 2026-02-01
+    mints: {
+        USDC: new web3_js_1.PublicKey("2rGgkS8piPnFbJxLhyyfXnTuLqPW8zPoM7YXnovjBK9s"),
+        TSLA: new web3_js_1.PublicKey("EmRuN3yRqizBKwVSahm6bPW4YEUZ4iGcP95SQg1MdDfZ"),
+        SPY: new web3_js_1.PublicKey("HgaWt2CGQLT3RTNt4HQpCFhMpeo8amadH6KcQ5gVCDvQ"),
+        AAPL: new web3_js_1.PublicKey("7JohqPXEVJ3Mm8TrHf7KQ7F4Nq4JnxvfTLQFn4D5nghj"),
+    },
+    // Faucet authority - update with deployed faucet program or mint authority
+    faucetAuthority: null,
+};
+// ============================================================================
+// MOCK RESPONSES - Used when MOCK_MODE is true
+// ============================================================================
+/**
+ * Simulated delay for mock operations (milliseconds)
+ */
+exports.MOCK_DELAY = {
+    fast: 800, // Balance queries
+    medium: 2000, // Deposits, withdrawals
+    slow: 4000, // MPC operations (orders, settlements)
+};
+let mockState = {
+    accountExists: true, // Pre-initialized for smooth demo
+    balances: { usdc: 0n, tsla: 0n, spy: 0n, aapl: 0n },
+    pendingOrder: null,
+    batchId: 1,
+};
+/**
+ * Get current mock state
+ */
+function getMockState() {
+    return mockState;
+}
+/**
+ * Update mock state
+ */
+function updateMockState(updates) {
+    mockState = { ...mockState, ...updates };
+}
+/**
+ * Reset mock state
+ */
+function resetMockState() {
+    mockState = {
+        accountExists: false,
+        balances: { usdc: 0n, tsla: 0n, spy: 0n, aapl: 0n },
+        pendingOrder: null,
+        batchId: 1,
+    };
+}
+/**
+ * Simulate async delay
+ */
+function mockDelay(type) {
+    return new Promise((resolve) => setTimeout(resolve, exports.MOCK_DELAY[type]));
+}
+/**
+ * Generate a fake transaction signature
+ */
+function mockSignature() {
+    const chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let sig = "";
+    for (let i = 0; i < 88; i++) {
+        sig += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return sig;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Shuffle CLI - Command Line Interface for Shuffle Privacy Protocol
+ *
+ * This CLI wraps the ShuffleClient SDK to provide terminal-based
+ * interaction with the Shuffle protocol on Solana.
+ */
+export {};

package/dist/cli/index.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Shuffle CLI - Command Line Interface for Shuffle Privacy Protocol
+ *
+ * This CLI wraps the ShuffleClient SDK to provide terminal-based
+ * interaction with the Shuffle protocol on Solana.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Suppress punycode deprecation warning from dependencies
+process.removeAllListeners('warning');
+const originalEmit = process.emit;
+// @ts-ignore
+process.emit = function (event, warning) {
+    if (event === 'warning' && warning?.name === 'DeprecationWarning' &&
+        warning?.message?.includes('punycode')) {
+        return false;
+    }
+    return originalEmit.apply(process, arguments);
+};
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const commands_1 = require("./commands");
+const config_1 = require("./config");
+const program = new commander_1.Command();
+program
+    .name("shuffle")
+    .description(chalk_1.default.cyan("🃏 Shuffle Protocol CLI - Private DeFi on Solana"))
+    .version((0, config_1.getVersion)())
+    .option("-n, --network <network>", "Network to use (devnet|localnet)")
+    .option("-k, --keypair <path>", "Path to keypair file")
+    .option("-u, --user <name>", "User profile name (creates separate keys)")
+    .option("--mock", "Run in mock mode (no blockchain interaction)")
+    .hook("preAction", async (thisCommand) => {
+    // Skip config loading for the config command itself
+    if (thisCommand.args[0] === "config")
+        return;
+    // Load config before any command runs
+    const opts = thisCommand.opts();
+    await (0, config_1.loadConfig)(opts);
+});
+// Config command (doesn't need preAction hook)
+const configCmd = program
+    .command("config")
+    .description("Manage CLI configuration");
+configCmd
+    .command("set <key> <value>")
+    .description("Set a config value (e.g., 'shuffle config set network localnet' or 'shuffle config set mock true')")
+    .action((key, value) => {
+    if (key === "network") {
+        if (!["devnet", "localnet"].includes(value)) {
+            console.log(chalk_1.default.red(`❌ Invalid network: ${value}. Use 'devnet' or 'localnet'.`));
+            return;
+        }
+    }
+    if (key === "mock") {
+        if (!["true", "false"].includes(value.toLowerCase())) {
+            console.log(chalk_1.default.red(`❌ Invalid value: ${value}. Use 'true' or 'false'.`));
+            return;
+        }
+        value = value.toLowerCase();
+    }
+    (0, config_1.saveConfig)(key, value);
+    console.log(chalk_1.default.green(`✓ Set ${key} = ${value}`));
+    console.log(chalk_1.default.gray(`  Saved to ~/.shuffle/config.json`));
+});
+configCmd
+    .command("get [key]")
+    .description("Get a config value or show all config")
+    .action((key) => {
+    if (key) {
+        const value = (0, config_1.getSavedConfig)(key);
+        if (value) {
+            console.log(`${key}: ${chalk_1.default.cyan(value)}`);
+        }
+        else {
+            console.log(chalk_1.default.gray(`${key}: (not set)`));
+        }
+    }
+    else {
+        // Show all config
+        const network = (0, config_1.getSavedConfig)("network") || "(default: devnet)";
+        const mock = (0, config_1.getSavedConfig)("mock") || "false";
+        console.log(chalk_1.default.cyan("\n🃏 Shuffle Config\n"));
+        console.log(`  network: ${chalk_1.default.white(network)}`);
+        console.log(`  mock:    ${chalk_1.default.white(mock)}`);
+        console.log(chalk_1.default.gray(`\n  Config file: ~/.shuffle/config.json\n`));
+    }
+});
+// Account Management
+program
+    .command("init")
+    .description("Create a new privacy account")
+    .action(commands_1.initCommand);
+program
+    .command("balance")
+    .description("View your encrypted balances")
+    .action(commands_1.balanceCommand);
+// Token Operations
+program
+    .command("deposit <asset> <amount>")
+    .alias("shield")
+    .description("Deposit (shield) tokens into your privacy account")
+    .action(commands_1.depositCommand);
+program
+    .command("withdraw <asset> <amount>")
+    .alias("unshield")
+    .description("Withdraw (unshield) tokens from your privacy account")
+    .action(commands_1.withdrawCommand);
+program
+    .command("transfer <address> <amount>")
+    .description("Send USDC privately to another user")
+    .action(commands_1.transferCommand);
+// Trading
+program
+    .command("order [pair] [direction] [amount]")
+    .description("Place an encrypted order (interactive if no args, or: shuffle order TSLA_USDC buy 100)")
+    .action(commands_1.orderCommand);
+program
+    .command("execute")
+    .description("Trigger batch execution (requires 8+ orders)")
+    .action(commands_1.executeCommand);
+program
+    .command("settle")
+    .description("Settle your pending order after batch execution")
+    .action(commands_1.settleCommand);
+program
+    .command("status")
+    .description("View batch info and pending order status")
+    .action(commands_1.statusCommand);
+// Devnet Utilities
+program
+    .command("faucet <amount>")
+    .description("Mint devnet USDC to your wallet")
+    .action(commands_1.faucetCommand);
+program
+    .command("airdrop [amount]")
+    .description("Airdrop SOL to your wallet (default: 2 SOL)")
+    .action(commands_1.airdropCommand);
+// History
+program
+    .command("history")
+    .description("View all executed batch logs")
+    .action(commands_1.historyCommand);
+// Parse and run, then exit to avoid hanging from open connections
+program.parseAsync().then(() => {
+    // Give a moment for any final I/O to flush
+    setTimeout(() => process.exit(0), 100);
+}).catch((e) => {
+    console.error(e);
+    process.exit(1);
+});