@shuffle-protocol/sdk 0.1.0

package/dist/constants.d.ts

@@ -0,0 +1,30 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const PROGRAM_ID: PublicKey;
+export declare enum AssetId {
+    USDC = 0,
+    TSLA = 1,
+    SPY = 2,
+    AAPL = 3
+}
+export declare enum PairId {
+    TSLA_USDC = 0,
+    SPY_USDC = 1,
+    AAPL_USDC = 2,
+    TSLA_SPY = 3,
+    TSLA_AAPL = 4,
+    SPY_AAPL = 5
+}
+export declare enum Direction {
+    AtoB = 0,
+    BtoA = 1
+}
+export declare const NUM_PAIRS = 6;
+export declare const NUM_ASSETS = 4;
+export declare const POOL_SEED = "pool";
+export declare const USER_SEED = "user";
+export declare const BATCH_ACCUMULATOR_SEED = "batch_accumulator";
+export declare const BATCH_LOG_SEED = "batch_log";
+export declare const VAULT_SEED = "vault";
+export declare const VAULT_ASSET_SEEDS: Record<AssetId, string>;
+export declare const ASSET_LABELS: Record<AssetId, string>;
+export declare const PAIR_TOKENS: Record<PairId, [AssetId, AssetId]>;

package/dist/constants.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAIR_TOKENS = exports.ASSET_LABELS = exports.VAULT_ASSET_SEEDS = exports.VAULT_SEED = exports.BATCH_LOG_SEED = exports.BATCH_ACCUMULATOR_SEED = exports.USER_SEED = exports.POOL_SEED = exports.NUM_ASSETS = exports.NUM_PAIRS = exports.Direction = exports.PairId = exports.AssetId = exports.PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+// Program ID (localnet default from Anchor.toml)
+exports.PROGRAM_ID = new web3_js_1.PublicKey("BzaakuSahkVtEXKqZnD9tSPBoiJCMLa1nzQHUjtY1xRM");
+// Asset IDs matching contract/programs/shuffle_protocol/src/constants.rs
+var AssetId;
+(function (AssetId) {
+    AssetId[AssetId["USDC"] = 0] = "USDC";
+    AssetId[AssetId["TSLA"] = 1] = "TSLA";
+    AssetId[AssetId["SPY"] = 2] = "SPY";
+    AssetId[AssetId["AAPL"] = 3] = "AAPL";
+})(AssetId || (exports.AssetId = AssetId = {}));
+// Pair IDs for the 6 trading pairs (4 choose 2)
+var PairId;
+(function (PairId) {
+    PairId[PairId["TSLA_USDC"] = 0] = "TSLA_USDC";
+    PairId[PairId["SPY_USDC"] = 1] = "SPY_USDC";
+    PairId[PairId["AAPL_USDC"] = 2] = "AAPL_USDC";
+    PairId[PairId["TSLA_SPY"] = 3] = "TSLA_SPY";
+    PairId[PairId["TSLA_AAPL"] = 4] = "TSLA_AAPL";
+    PairId[PairId["SPY_AAPL"] = 5] = "SPY_AAPL";
+})(PairId || (exports.PairId = PairId = {}));
+// Order direction
+var Direction;
+(function (Direction) {
+    Direction[Direction["AtoB"] = 0] = "AtoB";
+    Direction[Direction["BtoA"] = 1] = "BtoA";
+})(Direction || (exports.Direction = Direction = {}));
+exports.NUM_PAIRS = 6;
+exports.NUM_ASSETS = 4;
+// PDA seeds (must match Rust constants)
+exports.POOL_SEED = "pool";
+exports.USER_SEED = "user";
+exports.BATCH_ACCUMULATOR_SEED = "batch_accumulator";
+exports.BATCH_LOG_SEED = "batch_log";
+exports.VAULT_SEED = "vault";
+// Per-asset vault sub-seeds
+exports.VAULT_ASSET_SEEDS = {
+    [AssetId.USDC]: "usdc",
+    [AssetId.TSLA]: "tsla",
+    [AssetId.SPY]: "spy",
+    [AssetId.AAPL]: "aapl",
+};
+// Asset labels for display
+exports.ASSET_LABELS = {
+    [AssetId.USDC]: "USDC",
+    [AssetId.TSLA]: "TSLA",
+    [AssetId.SPY]: "SPY",
+    [AssetId.AAPL]: "AAPL",
+};
+// Pair token mapping: pairId -> [baseAsset, quoteAsset]
+exports.PAIR_TOKENS = {
+    [PairId.TSLA_USDC]: [AssetId.TSLA, AssetId.USDC],
+    [PairId.SPY_USDC]: [AssetId.SPY, AssetId.USDC],
+    [PairId.AAPL_USDC]: [AssetId.AAPL, AssetId.USDC],
+    [PairId.TSLA_SPY]: [AssetId.TSLA, AssetId.SPY],
+    [PairId.TSLA_AAPL]: [AssetId.TSLA, AssetId.AAPL],
+    [PairId.SPY_AAPL]: [AssetId.SPY, AssetId.AAPL],
+};

