@adelos/sdk 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,25 +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 } from "@solana/web3.js";
-var PROGRAM_ID = new PublicKey(
-  "7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp"
-);
-var REGISTRY_SEED = "registry";
-var REGISTRY_ACCOUNT_SIZE = 8 + 32 + 32 + 1;
+import { PublicKey, clusterApiUrl } from "@solana/web3.js";
+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 = 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
   );
 }
@@ -53,133 +64,290 @@ function getDiscriminator(instructionName) {
 
 // src/idl.ts
 var IDL = {
-  address: "7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp",
-  metadata: {
-    name: "adelos_registry",
-    version: "0.1.0",
-    spec: "0.1.0"
+  "address": "7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp",
+  "metadata": {
+    "name": "adelos_registry",
+    "version": "0.1.0",
+    "spec": "0.1.0",
+    "description": "Privacy Registry for Adelos Protocol"
   },
-  instructions: [
+  "instructions": [
     {
-      name: "register_identity",
-      discriminator: [164, 118, 227, 177, 47, 176, 187, 248],
-      accounts: [
-        { name: "owner", writable: true, signer: true },
-        { name: "registry", writable: true, pda: { seeds: [{ kind: "const", value: [114, 101, 103, 105, 115, 116, 114, 121] }, { kind: "account", path: "owner" }] } },
-        { name: "system_program", address: "11111111111111111111111111111111" }
+      "name": "close_registry",
+      "discriminator": [
+        76,
+        32,
+        154,
+        180,
+        51,
+        159,
+        218,
+        102
       ],
-      args: [{ name: "meta_pubkey", type: { array: ["u8", 32] } }]
+      "accounts": [
+        {
+          "name": "owner",
+          "writable": true,
+          "signer": true,
+          "relations": [
+            "registry"
+          ]
+        },
+        {
+          "name": "registry",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "owner"
+              }
+            ]
+          }
+        }
+      ],
+      "args": []
     },
     {
-      name: "update_identity",
-      discriminator: [130, 54, 88, 104, 222, 124, 238, 252],
-      accounts: [
-        { name: "owner", signer: true },
-        { name: "registry", writable: true }
+      "name": "register_identity",
+      "discriminator": [
+        164,
+        118,
+        227,
+        177,
+        47,
+        176,
+        187,
+        248
+      ],
+      "accounts": [
+        {
+          "name": "owner",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "registry",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "owner"
+              }
+            ]
+          }
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
       ],
-      args: [{ name: "new_meta_pubkey", type: { array: ["u8", 32] } }]
+      "args": [
+        {
+          "name": "meta_pubkey",
+          "type": {
+            "array": [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
     },
     {
-      name: "close_registry",
-      discriminator: [76, 32, 154, 180, 51, 159, 218, 102],
-      accounts: [
-        { name: "owner", writable: true, signer: true },
-        { name: "registry", writable: true }
+      "name": "update_identity",
+      "discriminator": [
+        130,
+        54,
+        88,
+        104,
+        222,
+        124,
+        238,
+        252
+      ],
+      "accounts": [
+        {
+          "name": "owner",
+          "writable": true,
+          "signer": true,
+          "relations": [
+            "registry"
+          ]
+        },
+        {
+          "name": "registry",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "owner"
+              }
+            ]
+          }
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
       ],
-      args: []
+      "args": [
+        {
+          "name": "new_meta_pubkey",
+          "type": {
+            "array": [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    }
+  ],
+  "accounts": [
+    {
+      "name": "RegistryAccount",
+      "discriminator": [
+        113,
+        93,
+        106,
+        201,
+        100,
+        166,
+        146,
+        98
+      ]
     }
   ],
-  accounts: [
+  "errors": [
+    {
+      "code": 6e3,
+      "name": "InvalidMetaPubkey",
+      "msg": "Invalid meta_pubkey"
+    },
     {
-      name: "RegistryAccount",
-      discriminator: [113, 93, 106, 201, 100, 166, 146, 98]
+      "code": 6001,
+      "name": "Unauthorized",
+      "msg": "Unauthorized"
     }
   ],
-  types: [
+  "types": [
     {
-      name: "RegistryAccount",
-      type: {
-        kind: "struct",
-        fields: [
-          { name: "owner", type: "pubkey" },
-          { name: "meta_pubkey", type: { array: ["u8", 32] } },
-          { name: "bump", type: "u8" }
+      "name": "RegistryAccount",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "owner",
+            "type": "pubkey"
+          },
+          {
+            "name": "meta_pubkey",
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            "name": "bump",
+            "type": "u8"
+          }
         ]
       }
     }
-  ],
-  errors: [
-    { code: 6e3, name: "InvalidMetaPubkey", msg: "Invalid meta_pubkey" },
-    { code: 6001, name: "Unauthorized", msg: "Unauthorized" }
   ]
 };
 
 // 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 = sha256.create();
+  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("adelos:stealth")])
-  );
-  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 point = ed.ExtendedPoint.fromHex(bytesToHex(ephemeralPk));
+  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(metaSk)), 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("adelos:stealth")])
-  );
-  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 `ADLSv1:${pubkeyHex}`;
+  return `${ADELOS_CONFIG.MEMO_PREFIX}${bytesToHex(ephemeralPubkey)}`;
 }
 function parseStealthMemo(memo) {
-  if (!memo.startsWith("ADLSv1:")) return null;
-  const pubkeyHex = memo.slice(7);
+  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);
@@ -187,600 +355,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: new PublicKey3("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
-      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
-   *
-   * @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(
-        new PublicKey4(metaPubkey),
-        { limit }
-      );
-      for (const sigInfo of signatures) {
-        const tx = await this.connection.getParsedTransaction(
-          sigInfo.signature,
-          { maxSupportedTransactionVersion: 0 }
-        );
-        if (!tx) 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(
-        new PublicKey4("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
-        { 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("ADLSv1:")) 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
-   */
-  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;
+    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 || [];
-    const accounts = tx.transaction.message.accountKeys;
-    let stealthAddress = null;
-    let amount = BigInt(0);
-    let sender = null;
-    for (let i = 0; i < accounts.length; i++) {
-      const change = (postBalances[i] || 0) - (preBalances[i] || 0);
-      if (change > 0) {
-        stealthAddress = accounts[i].pubkey;
-        amount = BigInt(change);
-      } else if (change < 0 && i === 0) {
-        sender = accounts[i].pubkey;
-      }
-    }
-    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 if tx is for me:", error);
-    }
-    return {
-      signature,
-      blockTime: tx.blockTime ?? null,
-      slot: tx.slot,
-      sender,
-      stealthAddress,
-      amount,
-      ephemeralPubkey,
-      isForMe
-    };
-  }
-  /**
-   * 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 memoProgram = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
-    for (const ix of payload.instructions) {
-      if (ix.programId === memoProgram) {
-        memo = Buffer.from(ix.data, "base64").toString("utf-8");
-        break;
-      }
-    }
-    if (!memo?.startsWith("ADLSv1:")) 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: [
-              "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
-            ],
-            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.program = null;
-    const rpcUrl = options.rpcUrl ?? "https://api.devnet.solana.com";
-    this.connection = new Connection3(rpcUrl, "confirmed");
-    this.programId = options.programId ?? PROGRAM_ID;
+    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");
@@ -790,7 +473,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 },
@@ -800,9 +483,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");
@@ -812,22 +492,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 }
@@ -836,61 +514,56 @@ var AdelosSDK = class {
       data
     });
   }
-  /**
-   * Creates a register transaction (unsigned)
-   */
+  // --- Transaction Builders ---
+  async buildTransaction(payer, instructions, version = "v0") {
+    const { blockhash } = await this.connection.getLatestBlockhash();
+    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
+    }).compileToV0Message();
+    return new VersionedTransaction(message);
+  }
   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;
