@unicitylabs/sphere-sdk 0.7.1 → 0.7.2

package/dist/index.cjs

@@ -894,7 +894,6 @@ var init_network = __esm({
 // index.ts
 var index_exports = {};
 __export(index_exports, {
-  AuthVerificationError: () => AuthVerificationError,
   COIN_TYPES: () => COIN_TYPES,
   CoinGeckoPriceProvider: () => CoinGeckoPriceProvider,
   CommunicationsModule: () => CommunicationsModule,
@@ -945,7 +944,6 @@ __export(index_exports, {
   bytesToHex: () => bytesToHex3,
   checkNetworkHealth: () => checkNetworkHealth,
   coinIdsMatch: () => coinIdsMatch,
-  computeDirectAddressFromChainPubkey: () => computeDirectAddressFromChainPubkey,
   computeSwapId: () => computeSwapId,
   countCommittedTransactions: () => countCommittedTransactions,
   createAddress: () => createAddress,
@@ -1058,6 +1056,7 @@ __export(index_exports, {
   randomBytes: () => randomBytes2,
   randomHex: () => randomHex,
   randomUUID: () => randomUUID,
+  recoverPubkeyFromSignature: () => recoverPubkeyFromSignature,
   ripemd160: () => ripemd160,
   sha256: () => sha2562,
   signMessage: () => signMessage,
@@ -1075,7 +1074,6 @@ __export(index_exports, {
   verifyManifestIntegrity: () => verifyManifestIntegrity,
   verifyNametagBinding: () => verifyNametagBinding,
   verifySignedMessage: () => verifySignedMessage,
-  verifySphereAuth: () => verifySphereAuth,
   verifySwapSignature: () => verifySwapSignature
 });
 module.exports = __toCommonJS(index_exports);
@@ -5111,6 +5109,27 @@ function verifySignedMessage(message, signature, expectedPubkey) {
     return false;
   }
 }
+function recoverPubkeyFromSignature(message, signature) {
+  if (signature.length !== 130) {
+    throw new SphereError(
+      `Invalid signature length: expected 130 hex chars, got ${signature.length}`,
+      "SIGNING_ERROR"
+    );
+  }
+  const v = parseInt(signature.slice(0, 2), 16) - 31;
+  const r = signature.slice(2, 66);
+  const s = signature.slice(66, 130);
+  if (v < 0 || v > 3) {
+    throw new SphereError(
+      `Invalid recovery byte: v=${v} out of range [0..3]`,
+      "SIGNING_ERROR"
+    );
+  }
+  const hashHex = hashSignMessage(message);
+  const hashBytes = Buffer.from(hashHex, "hex");
+  const recovered = ec.recoverPubKey(hashBytes, { r, s }, v);
+  return recovered.encode("hex", true);
+}
 
 // l1/crypto.ts
 var import_crypto_js3 = __toESM(require("crypto-js"), 1);
@@ -27811,42 +27830,27 @@ async function parseAndDecryptWalletDat(data, password, onProgress) {
 
 // core/Sphere.ts
 var import_SigningService2 = require("@unicitylabs/state-transition-sdk/lib/sign/SigningService");
-var import_nostr_js_sdk5 = require("@unicitylabs/nostr-js-sdk");
-
-// core/address-derivation.ts
 var import_TokenType5 = require("@unicitylabs/state-transition-sdk/lib/token/TokenType");
 var import_HashAlgorithm7 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
 var import_UnmaskedPredicateReference3 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
-var UNICITY_TOKEN_TYPE_HEX2 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
-var COMPRESSED_PUBKEY_RE = /^(02|03)[0-9a-fA-F]{64}$/;
-async function computeDirectAddressFromChainPubkey(chainPubkey) {
-  if (typeof chainPubkey !== "string" || !COMPRESSED_PUBKEY_RE.test(chainPubkey)) {
-    throw new Error(
-      `computeDirectAddressFromChainPubkey: chainPubkey must be 66-char hex with 02/03 prefix, got "${String(chainPubkey).slice(0, 12)}..."`
-    );
-  }
-  const tokenTypeBytes = Buffer.from(UNICITY_TOKEN_TYPE_HEX2, "hex");
-  const tokenType = new import_TokenType5.TokenType(tokenTypeBytes);
-  const publicKeyBytes = Buffer.from(chainPubkey, "hex");
-  const predicateRef = await import_UnmaskedPredicateReference3.UnmaskedPredicateReference.create(
-    tokenType,
-    "secp256k1",
-    publicKeyBytes,
-    import_HashAlgorithm7.HashAlgorithm.SHA256
-  );
-  return (await predicateRef.toAddress()).toString();
-}
-
-// core/Sphere.ts
+var import_nostr_js_sdk5 = require("@unicitylabs/nostr-js-sdk");
 function isValidNametag2(nametag) {
   if ((0, import_nostr_js_sdk5.isPhoneNumber)(nametag)) return true;
   return /^[a-z0-9_-]{3,20}$/.test(nametag);
 }
+var UNICITY_TOKEN_TYPE_HEX2 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
 async function deriveL3PredicateAddress(privateKey) {
   const secret = Buffer.from(privateKey, "hex");
   const signingService = await import_SigningService2.SigningService.createFromSecret(secret);
-  const pubkeyHex = Buffer.from(signingService.publicKey).toString("hex");
-  return computeDirectAddressFromChainPubkey(pubkeyHex);
+  const tokenTypeBytes = Buffer.from(UNICITY_TOKEN_TYPE_HEX2, "hex");
+  const tokenType = new import_TokenType5.TokenType(tokenTypeBytes);
+  const predicateRef = import_UnmaskedPredicateReference3.UnmaskedPredicateReference.create(
+    tokenType,
+    signingService.algorithm,
+    signingService.publicKey,
+    import_HashAlgorithm7.HashAlgorithm.SHA256
+  );
+  return (await (await predicateRef).toAddress()).toString();
 }
 var Sphere = class _Sphere {
   // Singleton
@@ -31857,38 +31861,8 @@ function createPriceProvider(config) {
       throw new SphereError(`Unsupported price platform: ${String(config.platform)}`, "INVALID_CONFIG");
   }
 }
-
-// core/auth.ts
-var AuthVerificationError = class extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.name = "AuthVerificationError";
-    this.code = code;
-  }
-};
-async function verifySphereAuth(input) {
-  const { challenge, signature, chainPubkey } = input;
-  let directAddress;
-  try {
-    directAddress = await computeDirectAddressFromChainPubkey(chainPubkey);
-  } catch (err) {
-    throw new AuthVerificationError(
-      `chainPubkey is malformed: ${err.message}`,
-      "PUBKEY_MALFORMED"
-    );
-  }
-  if (!verifySignedMessage(challenge, signature, chainPubkey)) {
-    throw new AuthVerificationError(
-      "Signature does not verify against chainPubkey",
-      "SIGNATURE_INVALID"
-    );
-  }
-  return { chainPubkey, directAddress };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AuthVerificationError,
   COIN_TYPES,
   CoinGeckoPriceProvider,
   CommunicationsModule,
@@ -31939,7 +31913,6 @@ async function verifySphereAuth(input) {
   bytesToHex,
   checkNetworkHealth,
   coinIdsMatch,
-  computeDirectAddressFromChainPubkey,
   computeSwapId,
   countCommittedTransactions,
   createAddress,
@@ -32052,6 +32025,7 @@ async function verifySphereAuth(input) {
   randomBytes,
   randomHex,
   randomUUID,
+  recoverPubkeyFromSignature,
   ripemd160,
   sha256,
   signMessage,
@@ -32069,7 +32043,6 @@ async function verifySphereAuth(input) {
   verifyManifestIntegrity,
   verifyNametagBinding,
   verifySignedMessage,
-  verifySphereAuth,
   verifySwapSignature
 });
 /*! Bundled license information: