@adelos/sdk 0.1.2 → 0.1.5

package/dist/index.mjs

@@ -1,41 +1,36 @@
 // src/index.ts
 import {
-  Connection as Connection3,
-  PublicKey as PublicKey5,
+  Connection as Connection2,
+  PublicKey as PublicKey4,
   SystemProgram,
-  Transaction as Transaction2,
-  TransactionInstruction as TransactionInstruction2,
+  Transaction,
+  TransactionInstruction,
   TransactionMessage,
   VersionedTransaction
 } from "@solana/web3.js";
 
 // src/constants.ts
 import { PublicKey, clusterApiUrl } from "@solana/web3.js";
-var PROGRAM_IDS = {
-  devnet: new PublicKey("7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp"),
-  "mainnet-beta": new PublicKey("7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp"),
-  // Update when deployed to mainnet
-  localnet: new PublicKey("7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp")
-};
-var RPC_URLS = {
-  devnet: clusterApiUrl("devnet"),
-  "mainnet-beta": clusterApiUrl("mainnet-beta"),
-  localnet: "http://localhost:8899"
+var ADELOS_CONFIG = {
+  PROGRAM_ID: new PublicKey("7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp"),
+  RPC_URL: clusterApiUrl("devnet"),
+  MEMO_PROGRAM_ID: new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
+  REGISTRY_SEED: "registry",
+  MEMO_PREFIX: "ADLSv1:",
+  STEALTH_DOMAIN: "adelos:stealth:v1"
 };
-var PROGRAM_ID = PROGRAM_IDS.devnet;
-var MEMO_PROGRAM_ID = new PublicKey(
-  "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
-);
-var REGISTRY_SEED = "registry";
-var REGISTRY_ACCOUNT_SIZE = 8 + 32 + 32 + 1;
-var MEMO_PREFIX = "ADLSv1:";
-var STEALTH_DOMAIN = "adelos:stealth:v1";
+var PROGRAM_ID = ADELOS_CONFIG.PROGRAM_ID;
+var RPC_URL = ADELOS_CONFIG.RPC_URL;
+var MEMO_PROGRAM_ID = ADELOS_CONFIG.MEMO_PROGRAM_ID;
+var REGISTRY_SEED = ADELOS_CONFIG.REGISTRY_SEED;
+var MEMO_PREFIX = ADELOS_CONFIG.MEMO_PREFIX;
+var STEALTH_DOMAIN = ADELOS_CONFIG.STEALTH_DOMAIN;
 
 // src/utils.ts
 import { PublicKey as PublicKey2 } from "@solana/web3.js";
-function deriveRegistryPda(owner, programId = PROGRAM_ID) {
+function deriveRegistryPda(owner, programId = ADELOS_CONFIG.PROGRAM_ID) {
   return PublicKey2.findProgramAddressSync(
-    [Buffer.from(REGISTRY_SEED), owner.toBuffer()],
+    [Buffer.from(ADELOS_CONFIG.REGISTRY_SEED), owner.toBuffer()],
     programId
   );
 }
@@ -308,65 +303,52 @@ var IDL = {
 
 // src/crypto.ts
 import { sha256 } from "@noble/hashes/sha256";
+import { sha512 } from "@noble/hashes/sha512";
 import * as ed from "@noble/ed25519";
+ed.etc.sha512Sync = (...m) => {
+  const h = sha512.create();
+  m.forEach((msg) => h.update(msg));
+  return h.digest();
+};
+var encoder = new TextEncoder();
 function generateEphemeralKeypair() {
   const secretKey = ed.utils.randomPrivateKey();
-  const publicKey = ed.getPublicKey(secretKey);
-  return { secretKey, publicKey };
+  return { secretKey, publicKey: ed.getPublicKey(secretKey) };
 }
-async function computeSharedSecret(ephemeralSk, recipientMetaPubkey) {
-  const point = ed.ExtendedPoint.fromHex(recipientMetaPubkey);
-  const scalar = ed.etc.mod(
-    BigInt("0x" + bytesToHex(ephemeralSk)),
-    ed.CURVE.n
-  );
-  const sharedPoint = point.multiply(scalar);
-  const sharedBytes = sharedPoint.toRawBytes();
-  return sha256(sharedBytes);
+function computeSharedSecret(ephemeralSk, recipientMetaPk) {
+  const point = ed.ExtendedPoint.fromHex(bytesToHex(recipientMetaPk));
+  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(ephemeralSk)), ed.CURVE.n);
+  return sha256(point.multiply(scalar).toRawBytes());
 }
-function deriveStealthPubkey(metaPubkey, sharedSecret) {
-  const scalarBytes = sha256(
-    new Uint8Array([...sharedSecret, ...Buffer.from(STEALTH_DOMAIN)])
-  );
-  const scalar = ed.etc.mod(
-    BigInt("0x" + bytesToHex(scalarBytes)),
-    ed.CURVE.n
-  );
-  const scalarTimesG = ed.ExtendedPoint.BASE.multiply(scalar);
-  const metaPoint = ed.ExtendedPoint.fromHex(metaPubkey);
-  const stealthPoint = metaPoint.add(scalarTimesG);
+function computeSharedSecretAsRecipient(metaSk, ephemeralPk) {
+  const secretKey = metaSk.length === 64 ? metaSk.slice(0, 32) : metaSk;
+  const point = ed.ExtendedPoint.fromHex(bytesToHex(ephemeralPk));
+  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(secretKey)), ed.CURVE.n);
+  return sha256(point.multiply(scalar).toRawBytes());
+}
+function deriveStealthPubkey(metaPk, sharedSecret) {
+  const domain = encoder.encode(ADELOS_CONFIG.STEALTH_DOMAIN);
+  const scalarBytes = sha256(new Uint8Array([...sharedSecret, ...domain]));
+  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(scalarBytes)), ed.CURVE.n);
+  const metaPoint = ed.ExtendedPoint.fromHex(bytesToHex(metaPk));
+  const stealthPoint = metaPoint.add(ed.ExtendedPoint.BASE.multiply(scalar));
   return stealthPoint.toRawBytes();
 }
 function recoverStealthSecretKey(metaSk, sharedSecret) {
-  const scalarBytes = sha256(
-    new Uint8Array([...sharedSecret, ...Buffer.from(STEALTH_DOMAIN)])
-  );
-  const scalar = ed.etc.mod(
-    BigInt("0x" + bytesToHex(scalarBytes)),
-    ed.CURVE.n
-  );
-  const metaScalar = ed.etc.mod(
-    BigInt("0x" + bytesToHex(metaSk)),
-    ed.CURVE.n
-  );
+  const domain = encoder.encode(ADELOS_CONFIG.STEALTH_DOMAIN);
+  const scalarBytes = sha256(new Uint8Array([...sharedSecret, ...domain]));
+  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(scalarBytes)), ed.CURVE.n);
+  const metaScalar = ed.etc.mod(BigInt("0x" + bytesToHex(metaSk)), ed.CURVE.n);
   const stealthScalar = ed.etc.mod(metaScalar + scalar, ed.CURVE.n);
   const hex = stealthScalar.toString(16).padStart(64, "0");
   return hexToBytes(hex);
 }