package/dist/encryption.d.ts

@@ -0,0 +1,24 @@
+import { RescueCipher, deserializeLE } from "@arcium-hq/client";
+import * as anchor from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+export { RescueCipher, deserializeLE };
+export interface EncryptionKeypair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+export interface EncryptedValue {
+    ciphertext: Uint8Array;
+    nonce: Uint8Array;
+}
+/** Generate a new x25519 keypair for Arcium encryption */
+export declare function generateEncryptionKeypair(): EncryptionKeypair;
+/** Create a RescueCipher from user's private key and MXE public key */
+export declare function createCipher(privateKey: Uint8Array, mxePublicKey: Uint8Array): RescueCipher;
+/** Encrypt a single value, returning ciphertext and nonce */
+export declare function encryptValue(cipher: RescueCipher, value: bigint, nonce?: Uint8Array): EncryptedValue;
+/** Decrypt a ciphertext back to a bigint value */
+export declare function decryptValue(cipher: RescueCipher, ciphertext: Uint8Array, nonce: Uint8Array): bigint;
+/** Fetch MXE public key with retry logic */
+export declare function fetchMXEPublicKey(provider: anchor.AnchorProvider, programId: PublicKey, maxRetries?: number): Promise<Uint8Array>;
+/** Convert a nonce Uint8Array to anchor.BN (for instruction args) */
+export declare function nonceToBN(nonce: Uint8Array): anchor.BN;

package/dist/encryption.js

