@aintivirus-ai/mixer-sdk 1.0.6 → 1.0.8

package/README.md

@@ -88,7 +88,7 @@ const signer = await provider.getSigner();
 const sdk = new AintiVirusEVM(
   "0x...", // Factory contract address
   "0x...", // Token contract address
-  signer
+  signer,
 );
 
 // Deposit ETH
@@ -134,7 +134,7 @@ const sdk = new AintiVirusSolana(
   "AinTiV1ru5Staking1111111111111111111111111111", // Staking program ID
   wallet,
   connection,
-  "TokenMintAddress..." // Optional: Token mint address
+  "TokenMintAddress...", // Optional: Token mint address
 );
 
 // Deposit SOL
@@ -224,11 +224,7 @@ import {
   AssetMode,
 } from "@aintivirus-ai/mixer-sdk/hooks";
 
-const { withdraw, isEVMReady } = useWithdraw({
-  evm: {
-    factoryAddress: "0x...",
-  },
-});
+const { withdraw, isEVMReady } = useWithdraw();
 
 // Withdraw
 await withdraw(ChainType.EVM, proof, amount, AssetMode.ETH);
@@ -495,17 +491,14 @@ const commitment = computeCommitment(secret, nullifier);
 
 ### Generating Withdrawal Proof
 