-async function computeSharedSecretAsRecipient(metaSk, ephemeralPubkey) {
-  const point = ed.ExtendedPoint.fromHex(ephemeralPubkey);
-  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(metaSk)), ed.CURVE.n);
-  const sharedPoint = point.multiply(scalar);
-  const sharedBytes = sharedPoint.toRawBytes();
-  return sha256(sharedBytes);
-}
 function generateStealthMemo(ephemeralPubkey) {
-  const pubkeyHex = bytesToHex(ephemeralPubkey);
-  return `${MEMO_PREFIX}${pubkeyHex}`;
+  return `${ADELOS_CONFIG.MEMO_PREFIX}${bytesToHex(ephemeralPubkey)}`;
 }
 function parseStealthMemo(memo) {
-  if (!memo.startsWith(MEMO_PREFIX)) return null;
-  const pubkeyHex = memo.slice(MEMO_PREFIX.length);
+  if (!memo.startsWith(ADELOS_CONFIG.MEMO_PREFIX)) return null;
+  const pubkeyHex = memo.slice(ADELOS_CONFIG.MEMO_PREFIX.length);
   if (pubkeyHex.length !== 64) return null;
   try {
     return hexToBytes(pubkeyHex);
@@ -374,618 +356,115 @@ function parseStealthMemo(memo) {
     return null;
   }
 }
-async function generateStealthAddress(recipientMetaPubkey) {
+function generateStealthAddress(recipientMetaPk) {
   const ephemeralKeypair = generateEphemeralKeypair();
-  const sharedSecret = await computeSharedSecret(
-    ephemeralKeypair.secretKey,
-    recipientMetaPubkey
-  );
-  const stealthPubkey = deriveStealthPubkey(recipientMetaPubkey, sharedSecret);
+  const sharedSecret = computeSharedSecret(ephemeralKeypair.secretKey, recipientMetaPk);
+  const stealthPubkey = deriveStealthPubkey(recipientMetaPk, sharedSecret);
   const memo = generateStealthMemo(ephemeralKeypair.publicKey);
-  return {
-    stealthPubkey,
-    ephemeralKeypair,
-    sharedSecret,
-    memo
-  };
-}
-async function isStealthTransactionForMe(metaSk, metaPubkey, ephemeralPubkey, targetAddress) {
-  const sharedSecret = await computeSharedSecretAsRecipient(
-    metaSk,
-    ephemeralPubkey
-  );
-  const expectedStealth = deriveStealthPubkey(metaPubkey, sharedSecret);
-  return bytesToHex(expectedStealth) === bytesToHex(targetAddress);
-}
-
-// src/light.ts
-import {
-  Connection,
-  PublicKey as PublicKey3,
-  Transaction,
-  TransactionInstruction
-} from "@solana/web3.js";
-var LIGHT_PROGRAM_IDS = {
-  LIGHT_SYSTEM_PROGRAM: new PublicKey3(
-    "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7"
-  ),
-  COMPRESSED_TOKEN_PROGRAM: new PublicKey3(
-    "cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m"
-  ),
-  ACCOUNT_COMPRESSION_PROGRAM: new PublicKey3(
-    "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq"
-  )
-};
-var LightClient = class _LightClient {
-  constructor(connection, config) {
-    this.connection = connection;
-    this.config = config;
-  }
-  /**
-   * Creates a new Light Protocol client
-   *
-   * @param rpcUrl - Solana RPC URL with Light Protocol support
-   * @returns LightClient instance
-   */
-  static create(rpcUrl) {
-    const connection = new Connection(rpcUrl, "confirmed");
-    return new _LightClient(connection, { rpcUrl });
-  }
-  /**
-   * Gets compressed SOL balance for an address
-   *
-   * @param owner - Owner public key
-   * @returns Compressed SOL balance in lamports
-   */
-  async getCompressedSolBalance(owner) {
-    try {
-      const response = await fetch(this.config.rpcUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: 1,
-          method: "getCompressedAccountsByOwner",
-          params: [owner.toBase58()]
-        })
-      });
-      const data = await response.json();
-      if (data.error) {
-        console.warn("Light RPC error:", data.error);
-        return BigInt(0);
-      }
-      const accounts = data.result?.items || [];
-      let total = BigInt(0);
-      for (const acc of accounts) {
-        total += BigInt(acc.lamports || 0);
-      }
-      return total;
-    } catch (error) {
-      console.warn("Failed to get compressed balance:", error);
-      return BigInt(0);
-    }
-  }
-  /**
-   * Gets compressed token balances for an address
-   *
-   * @param owner - Owner public key
-   * @param mint - Optional token mint to filter
-   * @returns Array of compressed token balances
-   */
-  async getCompressedTokenBalances(owner, mint) {
-    try {
-      const response = await fetch(this.config.rpcUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: 1,
-          method: "getCompressedTokenAccountsByOwner",
-          params: [owner.toBase58(), mint?.toBase58()]
-        })
-      });
-      const data = await response.json();
-      if (data.error) {
-        console.warn("Light RPC error:", data.error);
-        return [];
-      }
-      const balancesByMint = /* @__PURE__ */ new Map();
-      const accounts = data.result?.items || [];
-      for (const acc of accounts) {
-        const mintStr = acc.mint;
-        if (!balancesByMint.has(mintStr)) {
-          balancesByMint.set(mintStr, {
-            mint: new PublicKey3(mintStr),
-            amount: BigInt(0),
-            accounts: []
-          });
-        }
-        const balance = balancesByMint.get(mintStr);
-        balance.amount += BigInt(acc.amount || 0);
-        balance.accounts.push({
-          hash: acc.hash,
-          owner: new PublicKey3(acc.owner),
-          lamports: acc.lamports || 0,
-          data: new Uint8Array(acc.data || []),
-          tree: new PublicKey3(acc.tree),
-          leafIndex: acc.leafIndex
-        });
-      }
-      return Array.from(balancesByMint.values());
-    } catch (error) {
-      console.warn("Failed to get compressed token balances:", error);
-      return [];
-    }
-  }
-  /**
-   * Creates a compressed SOL transfer instruction
-   *
-   * Note: This creates the instruction data structure.
-   * Actual ZK proof generation requires Light Protocol SDK.
-   *
-   * @param from - Sender public key
-   * @param to - Recipient public key (can be stealth address)
-   * @param amount - Amount in lamports
-   * @returns Transaction instruction (placeholder)
-   */
-  createCompressedTransferInstruction(from, to, amount) {
-    const data = Buffer.alloc(72);
-    data.write("compressed_transfer", 0);
-    data.writeBigUInt64LE(amount, 32);
-    return new TransactionInstruction({
-      keys: [
-        { pubkey: from, isSigner: true, isWritable: true },
-        { pubkey: to, isSigner: false, isWritable: true },
-        {
-          pubkey: LIGHT_PROGRAM_IDS.LIGHT_SYSTEM_PROGRAM,
-          isSigner: false,
-          isWritable: false
-        }
-      ],
-      programId: LIGHT_PROGRAM_IDS.LIGHT_SYSTEM_PROGRAM,
-      data
-    });
-  }
-  /**
-   * Compresses SOL from regular account to compressed account
-   *
-   * @param owner - Owner public key
-   * @param amount - Amount in lamports to compress
-   * @returns Transaction (unsigned)
-   */
-  async createCompressSolTransaction(owner, amount) {
-    const instruction = this.createCompressedTransferInstruction(
-      owner,
-      owner,
-      // Compress to self
-      amount
-    );
-    const transaction = new Transaction().add(instruction);
-    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
-    transaction.feePayer = owner;
-    return transaction;
-  }
-  /**
-   * Decompresses SOL from compressed account to regular account
-   *
-   * @param owner - Owner public key  
-   * @param amount - Amount in lamports to decompress
-   * @returns Transaction (unsigned)
-   */
-  async createDecompressSolTransaction(owner, amount) {
-    const instruction = this.createCompressedTransferInstruction(
-      owner,
-      owner,
-      amount
-    );
-    const transaction = new Transaction().add(instruction);
-    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
-    transaction.feePayer = owner;
-    return transaction;
-  }
-  /**
-   * Creates a stealth compressed transfer
-   * Combines stealth addressing with ZK-compression
-   *
-   * @param from - Sender public key
-   * @param stealthPubkey - Derived stealth address for recipient
-   * @param amount - Amount in lamports
-   * @param memo - Stealth memo containing ephemeral pubkey
-   * @returns Transaction (unsigned)
-   */
-  async createStealthCompressedTransfer(from, stealthPubkey, amount, memo) {
-    const stealthAddress = new PublicKey3(stealthPubkey);
-    const transferIx = this.createCompressedTransferInstruction(
-      from,
-      stealthAddress,
-      amount
-    );
-    const memoIx = new TransactionInstruction({
-      keys: [],
-      programId: MEMO_PROGRAM_ID,
-      data: Buffer.from(memo, "utf-8")
-    });
-    const transaction = new Transaction().add(transferIx).add(memoIx);
-    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
-    transaction.feePayer = from;
-    return transaction;
-  }
-};
-function createLightClient(rpcUrl) {
-  return LightClient.create(rpcUrl);
+  return { stealthPubkey, ephemeralKeypair, sharedSecret, memo };
 }
 
 // src/indexer.ts
