@adelos/sdk 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -4,16 +4,32 @@ import {
   PublicKey as PublicKey5,
   SystemProgram,
   Transaction as Transaction2,
-  TransactionInstruction as TransactionInstruction2
+  TransactionInstruction as TransactionInstruction2,
+  TransactionMessage,
+  VersionedTransaction
 } from "@solana/web3.js";
 
 // src/constants.ts
-import { PublicKey } from "@solana/web3.js";
-var PROGRAM_ID = new PublicKey(
-  "7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp"
+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 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";
 
 // src/utils.ts
 import { PublicKey as PublicKey2 } from "@solana/web3.js";
@@ -53,75 +69,246 @@ 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
       ],
-      args: [{ name: "new_meta_pubkey", type: { array: ["u8", 32] } }]
+      "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": "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: [
+  "accounts": [
     {
-      name: "RegistryAccount",
-      discriminator: [113, 93, 106, 201, 100, 166, 146, 98]
+      "name": "RegistryAccount",
+      "discriminator": [
+        113,
+        93,
+        106,
+        201,
+        100,
+        166,
+        146,
+        98
+      ]
     }
   ],
-  types: [
+  "errors": [
+    {
+      "code": 6e3,
+      "name": "InvalidMetaPubkey",
+      "msg": "Invalid meta_pubkey"
+    },
     {
-      name: "RegistryAccount",
-      type: {
-        kind: "struct",
-        fields: [
-          { name: "owner", type: "pubkey" },
-          { name: "meta_pubkey", type: { array: ["u8", 32] } },
-          { name: "bump", type: "u8" }
+      "code": 6001,
+      "name": "Unauthorized",
+      "msg": "Unauthorized"
+    }
+  ],
+  "types": [
+    {
+      "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 * as ed from "@noble/ed25519";
-ed.etc.sha512Sync = (...m) => {
-  const h = sha256.create();
-  m.forEach((msg) => h.update(msg));
-  return h.digest();
-};
 function generateEphemeralKeypair() {
   const secretKey = ed.utils.randomPrivateKey();
   const publicKey = ed.getPublicKey(secretKey);
@@ -139,7 +326,7 @@ async function computeSharedSecret(ephemeralSk, recipientMetaPubkey) {
 }
 function deriveStealthPubkey(metaPubkey, sharedSecret) {
   const scalarBytes = sha256(
-    new Uint8Array([...sharedSecret, ...Buffer.from("adelos:stealth")])
+    new Uint8Array([...sharedSecret, ...Buffer.from(STEALTH_DOMAIN)])
   );
   const scalar = ed.etc.mod(
     BigInt("0x" + bytesToHex(scalarBytes)),
@@ -152,7 +339,7 @@ function deriveStealthPubkey(metaPubkey, sharedSecret) {
 }
 function recoverStealthSecretKey(metaSk, sharedSecret) {
   const scalarBytes = sha256(
-    new Uint8Array([...sharedSecret, ...Buffer.from("adelos:stealth")])
+    new Uint8Array([...sharedSecret, ...Buffer.from(STEALTH_DOMAIN)])
   );
   const scalar = ed.etc.mod(
     BigInt("0x" + bytesToHex(scalarBytes)),
@@ -175,11 +362,11 @@ async function computeSharedSecretAsRecipient(metaSk, ephemeralPubkey) {
 }
 function generateStealthMemo(ephemeralPubkey) {
   const pubkeyHex = bytesToHex(ephemeralPubkey);
-  return `ADLSv1:${pubkeyHex}`;
+  return `${MEMO_PREFIX}${pubkeyHex}`;
 }
 function parseStealthMemo(memo) {
-  if (!memo.startsWith("ADLSv1:")) return null;
-  const pubkeyHex = memo.slice(7);
+  if (!memo.startsWith(MEMO_PREFIX)) return null;
+  const pubkeyHex = memo.slice(MEMO_PREFIX.length);
   if (pubkeyHex.length !== 64) return null;
   try {
     return hexToBytes(pubkeyHex);
@@ -415,7 +602,7 @@ var LightClient = class _LightClient {
     );
     const memoIx = new TransactionInstruction({
       keys: [],
-      programId: new PublicKey3("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
+      programId: MEMO_PROGRAM_ID,
       data: Buffer.from(memo, "utf-8")
     });
     const transaction = new Transaction().add(transferIx).add(memoIx);
@@ -445,6 +632,10 @@ var AdelosIndexer = class _AdelosIndexer {
   }
   /**
    * 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
@@ -455,7 +646,7 @@ var AdelosIndexer = class _AdelosIndexer {
     const results = [];
     try {
       const signatures = await this.connection.getSignaturesForAddress(
-        new PublicKey4(metaPubkey),
+        MEMO_PROGRAM_ID,
         { limit }
       );
       for (const sigInfo of signatures) {
@@ -464,6 +655,8 @@ var AdelosIndexer = class _AdelosIndexer {
           { maxSupportedTransactionVersion: 0 }
         );
         if (!tx) continue;
+        const memo = this.extractMemo(tx);
+        if (!memo?.startsWith(MEMO_PREFIX)) continue;
         const stealthTx = await this.parseStealthTransaction(
           tx,
           sigInfo.signature,
@@ -491,7 +684,7 @@ var AdelosIndexer = class _AdelosIndexer {
     const results = [];
     try {
       const signatures = await this.connection.getSignaturesForAddress(
-        new PublicKey4("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
+        MEMO_PROGRAM_ID,
         { limit: 1e3, until: since }
       );
       for (const sigInfo of signatures) {
@@ -501,7 +694,7 @@ var AdelosIndexer = class _AdelosIndexer {
         );
         if (!tx) continue;
         const memo = this.extractMemo(tx);
-        if (!memo?.startsWith("ADLSv1:")) continue;
+        if (!memo?.startsWith(MEMO_PREFIX)) continue;
         const stealthTx = await this.parseStealthTransaction(
           tx,
           sigInfo.signature,
@@ -543,39 +736,49 @@ var AdelosIndexer = class _AdelosIndexer {
     return null;
   }
   /**
-   * Parses a transaction to extract stealth transfer info
+   * 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) {
     const memo = this.extractMemo(tx);
     if (!memo) return null;
     const ephemeralPubkey = parseStealthMemo(memo);
     if (!ephemeralPubkey) 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;
+    let expectedStealthHex;
     try {
       const sharedSecret = await computeSharedSecretAsRecipient(
         metaSk,
         ephemeralPubkey
       );
       const expectedStealth = deriveStealthPubkey(metaPubkey, sharedSecret);
-      isForMe = bytesToHex(expectedStealth) === bytesToHex(stealthAddress.toBytes());
+      expectedStealthHex = bytesToHex(expectedStealth);
     } catch (error) {
-      console.warn("Error checking if tx is for me:", error);
+      console.warn("Error computing expected stealth:", error);
+      return null;
+    }
+    const accounts = tx.transaction.message.accountKeys;
+    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,
@@ -585,7 +788,8 @@ var AdelosIndexer = class _AdelosIndexer {
       stealthAddress,
       amount,
       ephemeralPubkey,
-      isForMe
+      isForMe: true
+      // If we reach here, it's definitely for us
     };
   }
   /**
@@ -639,14 +843,14 @@ var AdelosIndexer = class _AdelosIndexer {
    */
   async processWebhook(payload, metaSk, metaPubkey) {
     let memo = null;
-    const memoProgram = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+    const memoProgramStr = MEMO_PROGRAM_ID.toBase58();
     for (const ix of payload.instructions) {
-      if (ix.programId === memoProgram) {
+      if (ix.programId === memoProgramStr) {
         memo = Buffer.from(ix.data, "base64").toString("utf-8");
         break;
       }
     }
-    if (!memo?.startsWith("ADLSv1:")) return null;
+    if (!memo?.startsWith(MEMO_PREFIX)) return null;
     const ephemeralPubkey = parseStealthMemo(memo);
     if (!ephemeralPubkey) return null;
     let stealthAddress = null;
@@ -703,7 +907,7 @@ var AdelosIndexer = class _AdelosIndexer {
             webhookURL: webhookUrl,
             transactionTypes: ["TRANSFER"],
             accountAddresses: [
-              "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
+              MEMO_PROGRAM_ID.toBase58()
             ],
             webhookType: "enhanced"
           })
@@ -724,10 +928,11 @@ function createIndexer(config) {
 // src/index.ts
 var AdelosSDK = class {
   constructor(options = {}) {
-    this.program = null;
-    const rpcUrl = options.rpcUrl ?? "https://api.devnet.solana.com";
+    this.cluster = options.cluster ?? "devnet";
+    const rpcUrl = options.rpcUrl ?? RPC_URLS[this.cluster];
     this.connection = new Connection3(rpcUrl, "confirmed");
-    this.programId = options.programId ?? PROGRAM_ID;
+    this.programId = PROGRAM_IDS[this.cluster];
+    this.heliusApiKey = options.heliusApiKey;
   }
   /**
    * Derives the registry PDA for an owner
@@ -837,7 +1042,7 @@ var AdelosSDK = class {
     });
   }
   /**
-   * Creates a register transaction (unsigned)
+   * Creates a register transaction (unsigned) - Legacy format
    */
   async createRegisterTransaction(owner, metaPubkey) {
     const instruction = this.createRegisterInstruction(owner, metaPubkey);
@@ -847,7 +1052,21 @@ var AdelosSDK = class {
     return transaction;
   }
   /**
-   * Creates an update transaction (unsigned)
+   * 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);
@@ -857,7 +1076,20 @@ var AdelosSDK = class {
     return transaction;
   }
   /**
-   * Creates a close transaction (unsigned)
+   * Creates an update transaction (unsigned) - Versioned format (v0)
+   */
+  async createUpdateTransactionV0(owner, newMetaPubkey) {
+    const instruction = this.createUpdateInstruction(owner, newMetaPubkey);
+    const { blockhash } = await this.connection.getLatestBlockhash();
+    const messageV0 = new TransactionMessage({
+      payerKey: owner,
+      recentBlockhash: blockhash,
+      instructions: [instruction]
+    }).compileToV0Message();
+    return new VersionedTransaction(messageV0);
+  }
+  /**
+   * Creates a close transaction (unsigned) - Legacy format
    */
   async createCloseTransaction(owner) {
     const instruction = this.createCloseInstruction(owner);
@@ -867,7 +1099,20 @@ var AdelosSDK = class {
     return transaction;
   }
   /**
-   * Sends a signed transaction and confirms it
+   * 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);
+  }
+  /**
+   * Sends a signed legacy transaction and confirms it
    */
   async sendAndConfirm(signedTransaction) {
     const signature = await this.connection.sendRawTransaction(
@@ -876,6 +1121,16 @@ var AdelosSDK = class {
     await this.connection.confirmTransaction(signature, "confirmed");
     return signature;
   }
+  /**
+   * 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;
+  }
 };
 export {
   AdelosIndexer,
@@ -883,9 +1138,14 @@ export {
   IDL,
   LIGHT_PROGRAM_IDS,
   LightClient,
+  MEMO_PREFIX,
+  MEMO_PROGRAM_ID,
   PROGRAM_ID,
+  PROGRAM_IDS,
   REGISTRY_ACCOUNT_SIZE,
   REGISTRY_SEED,
+  RPC_URLS,
+  STEALTH_DOMAIN,
   bytesToHex,
   computeSharedSecret,
   computeSharedSecretAsRecipient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adelos/sdk",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Adelos Protocol SDK - Privacy Stealth Transfers on Solana",
   "main": "dist/index.js",
   "module": "dist/index.mjs",