+Set `CIRCUIT_WASM` and `CIRCUIT_ZKEY` in your environment. Values may be HTTPS URLs (fetched at proof time) or base64-encoded file content.
+
 ```typescript
 import {
   generateWithdrawalProofFromData,
   buildMerkleTree,
   getMerklePath,
 } from "@aintivirus-ai/mixer-sdk";
-import { readFileSync } from "fs";
-
-// Load circuit files (from your build directory)
-const circuitWasm = readFileSync("path/to/mixer.wasm");
-const circuitZkey = readFileSync("path/to/mixer.zkey");
 
 // Get all commitments from deposit events
 const commitments = [
@@ -519,14 +512,12 @@ const root = BigInt(tree.root);
 // Get merkle path for your commitment
 const path = getMerklePath(tree, commitment);
 
-// Generate proof
+// Generate proof (circuit files loaded from env)
 const proof = await generateWithdrawalProofFromData({
   secret,
   nullifier,
   recipient: "0x...", // Recipient address
   commitments,
-  circuitWasm,
-  circuitZkey,
 });
 
 // Withdraw

package/dist/config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Config normalization and chain resolution for multi-chain (EVM + Solana) and legacy single-chain.
+ * Solana config is still normalized and exposed; SDK/hooks Solana integration is disabled elsewhere.
+ */
+import type { SDKConfig, MixerSDKConfig, EvmChainConfig, SolanaChainConfig } from "./types";
+/** Normalized config: always has chains.evm and chains.solana as records */
+export interface NormalizedMixerConfig {
+    chains: {
+        evm: Record<number, EvmChainConfig>;
+        solana: Record<string, SolanaChainConfig>;
+    };
+    useMulticall?: boolean;
+}
+/**
+ * Normalize SDK config to canonical shape (chains.evm / chains.solana).
+ * Legacy flat evm/solana are converted to single-entry chains so one code path handles both.
+ */
+export declare function normalizeConfig(config: SDKConfig | MixerSDKConfig): NormalizedMixerConfig;
+/**
+ * Get EVM chain config for the given chainId.
+ * For legacy single-chain config, returns the single evm config for any chainId.
+ * Optimized for many EVM networks: each chainId is looked up in config.chains.evm.
+ */
+export declare function getEvmChainConfig(config: SDKConfig | MixerSDKConfig | NormalizedMixerConfig, chainId: number): EvmChainConfig | undefined;
+/**
+ * Get Solana chain config for the given network id (e.g. "mainnet", "devnet").
+ * For legacy single-chain config, returns the single solana config for any network.
+ */
+export declare function getSolanaChainConfig(config: SDKConfig | MixerSDKConfig | NormalizedMixerConfig, network: string): SolanaChainConfig | undefined;
+/**
+ * Return all EVM chain IDs present in the config.
+ */
+export declare function getEvmChainIds(config: NormalizedMixerConfig): number[];
+/**
+ * Return all Solana network ids present in the config.
+ */
+export declare function getSolanaNetworks(config: NormalizedMixerConfig): string[];

package/dist/config.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Config normalization and chain resolution for multi-chain (EVM + Solana) and legacy single-chain.
+ * Solana config is still normalized and exposed; SDK/hooks Solana integration is disabled elsewhere.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeConfig = normalizeConfig;
+exports.getEvmChainConfig = getEvmChainConfig;
+exports.getSolanaChainConfig = getSolanaChainConfig;
+exports.getEvmChainIds = getEvmChainIds;
+exports.getSolanaNetworks = getSolanaNetworks;
+const DEFAULT_EVM_CHAIN_ID = 1;
+const DEFAULT_SOLANA_NETWORK = "mainnet";
+/**
+ * Normalize SDK config to canonical shape (chains.evm / chains.solana).
+ * Legacy flat evm/solana are converted to single-entry chains so one code path handles both.
+ */
+function normalizeConfig(config) {
+    const hasChains = "chains" in config && config.chains != null;
+    const evmRecord = hasChains && config.chains?.evm
+        ? { ...config.chains.evm }
+        : {};
+    const solanaRecord = hasChains && config.chains?.solana
+        ? { ...config.chains.solana }
+        : {};
+    if (!hasChains || Object.keys(evmRecord).length === 0) {
+        const legacy = config;
+        if (legacy.evm) {
+            evmRecord[DEFAULT_EVM_CHAIN_ID] = {
+                factoryAddress: legacy.evm.factoryAddress,
+                tokenAddress: legacy.evm.tokenAddress,
+                wethAddress: legacy.evm.wethAddress,
+                wethGatewayAddress: legacy.evm.wethGatewayAddress,
+                rpcUrl: legacy.evm.rpcUrl,
+            };
+        }
+    }
+    if (!hasChains || Object.keys(solanaRecord).length === 0) {
+        const legacy = config;
+        if (legacy.solana) {
+            solanaRecord[DEFAULT_SOLANA_NETWORK] = {
+                factoryProgramId: legacy.solana.factoryProgramId,
+                mixerProgramId: legacy.solana.mixerProgramId,
+                stakingProgramId: legacy.solana.stakingProgramId,
+                tokenMint: legacy.solana.tokenMint,
+                rpcUrl: legacy.solana.rpcUrl,
+            };
+        }
+    }
+    return {
+        chains: { evm: evmRecord, solana: solanaRecord },
+        useMulticall: "useMulticall" in config ? config.useMulticall : undefined,
+    };
+}
+/**
+ * Get EVM chain config for the given chainId.
+ * For legacy single-chain config, returns the single evm config for any chainId.
+ * Optimized for many EVM networks: each chainId is looked up in config.chains.evm.
+ */
+function getEvmChainConfig(config, chainId) {
+    const normalized = "chains" in config && config.chains ? config : normalizeConfig(config);
+    const evm = normalized.chains?.evm?.[chainId];
+    if (evm)
+        return evm;
+    const legacy = config;
+    if (legacy.evm)
+        return legacy.evm;
+    return undefined;
+}
+/**
+ * Get Solana chain config for the given network id (e.g. "mainnet", "devnet").
+ * For legacy single-chain config, returns the single solana config for any network.
+ */
+function getSolanaChainConfig(config, network) {
+    const normalized = "chains" in config && config.chains ? config : normalizeConfig(config);
+    const solana = normalized.chains?.solana?.[network];
+    if (solana)
+        return solana;
+    const legacy = config;
+    if (legacy.solana)
+        return legacy.solana;
+    return undefined;
+}
+/**
+ * Return all EVM chain IDs present in the config.
+ */
+function getEvmChainIds(config) {
+    return Object.keys(config.chains?.evm ?? {}).map(Number);
+}
+/**
+ * Return all Solana network ids present in the config.
+ */
+function getSolanaNetworks(config) {
+    return Object.keys(config.chains?.solana ?? {});
+}

package/dist/createSDK.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Factory for multi-chain SDK instances (EVM + Solana config).
+ * EVM: built on demand per chainId. Solana: getSolana() disabled (returns null) for now.
+ */
+import type { Signer } from "ethers";
+import type { Provider } from "ethers";
+import type { MixerSDKConfig, SDKConfig } from "./types";
+import type { NormalizedMixerConfig } from "./config";
+import { AintiVirusEVM } from "./evm";
+import type { AintiVirusSolana } from "./solana";
+export type { NormalizedMixerConfig } from "./config";
+export interface MixerSDKInstance {
+    /** Get normalized config */
+    getConfig(): NormalizedMixerConfig;
+    /** EVM chain IDs present in config */
+    getEvmChainIds(): number[];
+    /** Solana network ids present in config (Solana SDK integration disabled) */
+    getSolanaNetworks(): string[];
+    /** Get EVM SDK for chainId; signerOrProvider from wagmi/ethers for that chain */
+    getEVM(chainId: number, signerOrProvider: Signer | Provider): AintiVirusEVM | null;
+    /** Get Solana SDK – disabled, returns null. Re-enable by uncommenting implementation in createSDK. */
+    getSolana(network: string, wallet: import("@coral-xyz/anchor").Wallet, connection: import("@solana/web3.js").Connection): AintiVirusSolana | null;
+}
+/**
+ * Create a multi-chain SDK instance. Accepts full settings (MixerSDKConfig) or legacy SDKConfig.
+ * EVM instances are created on demand via getEVM(chainId, signerOrProvider).
+ * Solana: getSolana() disabled (returns null).
+ */
+export declare function createMixerSDK(config: MixerSDKConfig | SDKConfig): MixerSDKInstance;

package/dist/createSDK.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Factory for multi-chain SDK instances (EVM + Solana config).
+ * EVM: built on demand per chainId. Solana: getSolana() disabled (returns null) for now.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMixerSDK = createMixerSDK;
+const config_1 = require("./config");
+const evm_1 = require("./evm");
+const multicall_1 = require("./evm/multicall");
+/**
+ * Create a multi-chain SDK instance. Accepts full settings (MixerSDKConfig) or legacy SDKConfig.
+ * EVM instances are created on demand via getEVM(chainId, signerOrProvider).
+ * Solana: getSolana() disabled (returns null).
+ */
+function createMixerSDK(config) {
+    const normalized = (0, config_1.normalizeConfig)(config);
+    return {
+        getConfig: () => normalized,
+        getEvmChainIds: () => (0, config_1.getEvmChainIds)(normalized),
+        getSolanaNetworks: () => (0, config_1.getSolanaNetworks)(normalized),
+        getEVM(chainId, signerOrProvider) {
+            const chainConfig = (0, config_1.getEvmChainConfig)(normalized, chainId);
+            if (!chainConfig)
+                return null;
+            const tokenAddress = chainConfig.tokenAddress ?? "0x0000000000000000000000000000000000000000";
+            try {
+                const useMulticall = chainConfig.useMulticall ?? normalized.useMulticall ?? false;
+                const multicallAddress = chainConfig.multicallAddress ?? multicall_1.MULTICALL3_ADDRESS;
+                return new evm_1.AintiVirusEVM(chainConfig.factoryAddress, tokenAddress, signerOrProvider, chainConfig.wethGatewayAddress, chainConfig.wethAddress, useMulticall, multicallAddress);
+            }
+            catch {
+                return null;
+            }
+        },
+        // Solana integration disabled – returns null. Uncomment below and add: import { AintiVirusSolana } from "./solana";
+        getSolana(_network, _wallet, _connection) {
+            return null;
+            // const chainConfig = getSolanaChainConfig(normalized, network);
+            // if (!chainConfig) return null;
+            // try {
+            //   return new AintiVirusSolana(wallet, connection, chainConfig.tokenMint);
+            // } catch {
+            //   return null;
+            // }
+        },
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Structured SDK errors for predictable handling (e.g. instanceof or code checks).
+ */
+export declare const ERROR_CODES: {
+    readonly SIGNER_REQUIRED: "SIGNER_REQUIRED";
+    readonly TRANSACTION: "TRANSACTION";
+    readonly SUBGRAPH: "SUBGRAPH";
+    readonly PROOF: "PROOF";
+    readonly MULTICALL: "MULTICALL";
+};
+/**
+ * Base error for all SDK errors. Has optional code and cause for programmatic handling.
+ */
+export declare class MixerSDKError extends Error {
+    readonly code?: string;
+    readonly cause?: unknown;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a write operation is attempted without a signer (wallet). */
+export declare class SignerRequiredError extends MixerSDKError {
+    constructor(message?: string);
+}
+/** Thrown when a transaction fails (missing hash, receipt timeout, revert). */
+export declare class TransactionError extends MixerSDKError {
+    constructor(message: string, cause?: unknown);
+}
+/** Thrown when subgraph request fails (HTTP or GraphQL errors). */
+export declare class SubgraphError extends MixerSDKError {
+    readonly status?: number;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        status?: number;
+    });
+}
+/** Thrown when proof generation or circuit fetch fails. */
+export declare class ProofError extends MixerSDKError {
+    constructor(message: string, cause?: unknown);
+}
+/** Thrown when multicall aggregate or decode fails. */
+export declare class MulticallError extends MixerSDKError {
+    constructor(message: string, cause?: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Structured SDK errors for predictable handling (e.g. instanceof or code checks).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulticallError = exports.ProofError = exports.SubgraphError = exports.TransactionError = exports.SignerRequiredError = exports.MixerSDKError = exports.ERROR_CODES = void 0;
+exports.ERROR_CODES = {
+    SIGNER_REQUIRED: "SIGNER_REQUIRED",
+    TRANSACTION: "TRANSACTION",
+    SUBGRAPH: "SUBGRAPH",
+    PROOF: "PROOF",
+    MULTICALL: "MULTICALL",
+};
+/**
+ * Base error for all SDK errors. Has optional code and cause for programmatic handling.
+ */
+class MixerSDKError extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name = "MixerSDKError";
+        this.code = options?.code;
+        this.cause = options?.cause;
+        Object.setPrototypeOf(this, MixerSDKError.prototype);
+    }
+}
+exports.MixerSDKError = MixerSDKError;
+/** Thrown when a write operation is attempted without a signer (wallet). */
+class SignerRequiredError extends MixerSDKError {
+    constructor(message = "Signer required for transactions") {
+        super(message, { code: exports.ERROR_CODES.SIGNER_REQUIRED });
+        this.name = "SignerRequiredError";
+        Object.setPrototypeOf(this, SignerRequiredError.prototype);
+    }
+}
+exports.SignerRequiredError = SignerRequiredError;
+/** Thrown when a transaction fails (missing hash, receipt timeout, revert). */
+class TransactionError extends MixerSDKError {
+    constructor(message, cause) {
+        super(message, { code: exports.ERROR_CODES.TRANSACTION, cause });
+        this.name = "TransactionError";
+        Object.setPrototypeOf(this, TransactionError.prototype);
+    }
+}
+exports.TransactionError = TransactionError;
+/** Thrown when subgraph request fails (HTTP or GraphQL errors). */
+class SubgraphError extends MixerSDKError {
+    constructor(message, options) {
+        super(message, { code: options?.code ?? exports.ERROR_CODES.SUBGRAPH, cause: options?.cause });
+        this.name = "SubgraphError";
+        this.status = options?.status;
+        Object.setPrototypeOf(this, SubgraphError.prototype);
+    }
+}
+exports.SubgraphError = SubgraphError;
+/** Thrown when proof generation or circuit fetch fails. */
+class ProofError extends MixerSDKError {
+    constructor(message, cause) {
+        super(message, { code: exports.ERROR_CODES.PROOF, cause });
+        this.name = "ProofError";
+        Object.setPrototypeOf(this, ProofError.prototype);
+    }
+}
+exports.ProofError = ProofError;
+/** Thrown when multicall aggregate or decode fails. */
+class MulticallError extends MixerSDKError {
+    constructor(message, cause) {
+        super(message, { code: exports.ERROR_CODES.MULTICALL, cause });
+        this.name = "MulticallError";
+        Object.setPrototypeOf(this, MulticallError.prototype);
+    }
+}
+exports.MulticallError = MulticallError;