bstest001 0.0.1

package/README.md

@@ -0,0 +1,22 @@
+# base SDK
+
+## test
+add to .env:
+```
+PRIVATE_KEY=[your private key]
+```
+
+Check balance:
+```bash
+bun example/test.ts balance
+```
+
+Deposit:
+```bash
+bun example/test.ts deposit
+```
+
+Withdraw:
+```bash
+bun example/test.ts withdraw
+```

package/dist/balance.d.ts

@@ -0,0 +1,7 @@
+export declare function getBalance({ provider: rawProvider, signature, address }: {
+    provider: any;
+    signature: string;
+    address: string;
+}): Promise<{
+    balance: string;
+}>;

package/dist/balance.js

@@ -0,0 +1,46 @@
+import { BigNumber, ethers } from 'ethers';
+import EtherPoolAbi from './utils/EtherPool.abi.json' with { type: 'json' };
+import { BASE_SEPOLIA_RPC, CONTRACT_ADDRESS } from './utils/constants.js';
+import { deriveKeys } from './utils/encryption.js';
+import { logger } from './utils/logger';
+import { findUnspentUtxos, toFixedHex } from './utils/utils.js';
+export async function getBalance({ provider: rawProvider, signature, address }) {
+    const provider = rawProvider?.request
+        ? new ethers.providers.Web3Provider(rawProvider)
+        : rawProvider;
+    // Use a dedicated JSON-RPC provider for contract reads so they always
+    // target the correct chain, regardless of which chain the wallet is on.
+    const readProvider = new ethers.providers.JsonRpcProvider(BASE_SEPOLIA_RPC);
+    const etherPoolAddress = CONTRACT_ADDRESS;
+    if (!etherPoolAddress) {
+        throw new Error('Missing CONTRACT_ADDRESS in environment');
+    }
+    const contractAddress = ethers.utils.getAddress(etherPoolAddress);
+    logger.debug(`Address: ${address}`);
+    logger.debug('Signing in to derive keys...');
+    const { encryptionKey, keypair } = deriveKeys(signature);
+    logger.debug(`UTXO pubkey: ${toFixedHex(keypair.pubkey)}`);
+    const etherPool = new ethers.Contract(contractAddress, EtherPoolAbi, readProvider);
+    const poolBalance = await readProvider.getBalance(etherPool.address);
+    logger.debug(`EtherPool: ${etherPool.address}`);
+    logger.debug(`Pool on-chain balance: ${ethers.utils.formatEther(poolBalance)} ETH`);
+    // Scan on-chain events and decrypt to find our UTXOs
+    logger.debug('Scanning on-chain events...');
+    const unspent = await findUnspentUtxos({
+        etherPool,
+        encryptionKey,
+        keypair
+    });
+    logger.debug(`Unspent UTXOs: ${unspent.length}`);
+    let total = BigNumber.from(0);
+    for (let i = 0; i < unspent.length; i++) {
+        const utxo = unspent[i];
+        logger.debug(`  #${i}: ${ethers.utils.formatEther(utxo.amount)} ETH (index: ${utxo.index})`);
+        total = total.add(utxo.amount);
+    }
+    let balance = ethers.utils.formatEther(total);
+    logger.debug(`\nTotal unspent: ${ethers.utils.formatEther(total)} ETH`);
+    return {
+        balance
+    };
+}

package/dist/deposit.d.ts

@@ -0,0 +1,8 @@
+export declare function deposit({ provider: rawProvider, depositAmountInput, keyBasePath, signature, address, txSender }: {
+    provider: any;
+    depositAmountInput: number;
+    keyBasePath: string;
+    signature: string;
+    address: string;
+    txSender: any;
+}): Promise<any>;

package/dist/deposit.js

