@orbinum/sdk 1.0.0 → 1.0.1

package/dist/index.d.mts

@@ -1809,12 +1809,15 @@ declare class PrivacyKeyManager {
      * Exports a shareable privacy address encoding the owner public key and
      * viewing PUBLIC key of the currently loaded identity.
      *
-     * Format: `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`
+     * Format: `orbpriv2:{ownerPk_hex}:{viewingPublicKey_hex}:{checksum}`
      *
      * The recipient uses this address so the sender can:
      *  1. Embed `ownerPk` in the note commitment (Poseidon4 input).
      *  2. Encrypt the memo via ECDH with the recipient's `viewingPublicKey`.
      *
+     * The trailing checksum (see `privacyAddressChecksum`) makes a corrupted
+     * paste fail to decode rather than pay into an unspendable note.
+     *
      * SECURITY: Only the viewing PUBLIC key is embedded — the viewing secret key
      * (used for decryption) is never exported. Holders of this address cannot
      * decrypt the recipient's notes.
@@ -1823,9 +1826,14 @@ declare class PrivacyKeyManager {
      */
     encodePrivacyAddress(): string;
     /**
-     * Decode a privacy address of the form `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`.
-     * Returns `{ ownerPkHex, viewingPublicKeyHex }` on success, or `null` if the input
-     * does not match the expected format.
+     * Decode a privacy address into `{ ownerPkHex, viewingPublicKeyHex }`, or
+     * `null` if it does not parse.
+     *
+     * Accepts both:
+     *  - `orbpriv2:{ownerPk}:{ivk}:{checksum}` — checksum verified; a mismatch
+     *    (corrupted paste) returns null.
+     *  - `orbpriv1:{ownerPk}:{ivk}` — legacy, no checksum. Still read so addresses
+     *    shared before v2 keep resolving; only v2 is emitted.
      */
     static decodePrivacyAddress(address: string): {
         ownerPkHex: string;

package/dist/index.d.ts

@@ -1809,12 +1809,15 @@ declare class PrivacyKeyManager {
      * Exports a shareable privacy address encoding the owner public key and
      * viewing PUBLIC key of the currently loaded identity.
      *
-     * Format: `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`
+     * Format: `orbpriv2:{ownerPk_hex}:{viewingPublicKey_hex}:{checksum}`
      *
      * The recipient uses this address so the sender can:
      *  1. Embed `ownerPk` in the note commitment (Poseidon4 input).
      *  2. Encrypt the memo via ECDH with the recipient's `viewingPublicKey`.
      *
+     * The trailing checksum (see `privacyAddressChecksum`) makes a corrupted
+     * paste fail to decode rather than pay into an unspendable note.
+     *
      * SECURITY: Only the viewing PUBLIC key is embedded — the viewing secret key
      * (used for decryption) is never exported. Holders of this address cannot
      * decrypt the recipient's notes.
@@ -1823,9 +1826,14 @@ declare class PrivacyKeyManager {
      */
     encodePrivacyAddress(): string;
     /**
-     * Decode a privacy address of the form `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`.
-     * Returns `{ ownerPkHex, viewingPublicKeyHex }` on success, or `null` if the input
-     * does not match the expected format.
+     * Decode a privacy address into `{ ownerPkHex, viewingPublicKeyHex }`, or
+     * `null` if it does not parse.
+     *
+     * Accepts both:
+     *  - `orbpriv2:{ownerPk}:{ivk}:{checksum}` — checksum verified; a mismatch
+     *    (corrupted paste) returns null.
+     *  - `orbpriv1:{ownerPk}:{ivk}` — legacy, no checksum. Still read so addresses
+     *    shared before v2 keep resolving; only v2 is emitted.
      */
     static decodePrivacyAddress(address: string): {
         ownerPkHex: string;

package/dist/index.js

@@ -1574,6 +1574,12 @@ function deriveOwnerPk(spendingKey) {
 }
 
 // src/protocol/keys/PrivacyKeyManager.ts
+var import_sha26 = require("@noble/hashes/sha2.js");
+function privacyAddressChecksum(ownerPkHex, ivkHex) {
+  const body = `orbpriv2:${ownerPkHex}:${ivkHex}`;
+  const digest = (0, import_sha26.sha256)(new TextEncoder().encode(body));
+  return toHex(digest.slice(0, 4)).slice(2);
+}
 var PrivacyKeyManager = class {
   _state = {
     spendingKey: null,
@@ -1683,12 +1689,15 @@ var PrivacyKeyManager = class {
    * Exports a shareable privacy address encoding the owner public key and
    * viewing PUBLIC key of the currently loaded identity.
    *
-   * Format: `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`
+   * Format: `orbpriv2:{ownerPk_hex}:{viewingPublicKey_hex}:{checksum}`
    *
    * The recipient uses this address so the sender can:
    *  1. Embed `ownerPk` in the note commitment (Poseidon4 input).
    *  2. Encrypt the memo via ECDH with the recipient's `viewingPublicKey`.
    *
+   * The trailing checksum (see `privacyAddressChecksum`) makes a corrupted
+   * paste fail to decode rather than pay into an unspendable note.
+   *
    * SECURITY: Only the viewing PUBLIC key is embedded — the viewing secret key
    * (used for decryption) is never exported. Holders of this address cannot
    * decrypt the recipient's notes.
@@ -1700,21 +1709,35 @@ var PrivacyKeyManager = class {
     const ivkPacked = this.getViewingPublicKeyPacked();
     const ownerPkHex = scalarToHex(ownerPk);
     const ivkHex = toHex(ivkPacked);
-    return `orbpriv1:${ownerPkHex}:${ivkHex}`;
+    const checksum = privacyAddressChecksum(ownerPkHex, ivkHex);
+    return `orbpriv2:${ownerPkHex}:${ivkHex}:${checksum}`;
   }
   /**
-   * Decode a privacy address of the form `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`.
-   * Returns `{ ownerPkHex, viewingPublicKeyHex }` on success, or `null` if the input
-   * does not match the expected format.
+   * Decode a privacy address into `{ ownerPkHex, viewingPublicKeyHex }`, or
+   * `null` if it does not parse.
+   *
+   * Accepts both:
+   *  - `orbpriv2:{ownerPk}:{ivk}:{checksum}` — checksum verified; a mismatch
+   *    (corrupted paste) returns null.
+   *  - `orbpriv1:{ownerPk}:{ivk}` — legacy, no checksum. Still read so addresses
+   *    shared before v2 keep resolving; only v2 is emitted.
    */
   static decodePrivacyAddress(address) {
-    if (!address.startsWith("orbpriv1:")) return null;
     const parts = address.split(":");
-    if (parts.length !== 3) return null;
-    const ownerPkHex = parts[1];
-    const viewingPublicKeyHex = parts[2];
-    if (!ownerPkHex || !viewingPublicKeyHex) return null;
-    return { ownerPkHex, viewingPublicKeyHex };
+    if (parts[0] === "orbpriv2") {
+      if (parts.length !== 4) return null;
+      const [, ownerPkHex, viewingPublicKeyHex, checksum] = parts;
+      if (!ownerPkHex || !viewingPublicKeyHex || !checksum) return null;
+      if (privacyAddressChecksum(ownerPkHex, viewingPublicKeyHex) !== checksum) return null;
+      return { ownerPkHex, viewingPublicKeyHex };
+    }
+    if (parts[0] === "orbpriv1") {
+      if (parts.length !== 3) return null;
+      const [, ownerPkHex, viewingPublicKeyHex] = parts;
+      if (!ownerPkHex || !viewingPublicKeyHex) return null;
+      return { ownerPkHex, viewingPublicKeyHex };
+    }
+    return null;
   }
   /**
    * Load keys from a cached "mk:0x{masterBytes_hex}" string produced by exportHex().
@@ -1740,7 +1763,7 @@ var PrivacyKeyManager = class {
 
 // src/protocol/keys/spendingKeyDerivation.ts
 var import_hkdf3 = require("@noble/hashes/hkdf.js");
-var import_sha26 = require("@noble/hashes/sha2.js");
+var import_sha27 = require("@noble/hashes/sha2.js");
 var MIN_SIGNATURE_BYTES = 32;
 var MIN_DISTINCT_BYTES = 8;
 function assertUsableSignature(sigBytes) {
@@ -1762,7 +1785,7 @@ async function deriveMasterKeyBytes(signatureHex, chainId, address) {
   const info = new TextEncoder().encode(
     `orbinum-sk-${KEY_VERSION}:${chainId}:${canonicalAccountId(address)}`
   );
-  return (0, import_hkdf3.hkdf)(import_sha26.sha256, sigBytes, new Uint8Array(0), info, 32);
+  return (0, import_hkdf3.hkdf)(import_sha27.sha256, sigBytes, new Uint8Array(0), info, 32);
 }
 async function deriveSpendingKeyFromSignature(signatureHex, chainId, address) {
   return deriveSpendingKeyFromMaster(await deriveMasterKeyBytes(signatureHex, chainId, address));

package/dist/index.mjs

@@ -463,6 +463,12 @@ ${canonicalAccountId(address)}`;
 }
 
 // src/protocol/keys/PrivacyKeyManager.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+function privacyAddressChecksum(ownerPkHex, ivkHex) {
+  const body = `orbpriv2:${ownerPkHex}:${ivkHex}`;
+  const digest = sha256(new TextEncoder().encode(body));
+  return toHex(digest.slice(0, 4)).slice(2);
+}
 var PrivacyKeyManager = class {
   _state = {
     spendingKey: null,
@@ -572,12 +578,15 @@ var PrivacyKeyManager = class {
    * Exports a shareable privacy address encoding the owner public key and
    * viewing PUBLIC key of the currently loaded identity.
    *
-   * Format: `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`
+   * Format: `orbpriv2:{ownerPk_hex}:{viewingPublicKey_hex}:{checksum}`
    *
    * The recipient uses this address so the sender can:
    *  1. Embed `ownerPk` in the note commitment (Poseidon4 input).
    *  2. Encrypt the memo via ECDH with the recipient's `viewingPublicKey`.
    *
+   * The trailing checksum (see `privacyAddressChecksum`) makes a corrupted
+   * paste fail to decode rather than pay into an unspendable note.
+   *
    * SECURITY: Only the viewing PUBLIC key is embedded — the viewing secret key
    * (used for decryption) is never exported. Holders of this address cannot
    * decrypt the recipient's notes.
@@ -589,21 +598,35 @@ var PrivacyKeyManager = class {
     const ivkPacked = this.getViewingPublicKeyPacked();
     const ownerPkHex = scalarToHex(ownerPk);
     const ivkHex = toHex(ivkPacked);
-    return `orbpriv1:${ownerPkHex}:${ivkHex}`;
+    const checksum = privacyAddressChecksum(ownerPkHex, ivkHex);
+    return `orbpriv2:${ownerPkHex}:${ivkHex}:${checksum}`;
   }
   /**
-   * Decode a privacy address of the form `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`.
-   * Returns `{ ownerPkHex, viewingPublicKeyHex }` on success, or `null` if the input
-   * does not match the expected format.
+   * Decode a privacy address into `{ ownerPkHex, viewingPublicKeyHex }`, or
+   * `null` if it does not parse.
+   *
+   * Accepts both:
+   *  - `orbpriv2:{ownerPk}:{ivk}:{checksum}` — checksum verified; a mismatch
+   *    (corrupted paste) returns null.
+   *  - `orbpriv1:{ownerPk}:{ivk}` — legacy, no checksum. Still read so addresses
+   *    shared before v2 keep resolving; only v2 is emitted.
    */
   static decodePrivacyAddress(address) {
-    if (!address.startsWith("orbpriv1:")) return null;
     const parts = address.split(":");
-    if (parts.length !== 3) return null;
-    const ownerPkHex = parts[1];
-    const viewingPublicKeyHex = parts[2];
-    if (!ownerPkHex || !viewingPublicKeyHex) return null;
-    return { ownerPkHex, viewingPublicKeyHex };
+    if (parts[0] === "orbpriv2") {
+      if (parts.length !== 4) return null;
+      const [, ownerPkHex, viewingPublicKeyHex, checksum] = parts;
+      if (!ownerPkHex || !viewingPublicKeyHex || !checksum) return null;
+      if (privacyAddressChecksum(ownerPkHex, viewingPublicKeyHex) !== checksum) return null;
+      return { ownerPkHex, viewingPublicKeyHex };
+    }
+    if (parts[0] === "orbpriv1") {
+      if (parts.length !== 3) return null;
+      const [, ownerPkHex, viewingPublicKeyHex] = parts;
+      if (!ownerPkHex || !viewingPublicKeyHex) return null;
+      return { ownerPkHex, viewingPublicKeyHex };
+    }
+    return null;
   }
   /**
    * Load keys from a cached "mk:0x{masterBytes_hex}" string produced by exportHex().
@@ -629,7 +652,7 @@ var PrivacyKeyManager = class {
 
 // src/protocol/keys/spendingKeyDerivation.ts
 import { hkdf } from "@noble/hashes/hkdf.js";
-import { sha256 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 var MIN_SIGNATURE_BYTES = 32;
 var MIN_DISTINCT_BYTES = 8;
 function assertUsableSignature(sigBytes) {
@@ -651,7 +674,7 @@ async function deriveMasterKeyBytes(signatureHex, chainId, address) {
   const info = new TextEncoder().encode(
     `orbinum-sk-${KEY_VERSION}:${chainId}:${canonicalAccountId(address)}`
   );
-  return hkdf(sha256, sigBytes, new Uint8Array(0), info, 32);
+  return hkdf(sha2562, sigBytes, new Uint8Array(0), info, 32);
 }
 async function deriveSpendingKeyFromSignature(signatureHex, chainId, address) {
   return deriveSpendingKeyFromMaster(await deriveMasterKeyBytes(signatureHex, chainId, address));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbinum/sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Official TypeScript SDK for Orbinum.",
   "author": "Orbinum",
   "license": "MIT",