@@ -0,0 +1,90 @@
+"use strict";
+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.deserializeLE = exports.RescueCipher = void 0;
+exports.generateEncryptionKeypair = generateEncryptionKeypair;
+exports.createCipher = createCipher;
+exports.encryptValue = encryptValue;
+exports.decryptValue = decryptValue;
+exports.fetchMXEPublicKey = fetchMXEPublicKey;
+exports.nonceToBN = nonceToBN;
+const client_1 = require("@arcium-hq/client");
+Object.defineProperty(exports, "RescueCipher", { enumerable: true, get: function () { return client_1.RescueCipher; } });
+Object.defineProperty(exports, "deserializeLE", { enumerable: true, get: function () { return client_1.deserializeLE; } });
+const crypto_1 = require("crypto");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+/** Generate a new x25519 keypair for Arcium encryption */
+function generateEncryptionKeypair() {
+    const privateKey = client_1.x25519.utils.randomSecretKey();
+    const publicKey = client_1.x25519.getPublicKey(privateKey);
+    return { privateKey, publicKey };
+}
+/** Create a RescueCipher from user's private key and MXE public key */
+function createCipher(privateKey, mxePublicKey) {
+    const sharedSecret = client_1.x25519.getSharedSecret(privateKey, mxePublicKey);
+    return new client_1.RescueCipher(sharedSecret);
+}
+/** Encrypt a single value, returning ciphertext and nonce */
+function encryptValue(cipher, value, nonce) {
+    const nonceBytes = nonce || (0, crypto_1.randomBytes)(16);
+    const encrypted = cipher.encrypt([value], nonceBytes);
+    return {
+        ciphertext: encrypted[0],
+        nonce: nonceBytes,
+    };
+}
+/** Decrypt a ciphertext back to a bigint value */
+function decryptValue(cipher, ciphertext, nonce) {
+    const decrypted = cipher.decrypt([ciphertext], nonce);
+    return decrypted[0];
+}
+/** Fetch MXE public key with retry logic */
+async function fetchMXEPublicKey(provider, programId, maxRetries = 5) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await (0, client_1.getMXEPublicKey)(provider, programId);
+        }
+        catch (error) {
+            if (attempt === maxRetries)
+                throw error;
+            await new Promise((r) => setTimeout(r, 2000 * attempt));
+        }
+    }
+    throw new Error("Failed to fetch MXE public key");
+}
+/** Convert a nonce Uint8Array to anchor.BN (for instruction args) */
+function nonceToBN(nonce) {
+    return new anchor.BN((0, client_1.deserializeLE)(nonce).toString());
+}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+/** Maps Anchor error codes (6000+) to readable names and messages */
+export declare const ERROR_MAP: Record<number, {
+    name: string;
+    message: string;
+}>;
+export declare class ShuffleError extends Error {
+    code: number;
+    errorName: string;
+    constructor(code: number);
+}
+/** Extract a readable error from an Anchor error object */
+export declare function parseError(error: any): ShuffleError | Error;

package/dist/errors.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShuffleError = exports.ERROR_MAP = void 0;
+exports.parseError = parseError;
+/** Maps Anchor error codes (6000+) to readable names and messages */
+exports.ERROR_MAP = {
+    6000: { name: "ProtocolPaused", message: "Protocol is paused" },
+    6001: { name: "Unauthorized", message: "Unauthorized" },
+    6002: { name: "InvalidAmount", message: "Invalid amount" },
+    6003: { name: "InvalidAsset", message: "Invalid asset" },
+    6004: { name: "InvalidAssetId", message: "Invalid asset ID (must be 0-3)" },
+    6005: { name: "InvalidPairId", message: "Invalid pair ID (must be 0-5)" },
+    6006: { name: "InvalidMint", message: "Invalid token mint" },
+    6007: { name: "InvalidOwner", message: "Invalid token account owner" },
+    6008: { name: "FeeTooHigh", message: "Fee too high (max 10%)" },
+    6009: { name: "PendingOrderExists", message: "User has a pending order - settle before placing a new one" },
+    6010: { name: "NoPendingOrder", message: "No pending order to settle" },
+    6011: { name: "BatchNotFinalized", message: "Batch not yet executed" },
+    6012: { name: "BatchIdMismatch", message: "Batch ID mismatch" },
+    6013: { name: "InsufficientBalance", message: "Insufficient balance" },
+    6014: { name: "MinOutputNotMet", message: "Minimum output not met" },
+    6015: { name: "DivisionByZero", message: "Division by zero in settlement" },
+    6016: { name: "AbortedComputation", message: "The computation was aborted" },
+    6017: { name: "ComputationFailed", message: "MPC computation failed" },
+    6018: { name: "ClusterNotSet", message: "Cluster not set" },
+    6019: { name: "RecipientAccountNotFound", message: "Recipient account not found" },
+};
+class ShuffleError extends Error {
+    constructor(code) {
+        const info = exports.ERROR_MAP[code] || { name: "Unknown", message: `Unknown error code: ${code}` };
+        super(info.message);
+        this.code = code;
+        this.errorName = info.name;
+        this.name = "ShuffleError";
+    }
+}
+exports.ShuffleError = ShuffleError;
+/** Extract a readable error from an Anchor error object */
+function parseError(error) {
+    const code = error?.error?.errorCode?.number;
+    if (code && exports.ERROR_MAP[code]) {
+        return new ShuffleError(code);
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}