@@ -0,0 +1,136 @@
+import { BigNumber, ethers } from 'ethers';
+import EtherPoolAbi from './utils/EtherPool.abi.json' with { type: 'json' };
+import { BASE_SEPOLIA_RPC, CONTRACT_ADDRESS, INDEXER_URL } from './utils/constants.js';
+import { deriveKeys } from './utils/encryption.js';
+import { logger } from './utils/logger';
+import { findUnspentUtxos, prepareTransaction, toFixedHex } from './utils/utils.js';
+import { Utxo } from './utils/utxo.js';
+export async function deposit({ provider: rawProvider, depositAmountInput, keyBasePath, signature, address, txSender }) {
+    const provider = rawProvider?.request
+        ? new ethers.providers.Web3Provider(rawProvider)
+        : rawProvider;
+    const readProvider = new ethers.providers.JsonRpcProvider(BASE_SEPOLIA_RPC);
+    const etherPoolAddress = CONTRACT_ADDRESS;
+    if (!etherPoolAddress) {
+        throw new Error('Missing CONTRACT_ADDRESS in environment');
+    }
+    const contractAddress = ethers.utils.getAddress(etherPoolAddress);
+    logger.debug(`Depositor: ${address}`);
+    logger.info('Signing in to derive keys...');
+    const { encryptionKey, keypair } = deriveKeys(signature);
+    logger.debug(`UTXO pubkey: ${toFixedHex(keypair.pubkey)}`);
+    const etherPool = new ethers.Contract(contractAddress, EtherPoolAbi, readProvider);
+    const poolBalance = await readProvider.getBalance(etherPool.address);
+    logger.debug(`EtherPool: ${etherPool.address}`);
+    logger.debug(`Pool balance: ${ethers.utils.formatEther(poolBalance)} ETH`);
+    const depositAmount = ethers.utils.parseEther(depositAmountInput.toString());
+    const maxDeposit = await etherPool.maximumDepositAmount();
+    if (depositAmount.gt(maxDeposit)) {
+        throw new Error(`Deposit amount ${depositAmountInput} ETH exceeds pool limit of ${ethers.utils.formatEther(maxDeposit)} ETH`);
+    }
+    // post address to /screen_address of indexer to check if it's blacklisted
+    logger.debug(`screening address ${address}`);
+    let res = await fetch(INDEXER_URL + '/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.');
+    }
+    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,
+        encryptionKey,
+        keypair
+    });
+    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);
+        logger.debug(`Using 2 existing UTXOs as inputs (${ethers.utils.formatEther(inputSum)} ETH)`);
+    }
+    else if (unspent.length === 1) {
+        inputs = [unspent[0]];
+        inputSum = inputs[0].amount;
+        logger.debug(`Using 1 existing UTXO as input (${ethers.utils.formatEther(inputSum)} ETH)`);
+    }
+    else {
+        logger.debug('No existing UTXOs, creating fresh deposit');
+    }
+    const outputAmount = inputSum.add(depositAmount);
+    const outputUtxo = new Utxo({ amount: outputAmount, keypair });
+    logger.debug(`Depositing ${depositAmountInput} ETH (new output: ${ethers.utils.formatEther(outputAmount)} ETH)`);
+    const { args, extData } = await prepareTransaction({
+        inputs,
+        outputs: [outputUtxo],
+        encryptionKey,
+        keyBasePath,
+    });
+    // Build the transaction (Populate)
+    logger.info('Building transaction...');
+    const partialTx = await etherPool.populateTransaction.transact(args, extData, {
+        value: depositAmount,
+        gasLimit: 3000000,
+    });
+    const [network, nonce, feeData] = await Promise.all([
+        readProvider.getNetwork(),
+        readProvider.getTransactionCount(address, 'pending'),
+        readProvider.getFeeData(),
+    ]);
+    const unsignedTx = {
+        ...partialTx,
+        nonce,
+        chainId: network.chainId,
+    };
+    if (feeData.gasPrice) {
+        unsignedTx.gasPrice = feeData.gasPrice;
+    }
+    else {
+        throw new Error('Failed to fetch network fee data for transaction signing');
+    }
+    try {
+        let tx = await txSender(unsignedTx);
+        logger.info(`Transaction sent!`);
+        logger.debug('veryfying transaction on indexer...', extData.encryptedOutput1);
+        let retryTimes = 0;
+        let itv = 2;
+        // const encryptedOutputStr = Buffer.from(extData.encryptedOutput1).toString('hex')
+        let start = Date.now();
+        while (true) {
+            logger.debug('Confirming transaction..');
+            logger.debug(`retryTimes: ${retryTimes}`);
+            await new Promise(resolve => setTimeout(resolve, itv * 1000));
+            logger.debug('Fetching updated onchain state...');
+            // post to /check_encrypted_output with body encryptedOutput: extData.encryptedOutput1
+            let res = await fetch(INDEXER_URL + '/check_encrypted_output', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ encryptedOutput: extData.encryptedOutput1 }),
+            });
+            let resJson = await res.json();
+            if (resJson.exists) {
+                logger.debug(`Top up successfully in ${((Date.now() - start) / 1000).toFixed(2)} seconds!`);
+                // break while true loop
+                break;
+            }
+            if (retryTimes >= 10) {
+                throw new Error('Refresh the page to see latest balance.');
+            }
+            retryTimes++;
+        }
+        return tx;
+    }
+    catch (e) {
+        logger.error('Transaction failed:', e);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { getBalance } from './balance.js';
+export { deposit } from './deposit.js';
+export { setLogger } from './utils/logger.js';
+export { withdraw } from './withdraw.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { getBalance } from './balance.js';
+export { deposit } from './deposit.js';
+export { setLogger } from './utils/logger.js';
+export { withdraw } from './withdraw.js';