-import { Connection as Connection2, PublicKey as PublicKey4 } from "@solana/web3.js";
+import { Connection } from "@solana/web3.js";
 var AdelosIndexer = class _AdelosIndexer {
   constructor(config) {
-    this.isScanning = false;
-    this.scanIntervalId = null;
-    this.config = config;
-    this.connection = new Connection2(config.rpcUrl, "confirmed");
+    this.connection = new Connection(config.rpcUrl, "confirmed");
+    this.heliusApiKey = config.heliusApiKey;
   }
-  /**
-   * Creates an indexer instance
-   */
   static create(config) {
     return new _AdelosIndexer(config);
   }
-  /**
-   * Scans recent transactions for stealth transfers to a recipient
-   * 
-   * IMPORTANT: We scan the Memo Program, NOT the metaPubkey!
-   * The metaPubkey should never appear in transactions - that's the whole point of stealth addresses.
-   * We scan memo program for ADLSv1: prefix, then use Trial Decryption to check if it's for us.
-   *
-   * @param metaSk - Recipient's meta secret key
-   * @param metaPubkey - Recipient's meta public key
-   * @param limit - Number of transactions to scan
-   * @returns Array of stealth transactions for this recipient
-   */
-  async scanForStealthTransfers(metaSk, metaPubkey, limit = 100) {
-    const results = [];
-    try {
-      const signatures = await this.connection.getSignaturesForAddress(
-        MEMO_PROGRAM_ID,
-        { limit }
-      );
-      for (const sigInfo of signatures) {
-        const tx = await this.connection.getParsedTransaction(
-          sigInfo.signature,
-          { maxSupportedTransactionVersion: 0 }
-        );
-        if (!tx) continue;
-        const memo = this.extractMemo(tx);
-        if (!memo?.startsWith(MEMO_PREFIX)) continue;
-        const stealthTx = await this.parseStealthTransaction(
-          tx,
-          sigInfo.signature,
-          metaSk,
-          metaPubkey
-        );
-        if (stealthTx) {
-          results.push(stealthTx);
-        }
-      }
-    } catch (error) {
-      console.error("Error scanning transactions:", error);
-    }
-    return results;
-  }
-  /**
-   * Scans all transactions with ADLSv1 memo prefix
-   *
-   * @param metaSk - Recipient's meta secret key
-   * @param metaPubkey - Recipient's meta public key
-   * @param since - Scan transactions after this signature
-   * @returns Array of stealth transactions
-   */
-  async scanByMemoPrefix(metaSk, metaPubkey, since) {
+  /** Scan for stealth transfers to this recipient */
+  async scanForStealthTransfers(metaSk, metaPk, limit = 100) {
+    const sigs = await this.connection.getSignaturesForAddress(
+      ADELOS_CONFIG.MEMO_PROGRAM_ID,
+      { limit }
+    );
     const results = [];
-    try {
-      const signatures = await this.connection.getSignaturesForAddress(
-        MEMO_PROGRAM_ID,
-        { limit: 1e3, until: since }
-      );
-      for (const sigInfo of signatures) {
-        const tx = await this.connection.getParsedTransaction(
-          sigInfo.signature,
-          { maxSupportedTransactionVersion: 0 }
-        );
-        if (!tx) continue;
-        const memo = this.extractMemo(tx);
-        if (!memo?.startsWith(MEMO_PREFIX)) continue;
-        const stealthTx = await this.parseStealthTransaction(
-          tx,
-          sigInfo.signature,
-          metaSk,
-          metaPubkey
-        );
-        if (stealthTx) {
-          results.push(stealthTx);
-        }
+    for (const s of sigs) {
+      const tx = await this.connection.getParsedTransaction(s.signature, {
+        maxSupportedTransactionVersion: 0
+      });
+      if (!tx) continue;
+      const memo = this.extractMemo(tx);
+      if (!memo?.startsWith(ADELOS_CONFIG.MEMO_PREFIX)) continue;
+      const detected = this.attemptDecryption(tx, metaSk, metaPk);
+      if (detected) {
+        results.push({
+          signature: s.signature,
+          blockTime: tx.blockTime ?? null,
+          stealthAddress: detected.stealthAddress,
+          amount: detected.amount
+        });
       }
-    } catch (error) {
-      console.error("Error scanning by memo:", error);
     }
     return results;
   }
-  /**
-   * Extracts memo from a parsed transaction
-   */
-  extractMemo(tx) {
-    const memoProgram = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
-    for (const ix of tx.transaction.message.instructions) {
-      if ("programId" in ix && ix.programId.toBase58() === memoProgram) {
-        if ("parsed" in ix && typeof ix.parsed === "string") {
-          return ix.parsed;
-        }
-      }
-    }
-    if (tx.meta?.innerInstructions) {
-      for (const inner of tx.meta.innerInstructions) {
-        for (const ix of inner.instructions) {
-          if ("programId" in ix && ix.programId.toBase58() === memoProgram) {
-            if ("parsed" in ix && typeof ix.parsed === "string") {
-              return ix.parsed;
-            }
-          }
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * Parses a transaction to extract stealth transfer info using Trial Decryption
-   * 
-   * Trial Decryption: First compute expected stealth address, then find if it exists in tx accounts
-   */
-  async parseStealthTransaction(tx, signature, metaSk, metaPubkey) {
+  /** Trial Decryption: Check if transaction is for this recipient */
+  attemptDecryption(tx, metaSk, metaPk) {
     const memo = this.extractMemo(tx);
-    if (!memo) return null;
-    const ephemeralPubkey = parseStealthMemo(memo);
-    if (!ephemeralPubkey) return null;
-    let expectedStealthHex;
-    try {
-      const sharedSecret = await computeSharedSecretAsRecipient(
-        metaSk,
-        ephemeralPubkey
-      );
-      const expectedStealth = deriveStealthPubkey(metaPubkey, sharedSecret);
-      expectedStealthHex = bytesToHex(expectedStealth);
-    } catch (error) {
-      console.warn("Error computing expected stealth:", error);
-      return null;
-    }
+    const ephemeralPk = parseStealthMemo(memo || "");
+    if (!ephemeralPk) return null;
+    const secret = computeSharedSecretAsRecipient(metaSk, ephemeralPk);
+    const expectedStealthHex = bytesToHex(deriveStealthPubkey(metaPk, secret));
     const accounts = tx.transaction.message.accountKeys;
+    const idx = accounts.findIndex(
+      (a) => bytesToHex(a.pubkey.toBytes()) === expectedStealthHex
+    );
+    if (idx === -1) return null;
     const preBalances = tx.meta?.preBalances || [];
     const postBalances = tx.meta?.postBalances || [];
-    let stealthIndex = -1;
-    for (let i = 0; i < accounts.length; i++) {
-      const accountHex = bytesToHex(accounts[i].pubkey.toBytes());
-      if (accountHex === expectedStealthHex) {
-        stealthIndex = i;
-        break;
-      }
-    }
-    if (stealthIndex === -1) return null;
-    const stealthAddress = accounts[stealthIndex].pubkey;
-    const change = (postBalances[stealthIndex] || 0) - (preBalances[stealthIndex] || 0);
-    const amount = BigInt(Math.max(change, 0));
-    let sender = null;
-    for (let i = 0; i < accounts.length; i++) {
-      const accChange = (postBalances[i] || 0) - (preBalances[i] || 0);
-      if (accChange < 0) {
-        sender = accounts[i].pubkey;
-        break;
-      }
-    }
-    return {
-      signature,
-      blockTime: tx.blockTime ?? null,
-      slot: tx.slot,
-      sender,
-      stealthAddress,
-      amount,
-      ephemeralPubkey,
-      isForMe: true
-      // If we reach here, it's definitely for us
-    };
-  }
-  /**
-   * Starts continuous scanning for stealth transfers
-   *
-   * @param metaSk - Recipient's meta secret key
-   * @param metaPubkey - Recipient's meta public key
-   */
-  startScanning(metaSk, metaPubkey) {
-    if (this.isScanning) return;
-    this.isScanning = true;
-    let lastSignature;
-    const scanInterval = this.config.scanInterval || 1e4;
-    this.scanIntervalId = setInterval(async () => {
-      try {
-        const txs = await this.scanByMemoPrefix(
-          metaSk,
-          metaPubkey,
-          lastSignature
-        );
-        for (const tx of txs) {
-          if (tx.isForMe && this.onTransaction) {
-            this.onTransaction(tx);
-          }
-        }
-        if (txs.length > 0) {
-          lastSignature = txs[0].signature;
-        }
-      } catch (error) {
-        console.error("Scan error:", error);
-      }
-    }, scanInterval);
-  }
-  /**
-   * Stops continuous scanning
-   */
-  stopScanning() {
-    this.isScanning = false;
-    if (this.scanIntervalId) {
-      clearInterval(this.scanIntervalId);
-      this.scanIntervalId = null;
-    }
-  }
-  /**
-   * Processes a Helius webhook payload
-   *
-   * @param payload - Webhook payload from Helius
-   * @param metaSk - Recipient's meta secret key
-   * @param metaPubkey - Recipient's meta public key
-   * @returns Stealth transaction if detected and for this recipient
-   */
-  async processWebhook(payload, metaSk, metaPubkey) {
-    let memo = null;
-    const memoProgramStr = MEMO_PROGRAM_ID.toBase58();
-    for (const ix of payload.instructions) {
-      if (ix.programId === memoProgramStr) {
-        memo = Buffer.from(ix.data, "base64").toString("utf-8");
-        break;
-      }
-    }
-    if (!memo?.startsWith(MEMO_PREFIX)) return null;
-    const ephemeralPubkey = parseStealthMemo(memo);
-    if (!ephemeralPubkey) return null;
-    let stealthAddress = null;
-    let amount = BigInt(0);
-    for (const acc of payload.accountData) {
-      if (acc.nativeBalanceChange > 0) {
-        stealthAddress = new PublicKey4(acc.account);
-        amount = BigInt(acc.nativeBalanceChange);
-        break;
-      }
-    }
-    if (!stealthAddress) return null;
-    let isForMe = false;
-    try {
-      const sharedSecret = await computeSharedSecretAsRecipient(
-        metaSk,
-        ephemeralPubkey
-      );
-      const expectedStealth = deriveStealthPubkey(metaPubkey, sharedSecret);
-      isForMe = bytesToHex(expectedStealth) === bytesToHex(stealthAddress.toBytes());
-    } catch (error) {
-      console.warn("Error checking webhook tx:", error);
-    }
-    if (!isForMe) return null;
+    const change = (postBalances[idx] || 0) - (preBalances[idx] || 0);
     return {
-      signature: payload.signature,
-      blockTime: payload.timestamp,
-      slot: payload.slot,
-      sender: null,
-      stealthAddress,
-      amount,
-      ephemeralPubkey,
-      isForMe: true
+      stealthAddress: accounts[idx].pubkey,
+      amount: BigInt(Math.max(change, 0))
     };
   }
-  /**
-   * Sets up Helius webhook for real-time notifications
-   *
-   * @param webhookUrl - Your server's webhook endpoint
-   * @returns Webhook ID
-   */
-  async setupHeliusWebhook(webhookUrl) {
-    if (!this.config.heliusApiKey) {
-      console.warn("Helius API key not configured");
-      return null;
-    }
-    try {
-      const response = await fetch(
-        `https://api.helius.xyz/v0/webhooks?api-key=${this.config.heliusApiKey}`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            webhookURL: webhookUrl,
-            transactionTypes: ["TRANSFER"],
-            accountAddresses: [
-              MEMO_PROGRAM_ID.toBase58()
-            ],
-            webhookType: "enhanced"
-          })
-        }
-      );
-      const data = await response.json();
-      return data.webhookID || null;
-    } catch (error) {
-      console.error("Failed to setup Helius webhook:", error);
-      return null;
-    }
+  extractMemo(tx) {
+    const ix = tx.transaction.message.instructions.find(
+      (i) => i.programId.equals(ADELOS_CONFIG.MEMO_PROGRAM_ID)
+    );
+    return ix?.parsed || null;
   }
 };
 function createIndexer(config) {
-  return AdelosIndexer.create(config);
+  return new AdelosIndexer(config);
 }
 
 // src/index.ts
 var AdelosSDK = class {
   constructor(options = {}) {
-    this.cluster = options.cluster ?? "devnet";
-    const rpcUrl = options.rpcUrl ?? RPC_URLS[this.cluster];
-    this.connection = new Connection3(rpcUrl, "confirmed");
-    this.programId = PROGRAM_IDS[this.cluster];
-    this.heliusApiKey = options.heliusApiKey;
+    const rpcUrl = options.rpcUrl ?? ADELOS_CONFIG.RPC_URL;
+    this.connection = new Connection2(rpcUrl, "confirmed");
+    this.programId = ADELOS_CONFIG.PROGRAM_ID;
   }
-  /**
-   * Derives the registry PDA for an owner
-   */
+  // --- Registry Operations ---
   deriveRegistryAddress(owner) {
     return deriveRegistryPda(owner, this.programId);
   }
-  /**
-   * Fetches a registry account by owner
-   */
   async getRegistry(owner) {
     const [address] = this.deriveRegistryAddress(owner);
     const accountInfo = await this.connection.getAccountInfo(address);
     if (!accountInfo) {
-      return {
-        address,
-        exists: false,
-        account: null
-      };
+      return { address, exists: false, account: null };
     }
     const data = accountInfo.data.slice(8);
     const account = {
-      owner: new PublicKey5(data.slice(0, 32)),
+      owner: new PublicKey4(data.slice(0, 32)),
       metaPubkey: new Uint8Array(data.slice(32, 64)),
       bump: data[64]
     };
     return { address, exists: true, account };
   }
-  /**
-   * Gets the meta pubkey for an owner
-   * @returns The meta pubkey as Uint8Array, or null if not registered
-   */
   async getMetaPubkey(owner) {
     const registry = await this.getRegistry(owner);
     return registry.exists ? registry.account.metaPubkey : null;
   }
-  /**
-   * Gets the meta pubkey as hex string
-   */
-  async getMetaPubkeyHex(owner) {
-    const metaPubkey = await this.getMetaPubkey(owner);
-    return metaPubkey ? bytesToHex(metaPubkey) : null;
-  }
-  /**
-   * Checks if an owner has a registered identity
-   */
   async isRegistered(owner) {
     const registry = await this.getRegistry(owner);
     return registry.exists;
   }
-  /**
-   * Creates a register identity instruction
-   */
+  // --- Instruction Builders ---
   createRegisterInstruction(owner, metaPubkey) {
     if (!isValidMetaPubkey(metaPubkey)) {
       throw new Error("Invalid meta pubkey: must be 32 bytes and not all zeros");
@@ -995,7 +474,7 @@ var AdelosSDK = class {
       Buffer.from(getDiscriminator("register_identity")),
       Buffer.from(metaPubkey)
     ]);
-    return new TransactionInstruction2({
+    return new TransactionInstruction({
       keys: [
         { pubkey: owner, isSigner: true, isWritable: true },
         { pubkey: registryPda, isSigner: false, isWritable: true },
@@ -1005,9 +484,6 @@ var AdelosSDK = class {
       data
     });
   }
-  /**
-   * Creates an update identity instruction
-   */
   createUpdateInstruction(owner, newMetaPubkey) {
     if (!isValidMetaPubkey(newMetaPubkey)) {
       throw new Error("Invalid meta pubkey: must be 32 bytes and not all zeros");
@@ -1017,22 +493,20 @@ var AdelosSDK = class {
       Buffer.from(getDiscriminator("update_identity")),
       Buffer.from(newMetaPubkey)
     ]);
-    return new TransactionInstruction2({
+    return new TransactionInstruction({
       keys: [
-        { pubkey: owner, isSigner: true, isWritable: false },
-        { pubkey: registryPda, isSigner: false, isWritable: true }
+        { pubkey: owner, isSigner: true, isWritable: true },
+        { pubkey: registryPda, isSigner: false, isWritable: true },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
       ],
       programId: this.programId,
       data
     });
   }
-  /**
-   * Creates a close registry instruction
-   */
   createCloseInstruction(owner) {
     const [registryPda] = this.deriveRegistryAddress(owner);
     const data = Buffer.from(getDiscriminator("close_registry"));
-    return new TransactionInstruction2({
+    return new TransactionInstruction({
       keys: [
         { pubkey: owner, isSigner: true, isWritable: true },
         { pubkey: registryPda, isSigner: false, isWritable: true }
@@ -1041,116 +515,56 @@ var AdelosSDK = class {
       data
     });
   }
-  /**
-   * Creates a register transaction (unsigned) - Legacy format
-   */
-  async createRegisterTransaction(owner, metaPubkey) {
-    const instruction = this.createRegisterInstruction(owner, metaPubkey);
-    const transaction = new Transaction2().add(instruction);
-    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
-    transaction.feePayer = owner;
-    return transaction;
-  }
-  /**
-   * Creates a register transaction (unsigned) - Versioned format (v0)
-   * Recommended for modern Solana applications
-   */
-  async createRegisterTransactionV0(owner, metaPubkey) {
-    const instruction = this.createRegisterInstruction(owner, metaPubkey);
-    const { blockhash } = await this.connection.getLatestBlockhash();
-    const messageV0 = new TransactionMessage({
-      payerKey: owner,
-      recentBlockhash: blockhash,
-      instructions: [instruction]
-    }).compileToV0Message();
-    return new VersionedTransaction(messageV0);
-  }
-  /**
-   * Creates an update transaction (unsigned) - Legacy format
-   */
-  async createUpdateTransaction(owner, newMetaPubkey) {
-    const instruction = this.createUpdateInstruction(owner, newMetaPubkey);
-    const transaction = new Transaction2().add(instruction);
-    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
-    transaction.feePayer = owner;
-    return transaction;
-  }
-  /**
-   * Creates an update transaction (unsigned) - Versioned format (v0)
-   */
-  async createUpdateTransactionV0(owner, newMetaPubkey) {
-    const instruction = this.createUpdateInstruction(owner, newMetaPubkey);
+  // --- Transaction Builders ---
+  async buildTransaction(payer, instructions, version = "v0") {
     const { blockhash } = await this.connection.getLatestBlockhash();
-    const messageV0 = new TransactionMessage({
-      payerKey: owner,
+    if (version === "legacy") {
+      const tx = new Transaction().add(...instructions);
+      tx.recentBlockhash = blockhash;
+      tx.feePayer = payer;
+      return tx;
+    }
+    const message = new TransactionMessage({
+      payerKey: payer,
       recentBlockhash: blockhash,
-      instructions: [instruction]
+      instructions
     }).compileToV0Message();
-    return new VersionedTransaction(messageV0);
+    return new VersionedTransaction(message);
   }
-  /**
-   * Creates a close transaction (unsigned) - Legacy format
-   */
-  async createCloseTransaction(owner) {
-    const instruction = this.createCloseInstruction(owner);
-    const transaction = new Transaction2().add(instruction);
-    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
-    transaction.feePayer = owner;
-    return transaction;
+  async createRegisterTransaction(owner, metaPubkey) {
+    const ix = this.createRegisterInstruction(owner, metaPubkey);
+    return this.buildTransaction(owner, [ix], "legacy");
   }
-  /**
-   * Creates a close transaction (unsigned) - Versioned format (v0)
-   */
-  async createCloseTransactionV0(owner) {
-    const instruction = this.createCloseInstruction(owner);
-    const { blockhash } = await this.connection.getLatestBlockhash();
-    const messageV0 = new TransactionMessage({
-      payerKey: owner,
-      recentBlockhash: blockhash,
-      instructions: [instruction]
-    }).compileToV0Message();
-    return new VersionedTransaction(messageV0);
+  async createRegisterTransactionV0(owner, metaPubkey) {
+    const ix = this.createRegisterInstruction(owner, metaPubkey);
+    return this.buildTransaction(owner, [ix], "v0");
   }
-  /**
-   * Sends a signed legacy transaction and confirms it
-   */
-  async sendAndConfirm(signedTransaction) {
-    const signature = await this.connection.sendRawTransaction(
-      signedTransaction.serialize()
-    );
-    await this.connection.confirmTransaction(signature, "confirmed");
-    return signature;
+  async sendAndConfirm(signedTx) {
+    const sig = await this.connection.sendRawTransaction(signedTx.serialize());
+    await this.connection.confirmTransaction(sig, "confirmed");
+    return sig;
   }
-  /**
-   * Sends a signed versioned transaction and confirms it
-   */
-  async sendAndConfirmV0(signedTransaction) {
-    const signature = await this.connection.sendRawTransaction(
-      signedTransaction.serialize()
-    );
-    await this.connection.confirmTransaction(signature, "confirmed");
-    return signature;
+  async sendAndConfirmV0(signedTx) {
+    const sig = await this.connection.sendRawTransaction(signedTx.serialize());
+    await this.connection.confirmTransaction(sig, "confirmed");
+    return sig;
   }
 };
 export {
+  ADELOS_CONFIG,
   AdelosIndexer,
   AdelosSDK,
   IDL,
-  LIGHT_PROGRAM_IDS,
-  LightClient,
   MEMO_PREFIX,
   MEMO_PROGRAM_ID,
   PROGRAM_ID,
-  PROGRAM_IDS,
-  REGISTRY_ACCOUNT_SIZE,
   REGISTRY_SEED,
-  RPC_URLS,
+  RPC_URL,
   STEALTH_DOMAIN,
   bytesToHex,
   computeSharedSecret,
   computeSharedSecretAsRecipient,
   createIndexer,
-  createLightClient,
   deriveRegistryPda,
   deriveStealthPubkey,
   generateEphemeralKeypair,
@@ -1158,7 +572,6 @@ export {
   generateStealthMemo,
   getDiscriminator,
   hexToBytes,
-  isStealthTransactionForMe,
   isValidMetaPubkey,
   parseStealthMemo,
   recoverStealthSecretKey