@adelos/sdk 0.1.3 → 0.1.6

package/dist/index.js

@@ -33,7 +33,6 @@ __export(index_exports, {
   ADELOS_CONFIG: () => ADELOS_CONFIG,
   AdelosIndexer: () => AdelosIndexer,
   AdelosSDK: () => AdelosSDK,
-  IDL: () => IDL,
   MEMO_PREFIX: () => MEMO_PREFIX,
   MEMO_PROGRAM_ID: () => MEMO_PROGRAM_ID,
   PROGRAM_ID: () => PROGRAM_ID,
@@ -56,7 +55,7 @@ __export(index_exports, {
   recoverStealthSecretKey: () => recoverStealthSecretKey
 });
 module.exports = __toCommonJS(index_exports);
-var import_web34 = require("@solana/web3.js");
+var import_web33 = require("@solana/web3.js");
 
 // src/constants.ts
 var import_web3 = require("@solana/web3.js");
@@ -66,7 +65,8 @@ var ADELOS_CONFIG = {
   MEMO_PROGRAM_ID: new import_web3.PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
   REGISTRY_SEED: "registry",
   MEMO_PREFIX: "ADLSv1:",
-  STEALTH_DOMAIN: "adelos:stealth:v1"
+  STEALTH_DOMAIN: "adelos:stealth:v1",
+  UNLOCK_MESSAGE: "Adelos Protocol: Unlock Privacy Identity\n\nThis will derive your unique privacy key for stealth addresses. This does not cost gas."
 };
 var PROGRAM_ID = ADELOS_CONFIG.PROGRAM_ID;
 var RPC_URL = ADELOS_CONFIG.RPC_URL;
@@ -111,244 +111,8 @@ function getDiscriminator(instructionName) {
   return disc;
 }
 
-// src/idl.ts
-var IDL = {
-  "address": "7T1UxHJ6psKiQheKZXxANu6mhgsmgaX55eNKZZL5u4Rp",
-  "metadata": {
-    "name": "adelos_registry",
-    "version": "0.1.0",
-    "spec": "0.1.0",
-    "description": "Privacy Registry for Adelos Protocol"
-  },
-  "instructions": [
-    {
-      "name": "close_registry",
-      "discriminator": [
-        76,
-        32,
-        154,
-        180,
-        51,
-        159,
-        218,
-        102
-      ],
-      "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": "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": "meta_pubkey",
-          "type": {
-            "array": [
-              "u8",
-              32
-            ]
-          }
-        }
-      ]
-    },
-    {
-      "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": [
-        {
-          "name": "new_meta_pubkey",
-          "type": {
-            "array": [
-              "u8",
-              32
-            ]
-          }
-        }
-      ]
-    }
-  ],
-  "accounts": [
-    {
-      "name": "RegistryAccount",
-      "discriminator": [
-        113,
-        93,
-        106,
-        201,
-        100,
-        166,
-        146,
-        98
-      ]
-    }
-  ],
-  "errors": [
-    {
-      "code": 6e3,
-      "name": "InvalidMetaPubkey",
-      "msg": "Invalid meta_pubkey"
-    },
-    {
-      "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"
-          }
-        ]
-      }
-    }
-  ]
-};
+// src/index.ts
+var import_sha2562 = require("@noble/hashes/sha256");
 
 // src/crypto.ts
 var import_sha256 = require("@noble/hashes/sha256");
@@ -360,24 +124,30 @@ ed.etc.sha512Sync = (...m) => {
   return h.digest();
 };
 var encoder = new TextEncoder();