+    const ix = this.createRegisterInstruction(owner, metaPubkey);
+    return this.buildTransaction(owner, [ix], "legacy");
   }
-  /**
-   * Creates an update transaction (unsigned)
-   */
-  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;
+  async createRegisterTransactionV0(owner, metaPubkey) {
+    const ix = this.createRegisterInstruction(owner, metaPubkey);
+    return this.buildTransaction(owner, [ix], "v0");
   }
-  /**
-   * Creates a close transaction (unsigned)
-   */
-  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 sendAndConfirm(signedTx) {
+    const sig = await this.connection.sendRawTransaction(signedTx.serialize());
+    await this.connection.confirmTransaction(sig, "confirmed");
+    return sig;
   }
-  /**
-   * Sends a signed transaction and confirms it
-   */
-  async sendAndConfirm(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,
-  REGISTRY_ACCOUNT_SIZE,
   REGISTRY_SEED,
+  RPC_URL,
+  STEALTH_DOMAIN,
   bytesToHex,
   computeSharedSecret,
   computeSharedSecretAsRecipient,
   createIndexer,
-  createLightClient,
   deriveRegistryPda,
   deriveStealthPubkey,
   generateEphemeralKeypair,
@@ -898,7 +571,6 @@ export {
   generateStealthMemo,
   getDiscriminator,
   hexToBytes,
-  isStealthTransactionForMe,
   isValidMetaPubkey,
   parseStealthMemo,
   recoverStealthSecretKey