testprivacycash-evm 1.2.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,55 @@
+name: Publish to npm when version changes
+
+on:
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - "package.json"
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org/
+
+      - name: Get current package version
+        id: pkg
+        run: echo "version=$(node -p 'require(\"./package.json\").version')" >> $GITHUB_OUTPUT
+
+      - name: Check if version already exists on npm
+        id: check
+        run: |
+          PKG_NAME=$(node -p 'require("./package.json").name')
+          PUBLISHED=$(npm view $PKG_NAME versions --json | grep -o "\"${{ steps.pkg.outputs.version }}\"" || true)
+          if [ -n "$PUBLISHED" ]; then
+            echo "exists=true" >> $GITHUB_OUTPUT
+            echo "Version ${{ steps.pkg.outputs.version }} already exists on npm. Skipping publish."
+          else
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build source
+        run: npm run build || echo "No build script defined."
+
+      - name: Publish to npm
+        if: steps.check.outputs.exists == 'false'
+        run: |
+          echo "Publishing version ${{ steps.pkg.outputs.version }}..."
+          npm publish --access public

package/README.md

@@ -0,0 +1,17 @@
+# Base SDK
+This is the SDK for Privacy Cash on Base. For documentation, please check: https://privacycash.mintlify.app/basesdk/frontend
+
+The SDK also supports BNB mainnet native BNB through `BNB_NETWORK` (chain ID
+56). Pass `token: 'bnb'` explicitly, or omit `token` when `network` is
+`BNB_NETWORK`. BNB USDT is not supported yet.
+
+Run `bun example/bnb-bnb.ts balance` for the BNB SDK example. Deposit and
+withdraw actions require an amount and `BNB_PRIVATE_KEY`. The Base and Ethereum
+examples continue to use `PRIVATE_KEY`.
+
+### Disclaimer
+This SDK powers Privacy Cash's frontend, assuming the single wallet use case. It is NOT supposed to support hardware wallet.
+
+If you use it or published npm library from this repo, please fully test and beware of the inherent software risks or potential bugs. Our team is not responsible for any losses.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/balance.d.ts

@@ -0,0 +1,10 @@
+import { NetworkConfig, PrivacyToken } from './utils/networkConfig.js';
+export declare function getBalance({ signature, address, offset, token, network }: {
+    signature: string;
+    address: string;
+    offset?: number;
+    token?: PrivacyToken;
+    network?: NetworkConfig | number;
+}): Promise<{
+    balance: string;
+}>;

package/dist/balance.js

@@ -0,0 +1,57 @@
+import { BigNumber, ethers } from 'ethers';
+import ERCPoolAbi from './utils/ERCPool.abi.json' with { type: 'json' };
+import EtherPoolAbi from './utils/EtherPool.abi.json' with { type: 'json' };
+import { deriveKeys } from './utils/encryption.js';
+import { logger } from './utils/logger.js';
+import { getErc20TokenConfig, resolveNetwork, resolvePrivacyToken } from './utils/networkConfig.js';
+import { findUnspentUtxos, toFixedHex } from './utils/utils.js';
+export async function getBalance({ signature, address, offset, token, network }) {
+    const net = resolveNetwork(network);
+    const resolvedToken = resolvePrivacyToken(net, token);
+    const readProvider = new ethers.providers.JsonRpcProvider(net.rpcUrl, {
+        name: net.chainKey,
+        chainId: net.chainId,
+    });
+    const erc20Token = getErc20TokenConfig(net, resolvedToken);
+    const isErc20 = erc20Token !== null;
+    const tokenSymbol = erc20Token?.symbol ?? net.nativeSymbol ?? (net.chainKey === 'bnb' ? 'BNB' : 'ETH');
+    const tokenDecimals = erc20Token?.decimals ?? 18;
+    const contractAddress = ethers.utils.getAddress(erc20Token ? erc20Token.poolAddress : net.etherPoolAddress);
+    const abi = isErc20 ? ERCPoolAbi : EtherPoolAbi;
+    logger.debug(`Address: ${address}`);
+    logger.debug('Signing in to derive keys...');
+    const { encryptionKey, keypair } = deriveKeys(signature);
+    logger.debug(`UTXO pubkey: ${toFixedHex(keypair.pubkey)}`);
+    const pool = new ethers.Contract(contractAddress, abi, readProvider);
+    if (!isErc20) {
+        const poolBalance = await readProvider.getBalance(pool.address);
+        logger.debug(`EtherPool: ${pool.address}`);
+        logger.debug(`Pool on-chain balance: ${ethers.utils.formatEther(poolBalance)} ${tokenSymbol}`);
+    }
+    // Scan on-chain events and decrypt to find our UTXOs
+    logger.debug('Scanning on-chain events...');
+    const unspent = await findUnspentUtxos({
+        etherPool: pool,
+        encryptionKey,
+        keypair,
+        address,
+        start: offset || 0,
+        token: resolvedToken,
+        network: net,
+    });
+    logger.debug(`Unspent UTXOs: ${unspent.length}`);
+    let total = BigNumber.from(0);
+    for (let i = 0; i < unspent.length; i++) {
+        const utxo = unspent[i];
+        const formatted = isErc20
+            ? ethers.utils.formatUnits(utxo.amount, tokenDecimals)
+            : ethers.utils.formatEther(utxo.amount);
+        logger.debug(`  #${i}: ${formatted} ${tokenSymbol} (index: ${utxo.index})`);
+        total = total.add(utxo.amount);
+    }
+    const balance = isErc20
+        ? ethers.utils.formatUnits(total, tokenDecimals)
+        : ethers.utils.formatEther(total);
+    logger.debug(`\nTotal unspent: ${balance} ${tokenSymbol}`);
+    return { balance };
+}