+var toScalar = (bytes) => {
+  const cleanBytes = bytes.length === 64 ? bytes.slice(0, 32) : bytes;
+  return ed.etc.mod(BigInt("0x" + bytesToHex(cleanBytes)), ed.CURVE.n);
+};
 function generateEphemeralKeypair() {
   const secretKey = ed.utils.randomPrivateKey();
-  return { secretKey, publicKey: ed.getPublicKey(secretKey) };
+  const scalar = toScalar(secretKey);
+  const publicKey = ed.ExtendedPoint.BASE.multiply(scalar).toRawBytes();
+  return { secretKey, publicKey };
 }
 function computeSharedSecret(ephemeralSk, recipientMetaPk) {
   const point = ed.ExtendedPoint.fromHex(bytesToHex(recipientMetaPk));
-  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(ephemeralSk)), ed.CURVE.n);
+  const scalar = toScalar(ephemeralSk);
   return (0, import_sha256.sha256)(point.multiply(scalar).toRawBytes());
 }
 function computeSharedSecretAsRecipient(metaSk, ephemeralPk) {
   const point = ed.ExtendedPoint.fromHex(bytesToHex(ephemeralPk));
-  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(metaSk)), ed.CURVE.n);
+  const scalar = toScalar(metaSk);
   return (0, import_sha256.sha256)(point.multiply(scalar).toRawBytes());
 }
 function deriveStealthPubkey(metaPk, sharedSecret) {
   const domain = encoder.encode(ADELOS_CONFIG.STEALTH_DOMAIN);
   const scalarBytes = (0, import_sha256.sha256)(new Uint8Array([...sharedSecret, ...domain]));
-  const scalar = ed.etc.mod(BigInt("0x" + bytesToHex(scalarBytes)), ed.CURVE.n);
+  const scalar = toScalar(scalarBytes);
   const metaPoint = ed.ExtendedPoint.fromHex(bytesToHex(metaPk));
   const stealthPoint = metaPoint.add(ed.ExtendedPoint.BASE.multiply(scalar));
   return stealthPoint.toRawBytes();
@@ -385,8 +155,8 @@ function deriveStealthPubkey(metaPk, sharedSecret) {
 function recoverStealthSecretKey(metaSk, sharedSecret) {
   const domain = encoder.encode(ADELOS_CONFIG.STEALTH_DOMAIN);
   const scalarBytes = (0, import_sha256.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 scalar = toScalar(scalarBytes);
+  const metaScalar = toScalar(metaSk);
   const stealthScalar = ed.etc.mod(metaScalar + scalar, ed.CURVE.n);
   const hex = stealthScalar.toString(16).padStart(64, "0");
   return hexToBytes(hex);
@@ -413,14 +183,10 @@ function generateStealthAddress(recipientMetaPk) {
 }
 
 // src/indexer.ts
-var import_web33 = require("@solana/web3.js");
-var AdelosIndexer = class _AdelosIndexer {
-  constructor(config) {
-    this.connection = new import_web33.Connection(config.rpcUrl, "confirmed");
-    this.heliusApiKey = config.heliusApiKey;
-  }
-  static create(config) {
-    return new _AdelosIndexer(config);
+var AdelosIndexer = class {
+  // Sekarang langsung menerima objek Connection yang sudah jadi
+  constructor(connection) {
+    this.connection = connection;
   }
   /** Scan for stealth transfers to this recipient */
   async scanForStealthTransfers(metaSk, metaPk, limit = 100) {
@@ -448,7 +214,9 @@ var AdelosIndexer = class _AdelosIndexer {
     }
     return results;
   }
-  /** Trial Decryption: Check if transaction is for this recipient */
+  /** * Trial Decryption: Mengecek apakah transaksi ini milik user.
+   * Dibuat 'public' agar bisa dites di file testing.
+   */
   attemptDecryption(tx, metaSk, metaPk) {
     const memo = this.extractMemo(tx);
     const ephemeralPk = parseStealthMemo(memo || "");
@@ -462,10 +230,10 @@ var AdelosIndexer = class _AdelosIndexer {
     if (idx === -1) return null;
     const preBalances = tx.meta?.preBalances || [];
     const postBalances = tx.meta?.postBalances || [];
-    const change = (postBalances[idx] || 0) - (preBalances[idx] || 0);
+    const change = BigInt(postBalances[idx] || 0) - BigInt(preBalances[idx] || 0);
     return {
       stealthAddress: accounts[idx].pubkey,
-      amount: BigInt(Math.max(change, 0))
+      amount: change > 0n ? change : 0n
     };
   }
   extractMemo(tx) {
@@ -475,125 +243,93 @@ var AdelosIndexer = class _AdelosIndexer {
     return ix?.parsed || null;
   }
 };
-function createIndexer(config) {
-  return new AdelosIndexer(config);
+function createIndexer(connection) {
+  return new AdelosIndexer(connection);
 }
 
 // src/index.ts
 var AdelosSDK = class {
   constructor(options = {}) {
-    const rpcUrl = options.rpcUrl ?? ADELOS_CONFIG.RPC_URL;
-    this.connection = new import_web34.Connection(rpcUrl, "confirmed");
+    this.connection = new import_web33.Connection(options.rpcUrl ?? ADELOS_CONFIG.RPC_URL, "confirmed");
     this.programId = ADELOS_CONFIG.PROGRAM_ID;
   }
-  // --- Registry Operations ---
-  deriveRegistryAddress(owner) {
-    return deriveRegistryPda(owner, this.programId);
-  }
+  // --- 1. Identity & Registry ---
   async getRegistry(owner) {
-    const [address] = this.deriveRegistryAddress(owner);
+    const [address] = deriveRegistryPda(owner, this.programId);
     const accountInfo = await this.connection.getAccountInfo(address);
-    if (!accountInfo) {
-      return { address, exists: false, account: null };
-    }
+    if (!accountInfo) return { address, exists: false, account: null };
     const data = accountInfo.data.slice(8);
-    const account = {
-      owner: new import_web34.PublicKey(data.slice(0, 32)),
-      metaPubkey: new Uint8Array(data.slice(32, 64)),
-      bump: data[64]
+    return {
+      address,
+      exists: true,
+      account: {
+        owner: new import_web33.PublicKey(data.slice(0, 32)),
+        metaPubkey: new Uint8Array(data.slice(32, 64)),
+        bump: data[64]
+      }
     };
-    return { address, exists: true, account };
   }
-  async getMetaPubkey(owner) {
-    const registry = await this.getRegistry(owner);
-    return registry.exists ? registry.account.metaPubkey : null;
+  /** Menghasilkan metaSk tanpa simpan di LocalStorage (Deterministic) */
+  async unlockPrivacy(signMessage) {
+    const message = new TextEncoder().encode(ADELOS_CONFIG.UNLOCK_MESSAGE);
+    const signature = await signMessage(message);
+    return (0, import_sha2562.sha256)(signature);
   }
-  async isRegistered(owner) {
-    const registry = await this.getRegistry(owner);
-    return registry.exists;
+  // --- 2. High-Level Transaction Builders ---
+  /** API Satu Pintu untuk kirim SOL secara privat */
+  async createStealthTransfer(sender, receiver, amountSOL, version = "v0") {
+    const registry = await this.getRegistry(receiver);
+    if (!registry.exists) throw new Error("Penerima belum terdaftar.");
+    const { stealthPubkey, memo } = await generateStealthAddress(registry.account.metaPubkey);
+    const instructions = [
+      import_web33.SystemProgram.transfer({
+        fromPubkey: sender,
+        toPubkey: new import_web33.PublicKey(stealthPubkey),
+        lamports: BigInt(Math.round(amountSOL * 1e9))
+      }),
+      new import_web33.TransactionInstruction({
+        keys: [{ pubkey: sender, isSigner: true, isWritable: false }],
+        programId: ADELOS_CONFIG.MEMO_PROGRAM_ID,
+        data: Buffer.from(memo, "utf-8")
+      })
+    ];
+    return this.buildTransaction(sender, instructions, version);
   }
-  // --- Instruction Builders ---
-  createRegisterInstruction(owner, metaPubkey) {
-    if (!isValidMetaPubkey(metaPubkey)) {
-      throw new Error("Invalid meta pubkey: must be 32 bytes and not all zeros");
-    }
-    const [registryPda] = this.deriveRegistryAddress(owner);
-    const data = Buffer.concat([
-      Buffer.from(getDiscriminator("register_identity")),
-      Buffer.from(metaPubkey)
-    ]);
-    return new import_web34.TransactionInstruction({
+  /** Membuat transaksi pendaftaran identitas */
+  async createRegisterTransaction(owner, metaPubkey, version = "v0") {
+    const [registryPda] = deriveRegistryPda(owner, this.programId);
+    const data = Buffer.concat([Buffer.from(getDiscriminator("register_identity")), Buffer.from(metaPubkey)]);
+    const ix = new import_web33.TransactionInstruction({
       keys: [
         { pubkey: owner, isSigner: true, isWritable: true },
         { pubkey: registryPda, isSigner: false, isWritable: true },
-        { pubkey: import_web34.SystemProgram.programId, isSigner: false, isWritable: false }
+        { pubkey: import_web33.SystemProgram.programId, isSigner: false, isWritable: false }
       ],
       programId: this.programId,
       data
     });
+    return this.buildTransaction(owner, [ix], version);
   }
-  createUpdateInstruction(owner, newMetaPubkey) {
-    if (!isValidMetaPubkey(newMetaPubkey)) {
-      throw new Error("Invalid meta pubkey: must be 32 bytes and not all zeros");
-    }
-    const [registryPda] = this.deriveRegistryAddress(owner);
-    const data = Buffer.concat([
-      Buffer.from(getDiscriminator("update_identity")),
-      Buffer.from(newMetaPubkey)
-    ]);
-    return new import_web34.TransactionInstruction({
-      keys: [
-        { pubkey: owner, isSigner: true, isWritable: true },
-        { pubkey: registryPda, isSigner: false, isWritable: true },
-        { pubkey: import_web34.SystemProgram.programId, isSigner: false, isWritable: false }
-      ],
-      programId: this.programId,
-      data
-    });
-  }
-  createCloseInstruction(owner) {
-    const [registryPda] = this.deriveRegistryAddress(owner);
-    const data = Buffer.from(getDiscriminator("close_registry"));
-    return new import_web34.TransactionInstruction({
-      keys: [
-        { pubkey: owner, isSigner: true, isWritable: true },
-        { pubkey: registryPda, isSigner: false, isWritable: true }
-      ],
-      programId: this.programId,
-      data
-    });
-  }
-  // --- Transaction Builders ---
+  // --- 3. Core Engine (Internal Helpers) ---
   async buildTransaction(payer, instructions, version = "v0") {
     const { blockhash } = await this.connection.getLatestBlockhash();
     if (version === "legacy") {
-      const tx = new import_web34.Transaction().add(...instructions);
+      const tx = new import_web33.Transaction().add(...instructions);
       tx.recentBlockhash = blockhash;
       tx.feePayer = payer;
       return tx;
     }
-    const message = new import_web34.TransactionMessage({
+    const message = new import_web33.TransactionMessage({
       payerKey: payer,
       recentBlockhash: blockhash,
       instructions
     }).compileToV0Message();
-    return new import_web34.VersionedTransaction(message);
-  }
-  async createRegisterTransaction(owner, metaPubkey) {
-    const ix = this.createRegisterInstruction(owner, metaPubkey);
-    return this.buildTransaction(owner, [ix], "legacy");
-  }
-  async createRegisterTransactionV0(owner, metaPubkey) {
-    const ix = this.createRegisterInstruction(owner, metaPubkey);
-    return this.buildTransaction(owner, [ix], "v0");
+    return new import_web33.VersionedTransaction(message);
   }
+  /** Satu fungsi kirim untuk semua jenis transaksi (Legacy/V0) */
   async sendAndConfirm(signedTx) {
-    const sig = await this.connection.sendRawTransaction(signedTx.serialize());
-    await this.connection.confirmTransaction(sig, "confirmed");
-    return sig;
-  }
-  async sendAndConfirmV0(signedTx) {
-    const sig = await this.connection.sendRawTransaction(signedTx.serialize());
+    const rawTx = signedTx instanceof import_web33.Transaction ? signedTx.serialize() : signedTx.serialize();
+    const sig = await this.connection.sendRawTransaction(rawTx);
     await this.connection.confirmTransaction(sig, "confirmed");
     return sig;
   }
@@ -603,7 +339,6 @@ var AdelosSDK = class {
   ADELOS_CONFIG,
   AdelosIndexer,
   AdelosSDK,
-  IDL,
   MEMO_PREFIX,
   MEMO_PROGRAM_ID,
   PROGRAM_ID,