package/dist/deposit.d.ts

@@ -0,0 +1,10 @@
+import { NetworkConfig, PrivacyToken } from './utils/networkConfig.js';
+export declare function deposit({ depositAmountInput, keyBasePath, signature, address, txSender, token, network }: {
+    depositAmountInput: number;
+    keyBasePath: string;
+    signature: string;
+    address: string;
+    txSender: any;
+    token?: PrivacyToken;
+    network?: NetworkConfig | number;
+}): Promise<any>;

package/dist/deposit.js

@@ -0,0 +1,345 @@
+import { BigNumber, ethers } from 'ethers';
+import ERCPoolAbi from './utils/ERCPool.abi.json' with { type: 'json' };
+import EtherPoolAbi from './utils/EtherPool.abi.json' with { type: 'json' };
+import { deriveKeys } from './utils/encryption.js';
+import { logger } from './utils/logger.js';
+import { getErc20TokenConfig, resolveNetwork, resolvePrivacyToken } from './utils/networkConfig.js';
+import { getRemoteConfig } from './utils/remoteConfig.js';
+import { findUnspentUtxos, prepareTransaction, toFixedHex } from './utils/utils.js';
+import { Utxo } from './utils/utxo.js';
+function getFeeBumpPercent() {
+    const value = Number(process.env.NEXT_PUBLIC_EVM_FEE_BUMP_PERCENT || process.env.EVM_FEE_BUMP_PERCENT);
+    if (Number.isFinite(value) && value >= 100)
+        return Math.floor(value);
+    return 110;
+}
+function bumpFee(value, percent = getFeeBumpPercent()) {
+    return value.mul(percent).div(100);
+}
+const MAX_PRIORITY_FEE_GWEI = process.env.NEXT_PUBLIC_MAX_PRIORITY_FEE_GWEI || process.env.MAX_PRIORITY_FEE_GWEI || '0.6';
+const MAX_PRIORITY_FEE = ethers.utils.parseUnits(MAX_PRIORITY_FEE_GWEI, 'gwei');
+function formatGwei(value) {
+    return value ? ethers.utils.formatUnits(value, 'gwei') : 'null';
+}
+function getGasLimitBumpPercent() {
+    const value = Number(process.env.NEXT_PUBLIC_EVM_GAS_LIMIT_BUMP_PERCENT || process.env.EVM_GAS_LIMIT_BUMP_PERCENT);
+    if (Number.isFinite(value) && value >= 100)
+        return Math.floor(value);
+    return 120;
+}
+function bumpGasLimit(value, percent = getGasLimitBumpPercent()) {
+    return value.mul(percent).add(99).div(100);
+}
+function getMinPriorityFee(net) {
+    const configured = process.env.NEXT_PUBLIC_ETH_MIN_PRIORITY_FEE_GWEI || process.env.ETH_MIN_PRIORITY_FEE_GWEI;
+    const gwei = configured || (net.chainKey === 'eth' ? '0.2' : '');
+    return gwei ? ethers.utils.parseUnits(gwei, 'gwei') : null;
+}
+function selectPriorityFee(providerPriorityFee, minPriorityFee) {
+    const priorityFee = providerPriorityFee && !providerPriorityFee.isZero()
+        ? providerPriorityFee
+        : (minPriorityFee ?? BigNumber.from(0));
+    return priorityFee.gt(MAX_PRIORITY_FEE) ? MAX_PRIORITY_FEE : priorityFee;
+}
+async function getFeeOverrides(net, provider, feeData) {
+    feeData ??= await provider.getFeeData();
+    // BNB Smart Chain's legacy gasPrice is the most widely supported path.
+    if (net.chainKey === 'bnb' && feeData.gasPrice) {
+        return { gasPrice: bumpFee(feeData.gasPrice) };
+    }
+    if (feeData.maxFeePerGas || feeData.maxPriorityFeePerGas) {
+        const minPriorityFee = getMinPriorityFee(net);
+        logger.debug(`Deposit feeData: gasPrice=${formatGwei(feeData.gasPrice)} gwei, ` +
+            `maxFeePerGas=${formatGwei(feeData.maxFeePerGas)} gwei, ` +
+            `maxPriorityFeePerGas=${formatGwei(feeData.maxPriorityFeePerGas)} gwei, ` +
+            `lastBaseFeePerGas=${formatGwei(feeData.lastBaseFeePerGas)} gwei, ` +
+            `defaultMinPriorityFee=${formatGwei(minPriorityFee)} gwei, ` +
+            `maxPriorityFeeCap=${MAX_PRIORITY_FEE_GWEI} gwei, ` +
+            `feeBumpPercent=${getFeeBumpPercent()}`);
+        const priorityFee = selectPriorityFee(feeData.maxPriorityFeePerGas, minPriorityFee);
+        if (priorityFee.isZero()) {
+            throw new Error('Failed to fetch network priority fee data');
+        }
+        let maxFeeBase = feeData.maxFeePerGas;
+        let fallbackBaseFee = null;
+        if (!maxFeeBase) {
+            const latestBlock = await provider.getBlock('latest');
+            fallbackBaseFee = latestBlock?.baseFeePerGas ?? null;
+            maxFeeBase = latestBlock?.baseFeePerGas
+                ? latestBlock.baseFeePerGas.mul(2).add(priorityFee)
+                : null;
+        }
+        if (!maxFeeBase) {
+            throw new Error('Failed to fetch network max fee data');
+        }
+        const maxFeePerGas = bumpFee(maxFeeBase);
+        const finalMaxFeePerGas = maxFeePerGas.gt(priorityFee) ? maxFeePerGas : priorityFee.mul(2);
+        logger.debug(`Deposit fee overrides: selectedPriorityFee=${formatGwei(priorityFee)} gwei, ` +
+            `fallbackLatestBaseFee=${formatGwei(fallbackBaseFee)} gwei, ` +
+            `maxFeeBase=${formatGwei(maxFeeBase)} gwei, ` +
+            `finalMaxFeePerGas=${formatGwei(finalMaxFeePerGas)} gwei`);
+        return {
+            type: 2,
+            maxPriorityFeePerGas: priorityFee,
+            maxFeePerGas: finalMaxFeePerGas,
+        };
+    }
+    if (feeData.gasPrice) {
+        const gasPrice = bumpFee(feeData.gasPrice);
+        logger.debug(`Deposit legacy feeData: providerGasPrice=${formatGwei(feeData.gasPrice)} gwei, ` +
+            `finalGasPrice=${formatGwei(gasPrice)} gwei, feeBumpPercent=${getFeeBumpPercent()}`);
+        return { gasPrice };
+    }
+    throw new Error('Failed to fetch network fee data');
+}
+async function estimateTransactGasLimit({ pool, args, extData, estimateOverrides, fallback, }) {
+    try {
+        const estimated = await pool.estimateGas.transact(args, extData, estimateOverrides);
+        const gasLimit = bumpGasLimit(estimated);
+        logger.debug(`Estimated transact gas: ${estimated.toString()} (using limit ${gasLimit.toString()})`);
+        return gasLimit;
+    }
+    catch (err) {
+        logger.warn(`Failed to estimate transact gas; using fallback ${fallback.toString()}. Error:`, err);
+        return fallback;
+    }
+}
+export async function deposit({ depositAmountInput, keyBasePath, signature, address, txSender, token, network }) {
+    const net = resolveNetwork(network);
+    const resolvedToken = resolvePrivacyToken(net, token);
+    const readProvider = new ethers.providers.JsonRpcProvider(net.rpcUrl, {
+        name: net.chainKey,
+        chainId: net.chainId,
+    });
+    const erc20Token = getErc20TokenConfig(net, resolvedToken);
+    const isErc20 = erc20Token !== null;
+    const tokenSymbol = erc20Token?.symbol ?? net.nativeSymbol ?? (net.chainKey === 'bnb' ? 'BNB' : 'ETH');
+    const tokenDecimals = erc20Token?.decimals ?? 18;
+    const remoteConfig = await getRemoteConfig(net);
+    const minDeposit = remoteConfig.minimum_deposit[resolvedToken];
+    if (isErc20) {
+        if (depositAmountInput < minDeposit) {
+            throw new Error(`Deposit amount must be at least ${minDeposit} ${tokenSymbol}`);
+        }
+    }
+    else {
+        if (depositAmountInput < minDeposit) {
+            throw new Error(`Deposit amount must be at least ${minDeposit} ${tokenSymbol}`);
+        }
+    }
+    const poolAddress = ethers.utils.getAddress(erc20Token ? erc20Token.poolAddress : net.etherPoolAddress);
+    const abi = isErc20 ? ERCPoolAbi : EtherPoolAbi;
+    logger.debug(`Depositor: ${address}`);
+    const { encryptionKey, keypair } = deriveKeys(signature);
+    logger.debug(`UTXO pubkey: ${toFixedHex(keypair.pubkey)}`);
+    const pool = new ethers.Contract(poolAddress, abi, readProvider);
+    if (!isErc20) {
+        const poolBalance = await readProvider.getBalance(pool.address);
+        logger.debug(`EtherPool: ${pool.address}`);
+        logger.debug(`Pool balance: ${ethers.utils.formatEther(poolBalance)} ${tokenSymbol}`);
+    }
+    const depositAmount = isErc20
+        ? ethers.utils.parseUnits(depositAmountInput.toString(), tokenDecimals)
+        : ethers.utils.parseEther(depositAmountInput.toString());
+    const maxDeposit = await pool.maximumDepositAmount();
+    if (depositAmount.gt(maxDeposit)) {
+        const formatted = isErc20
+            ? `${ethers.utils.formatUnits(maxDeposit, tokenDecimals)} ${tokenSymbol}`
+            : `${ethers.utils.formatEther(maxDeposit)} ${tokenSymbol}`;
+        throw new Error(`Please deposit less than ${formatted}`);
+    }
+    // post address to /screen_address of indexer to check if it's blacklisted
+    logger.info('screening wallet');
+    logger.debug(`screening address ${address}`);
+    try {
+        let res = await fetch(net.indexerUrl + '/screen_address', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ address }),
+        });
+        let resJson = await res.json();
+        if (resJson.isRisk) {
+            throw new Error('Your wallet address is risky. Service rejected.', { cause: { type: 'RISKY_ADDRESS' } });
+        }
+    }
+    catch (err) {
+        if (err.cause?.type === 'RISKY_ADDRESS') {
+            throw err;
+        }
+        logger.error('Failed to screen address, but proceeding with deposit. Error:', err);
+    }
+    logger.debug('Address screening passed');
+    // Scan on-chain events to find unspent UTXOs
+    logger.debug('Scanning on-chain events for unspent UTXOs...');
+    const unspent = await findUnspentUtxos({
+        etherPool: pool,
+        encryptionKey,
+        keypair,
+        address,
+        token: resolvedToken,
+        network: net,
+    });
+    logger.debug(`Unspent UTXOs found: ${unspent.length}`);
+    let inputs = [];
+    let inputSum = BigNumber.from(0);
+    if (unspent.length >= 2) {
+        inputs = [unspent[0], unspent[1]];
+        inputSum = inputs[0].amount.add(inputs[1].amount);
+    }
+    else if (unspent.length === 1) {
+        inputs = [unspent[0]];
+        inputSum = inputs[0].amount;
+    }
+    const outputAmount = inputSum.add(depositAmount);
+    // For ERC20 pools, embed the token contract address as mintAddress in the UTXO.
+    const mintAddress = erc20Token ? BigNumber.from(erc20Token.tokenAddress) : BigNumber.from(0);
+    const outputUtxo = new Utxo({ amount: outputAmount, keypair, mintAddress });
+    const formattedOutput = isErc20
+        ? `${ethers.utils.formatUnits(outputAmount, tokenDecimals)} ${tokenSymbol}`
+        : `${ethers.utils.formatEther(outputAmount)} ${tokenSymbol}`;
+    logger.debug(`Depositing ${depositAmountInput} ${tokenSymbol} (new output: ${formattedOutput})`);
+    if (isErc20 && erc20Token) {
+        // Step 1: send ERC20 approve tx first, BEFORE generating the ZK proof.
+        // The proof fetches the Merkle root; if we generate it before the approve
+        // is mined the root can advance while waiting, causing proof verification
+        // to fail on-chain.
+        const erc20Abi = [
+            'function allowance(address owner, address spender) view returns (uint256)',
+            'function approve(address spender, uint256 amount) returns (bool)',
+        ];
+        const erc20 = new ethers.Contract(erc20Token.tokenAddress, erc20Abi, readProvider);
+        const [network, feeData] = await Promise.all([
+            readProvider.getNetwork(),
+            readProvider.getFeeData(),
+        ]);
+        const feeOverrides = await getFeeOverrides(net, readProvider, feeData);
+        const allowance = await erc20.allowance(address, poolAddress);
+        logger.debug(`Current ${tokenSymbol} allowance: ${ethers.utils.formatUnits(allowance, tokenDecimals)} ${tokenSymbol}`);
+        if (allowance.lt(depositAmount)) {
+            if (resolvedToken === 'usdt' && allowance.gt(0)) {
+                const resetApproveTx = await erc20.populateTransaction.approve(poolAddress, 0);
+                const unsignedResetApproveTx = {
+                    ...resetApproveTx,
+                    chainId: network.chainId,
+                    ...feeOverrides,
+                };
+                logger.info('waiting for user signature [approve-reset]');
+                await txSender(unsignedResetApproveTx, { stage: 'approve-reset', token: resolvedToken, chain: net.chainKey });
+            }
+            const approveTx = await erc20.populateTransaction.approve(poolAddress, depositAmount);
+            const unsignedApproveTx = {
+                ...approveTx,
+                chainId: network.chainId,
+                ...feeOverrides,
+            };
+            logger.info('waiting for user signature [approve]');
+            await txSender(unsignedApproveTx, { stage: 'approve', token: resolvedToken, chain: net.chainKey });
+        }
+        else {
+            logger.info(`${tokenSymbol} allowance is sufficient; skipping approve`);
+        }
+        // txSender is expected to wait for the approve to be mined before returning
+        // (the UI's txSender calls waitForTransactionReceipt for ERC20 deposits).
+        // Step 2: generate ZK proof with a fresh Merkle root now that approve is confirmed
+        logger.info('generating ZK proof');
+        const { args, extData } = await prepareTransaction({
+            inputs,
+            outputs: [outputUtxo],
+            encryptionKey,
+            keyBasePath,
+            token: resolvedToken,
+            network: net,
+        });
+        // Step 3: send transact tx (no ETH value for ERC pool)
+        const gasLimit = await estimateTransactGasLimit({
+            pool,
+            args,
+            extData,
+            estimateOverrides: { from: address },
+            fallback: BigNumber.from(2000000),
+        });
+        const partialTx = await pool.populateTransaction.transact(args, extData, { gasLimit });
+        const [network2, feeData2] = await Promise.all([
+            readProvider.getNetwork(),
+            readProvider.getFeeData(),
+        ]);
+        const unsignedTx = {
+            ...partialTx,
+            chainId: network2.chainId,
+            ...(await getFeeOverrides(net, readProvider, feeData2)),
+        };
+        logger.info('waiting for user signature [deposit]');
+        const tx = await txSender(unsignedTx, { stage: 'deposit', token: resolvedToken, chain: net.chainKey });
+        logger.info('confirming transaction');
+        await confirmEncryptedOutput(extData.encryptedOutput1, resolvedToken, net);
+        return tx;
+    }
+    else {
+        logger.info('generating ZK proof');
+        const { args, extData } = await prepareTransaction({
+            inputs,
+            outputs: [outputUtxo],
+            encryptionKey,
+            keyBasePath,
+            token: resolvedToken,
+            network: net,
+        });
+        const gasLimit = await estimateTransactGasLimit({
+            pool,
+            args,
+            extData,
+            estimateOverrides: {
+                from: address,
+                value: depositAmount,
+            },
+            fallback: BigNumber.from(3000000),
+        });
+        const partialTx = await pool.populateTransaction.transact(args, extData, {
+            value: depositAmount,
+            gasLimit,
+        });
+        const [network, nonce, feeData] = await Promise.all([
+            readProvider.getNetwork(),
+            readProvider.getTransactionCount(address, 'pending'),
+            readProvider.getFeeData(),
+        ]);
+        const unsignedTx = {
+            ...partialTx,
+            nonce,
+            chainId: network.chainId,
+        };
+        Object.assign(unsignedTx, await getFeeOverrides(net, readProvider, feeData));
+        logger.info('waiting for user signature [deposit]');
+        const tx = await txSender(unsignedTx);
+        logger.info('confirming transaction');
+        await confirmEncryptedOutput(extData.encryptedOutput1, resolvedToken, net);
+        return tx;
+    }
+}
+async function confirmEncryptedOutput(encryptedOutput1, token, net) {
+    logger.debug('verifying transaction on indexer...', encryptedOutput1);
+    let retryTimes = 0;
+    const intervalMs = 3000;
+    const maxRetries = 10;
+    const start = Date.now();
+    while (true) {
+        logger.debug('Confirming transaction..');
+        logger.debug(`retryTimes: ${retryTimes}`);
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+        logger.debug('Fetching updated onchain state...');
+        let res = await fetch(net.indexerUrl + '/check_encrypted_output', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ encryptedOutput: encryptedOutput1, token, chain: net.chainKey }),
+        });
+        let resJson = await res.json();
+        if (resJson.exists) {
+            logger.debug(`Top up successfully in ${((Date.now() - start) / 1000).toFixed(2)} seconds!`);
+            break;
+        }
+        if (retryTimes >= maxRetries) {
+            throw new Error('Refresh the page to see latest balance.');
+        }
+        retryTimes++;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { getBalance } from './balance.js';
+export { deposit } from './deposit.js';
+export { setLogger } from './utils/logger.js';
+export { getRemoteConfig } from './utils/remoteConfig.js';
+export type { FeeSnapshot, RemoteConfig } from './utils/remoteConfig.js';
+export { withdraw } from './withdraw.js';
+export { FEE_RECIPIENT_ADDRESS, INDEXER_URL, PRIVATE_USDC_CONTRACT_ADDRESS, USDC_CONTRACT_ADDRESS, USDC_DECIMALS } from './utils/constants.js';
+export { clearCache } from './utils/utils.js';
+export { BASE_NETWORK, BNB_NETWORK, ETH_NETWORK, getDefaultNetworkConfig, getNetworkConfig, NETWORKS, resolveNetwork } from './utils/networkConfig.js';
+export type { Erc20Token, NativeToken, NetworkConfig, PrivacyToken, SupportedChain } from './utils/networkConfig.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { getBalance } from './balance.js';
+export { deposit } from './deposit.js';
+export { setLogger } from './utils/logger.js';
+export { getRemoteConfig } from './utils/remoteConfig.js';
+export { withdraw } from './withdraw.js';
+export { FEE_RECIPIENT_ADDRESS, INDEXER_URL, PRIVATE_USDC_CONTRACT_ADDRESS, USDC_CONTRACT_ADDRESS, USDC_DECIMALS } from './utils/constants.js';
+export { clearCache } from './utils/utils.js';
+export { BASE_NETWORK, BNB_NETWORK, ETH_NETWORK, getDefaultNetworkConfig, getNetworkConfig, NETWORKS, resolveNetwork } from './utils/networkConfig.js';