@notabene/verify-proof 1.11.0 → 1.12.0-next.12

package/src/concordium.ts

@@ -1,309 +1,60 @@
 import { ProofStatus, SignatureProof } from "@notabene/javascript-sdk";
+import { VerifiablePresentation } from "@concordium/web-sdk";
 
-// Concordium network configurations
-interface ConcordiumNetwork {
-  grpcUrl: string;
-  walletProxyUrl: string;
-}
-
-const NETWORKS: Record<string, ConcordiumNetwork> = {
-  testnet: {
-    grpcUrl: "https://grpc.testnet.concordium.com:20000",
-    walletProxyUrl: "https://wallet-proxy.testnet.concordium.com"
-  },
-  mainnet: {
-    grpcUrl: "https://grpc.mainnet.concordium.com:20000", 
-    walletProxyUrl: "https://wallet-proxy.mainnet.concordium.software"
-  }
-};
-
-// Configuration options for verification
-interface ConcordiumVerificationOptions {
-  network?: "testnet" | "mainnet";
-  timeout?: number; // timeout in milliseconds
-  retries?: number; // number of retry attempts
-  testMode?: boolean; // skip network calls for testing
-}
-
-// Signature object type
-interface ConcordiumSignature {
-  [key: string]: string | ConcordiumSignature;
-}
-
-// Default options
-const DEFAULT_OPTIONS: Required<ConcordiumVerificationOptions> = {
-  network: "testnet",
-  timeout: 50000, // 10 seconds
-  retries: 3,
-  testMode: true
-};
+const CONCORDIUM_VERIFIER_URL =
+  "https://web3id-verifier.mainnet.concordium.software";
 
 /**
- * Verifies a Concordium signature proof with proper cryptographic validation
+ * Verifies a Concordium signature proof using Concordium's hosted verifier service
  * @param proof The signature proof to verify
- * @param options Optional configuration for network and timeouts
  * @returns Promise resolving to the proof with updated status
  */
 export const verifyConcordiumSignature = async (
   proof: SignatureProof,
-  options: ConcordiumVerificationOptions = {}
 ): Promise<SignatureProof> => {
-  // Merge with default options
-  const config = { ...DEFAULT_OPTIONS, ...options };
-  
-  // Parse and validate address format
-  const [ns, networkId, address] = proof.address.split(/:/);
+  const [ns] = proof.address.split(/:/);
+
   if (ns !== "ccd") {
     return { ...proof, status: ProofStatus.FAILED };
   }
 
-  // Determine network from address or use config
-  let network = config.network;
-  if (networkId) {
-    // If network ID is specified in address, use it to determine network
-    network = networkId.includes("testnet") ? "testnet" : "mainnet";
-  }
-
   try {
-    // Validate signature format and extract signature data
-    let signature: ConcordiumSignature;
-    try {
-      signature = JSON.parse(proof.proof) as ConcordiumSignature;
-    } catch {
-      return { ...proof, status: ProofStatus.FAILED };
-    }
+    const presentationJson = JSON.parse(proof.proof) as VerifiablePresentation;
 
-    // Basic signature structure validation
-    if (!signature || typeof signature !== 'object' || Object.keys(signature).length === 0) {
-      return { ...proof, status: ProofStatus.FAILED };
+    // Validate presentation context matches attestation
+    if (presentationJson.presentationContext !== proof.attestation) {
+      throw new Error("Presentation context does not match attestation");
     }
 
-    // In test mode, skip network validation but still validate signature structure
-    if (config.testMode) {
-      // Perform signature format validation
-      try {
-        const signatureHex = convertSignatureToHex(signature);
-        
-        // Validate signature format
-        if (!signatureHex || signatureHex.length < 64 || !/^[0-9a-fA-F]+$/.test(signatureHex)) {
-          return { ...proof, status: ProofStatus.FAILED };
-        }
-        
-        return { ...proof, status: ProofStatus.VERIFIED };
-        
-      } catch {
-        return { ...proof, status: ProofStatus.FAILED };
-      }
-    }
-
-    // Production mode: validate account existence and get account info with retry logic
-    const accountInfo = await retryWithTimeout(
-      () => validateAccountAndGetInfo(address, network, config.timeout),
-      config.retries
-    );
-
-    if (!accountInfo) {
-      return { ...proof, status: ProofStatus.FAILED };
+    // Validate verifiableCredential exists and is not empty
+    if (
+      !presentationJson.verifiableCredential ||
+      presentationJson.verifiableCredential.length === 0
+    ) {
+      throw new Error("Verifiable credential is missing or empty");
     }
 
-    // Perform cryptographic signature verification
-    const isValidSignature = await retryWithTimeout(
-      () => verifyCryptographicSignature(
-        signature,
-        config.timeout,
-        // proof.attestation,
-        // address,
-        // network
-      ),
-      config.retries
-    );
+    // Use Concordium's hosted verifier instead of gRPC
+    const response = await fetch(`${CONCORDIUM_VERIFIER_URL}/v0/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(presentationJson),
+    });
 
-    if (isValidSignature) {
-      return { ...proof, status: ProofStatus.VERIFIED };
-    } else {
-      return { ...proof, status: ProofStatus.FAILED };
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Verifier returned ${response.status}: ${errorText}`);
     }
 
+    // If we get here, the proof is valid
+    return {
+      ...proof,
+      status: ProofStatus.VERIFIED,
+    };
   } catch {
-    return { ...proof, status: ProofStatus.FAILED };
+    return {
+      ...proof,
+      status: ProofStatus.FAILED,
+    };
   }
 };
-
-/**
- * Validates that a Concordium account exists and retrieves account information
- */
-async function validateAccountAndGetInfo(
-  address: string,
-  network: "testnet" | "mainnet",
-  timeout: number
-): Promise<boolean> {
-  const networkConfig = NETWORKS[network];
-  
-  try {
-    // Check account existence via wallet proxy (faster than gRPC for existence check)
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-    const response = await fetch(
-      `${networkConfig.walletProxyUrl}/v0/accEncryptionKey/${address}`,
-      {
-        method: 'GET',
-        headers: {
-          'Accept': 'application/json',
-          'User-Agent': 'verify-proof/1.6.0'
-        },
-        signal: controller.signal
-      }
-    );
-
-    clearTimeout(timeoutId);
-    return response.ok;
-
-  } catch (error) {
-    if (error instanceof Error && error.name === 'AbortError') {
-      throw new Error(`Account validation timeout after ${timeout}ms`);
-    }
-    throw error;
-  }
-}
-
-/**
- * Performs cryptographic verification of the signature using Concordium SDK
- * For production use, this would use the actual Concordium SDK verification methods
- * Currently implementing a comprehensive validation approach
- */
-async function verifyCryptographicSignature(
-  signature: ConcordiumSignature,
-  timeout: number,
-  // message?: string, // intentionally left out for now. Will enable for mainnet.
-  // address?: string,
-  // network?: "testnet" | "mainnet"
-): Promise<boolean> {
-  try {
-    // Convert signature format for verification
-    const signatureHex = convertSignatureToHex(signature);
-    
-    // For production, implement proper signature verification
-    // This is a placeholder for the actual SDK verification
-    // The exact method depends on the available SDK version
-    
-    // Validate that we have a proper signature hex string
-    if (!signatureHex || signatureHex.length < 64) {
-      return false;
-    }
-
-    // For now, return true if we have a valid signature structure
-    // In production, this should call the actual SDK verification method
-    // Example: 
-    // const client = new ConcordiumGRPCNodeClient(networkConfig.grpcUrl, 20000, credentials.createInsecure(), { timeout });
-    // const result = await client.verifyAccountSignature(address, message, signatureHex);
-    
-    // Placeholder validation - replace with actual SDK call
-    return signatureHex.length >= 64 && /^[0-9a-fA-F]+$/.test(signatureHex);
-
-  } catch (error) {
-    // Handle specific error types
-    if (error instanceof Error) {
-      if (error.message?.includes("timeout")) {
-        throw new Error(`Signature verification timeout after ${timeout}ms`);
-      }
-      
-      if (error.message?.includes("UNAVAILABLE")) {
-        throw new Error("Concordium node unavailable");
-      }
-
-      if (error.message?.includes("NOT_FOUND")) {
-        return false;
-      }
-    }
-
-    throw error;
-  }
-}
-
-/**
- * Converts the signature object to the format expected by Concordium SDK
- */
-function convertSignatureToHex(signature: ConcordiumSignature): string {
-  try {
-    // Handle different signature formats
-    if (typeof signature === 'string') {
-      return signature;
-    }
-
-    // Handle nested signature object format (common from wallet)
-    if (signature && typeof signature === 'object') {
-      // Extract signature from nested structure
-      const extractSignature = (obj: ConcordiumSignature): string | null => {
-        if (typeof obj === 'string') {
-          return obj;
-        }
-        
-        if (obj && typeof obj === 'object') {
-          for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-              const value = obj[key];
-              if (typeof value === 'string') {
-                return value;
-              } else if (typeof value === 'object') {
-                const result = extractSignature(value);
-                if (result) return result;
-              }
-            }
-          }
-        }
-        
-        return null;
-      };
-
-      const extractedSig = extractSignature(signature);
-      if (extractedSig) {
-        return extractedSig;
-      }
-    }
-
-    throw new Error("Unable to extract signature from object");
-    
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Invalid signature format: ${errorMessage}`);
-  }
-}
-
-/**
- * Utility function to retry operations with exponential backoff
- */
-async function retryWithTimeout<T>(
-  operation: () => Promise<T>,
-  maxRetries: number
-): Promise<T> {
-  let lastError: Error = new Error("No attempts made");
-  
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      const errorInstance = error instanceof Error ? error : new Error(String(error));
-      lastError = errorInstance;
-      
-      // Don't retry on certain types of errors
-      if (
-        errorInstance.message?.includes("Invalid signature") ||
-        errorInstance.message?.includes("Account not found")
-      ) {
-        throw errorInstance;
-      }
-
-      // Don't retry on the last attempt
-      if (attempt === maxRetries) {
-        break;
-      }
-
-      // Exponential backoff: wait 2^attempt * 1000ms
-      const delay = Math.min(Math.pow(2, attempt) * 1000, 5000);
-      await new Promise(resolve => setTimeout(resolve, delay));
-    }
-  }
-
-  throw lastError;
-}

package/src/cosmos.ts

@@ -8,6 +8,7 @@ import { StdSignDoc, serializeSignDoc } from "@cosmjs/amino";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { ripemd160 } from "@noble/hashes/legacy";
 import { sha256 } from "@noble/hashes/sha2";
+import { keccak_256 } from "@noble/hashes/sha3";
 
 // Base64 decode
 function base64ToUint8Array(base64: string): Uint8Array {
@@ -26,12 +27,47 @@ function toBase64Bytes(str: string): string {
 
 // Cosmos address derivation (ADR-36)
 // https://github.com/cosmos/cosmos-sdk/blob/214b11dcbaa129f7b4c0013b2103db9d54b85e9e/docs/architecture/adr-036-arbitrary-signature.md
-function deriveCosmosAddress(pubkey: Uint8Array, prefix = "cosmos"): string {
+function deriveCosmosAddress(pubkey: Uint8Array, prefix: string): string {
   const sha = sha256(pubkey);
   const rip = ripemd160(sha);
   return bech32.encode(prefix, bech32.toWords(rip));
 }
 
+// Ethermint-style chains (Injective, Evmos, ...) use eth-secp256k1 keys: the account is
+// the Ethereum address of the key, bech32-encoded under the chain prefix.
+function deriveEthAddress(pubkey: Uint8Array, prefix: string): string {
+  const uncompressed = secp256k1.ProjectivePoint.fromHex(pubkey)
+    .toRawBytes(false)
+    .slice(1);
+  const eth = keccak_256(uncompressed).slice(-20);
+  return bech32.encode(prefix, bech32.toWords(eth));
+}
+
+// Same selection Keplr's verifyADR36AminoSignDoc makes via its `algo` argument. The signed
+// address tells us which key algorithm the chain uses, so we do not depend on the
+// pub_key.type string wallets put in the amino signature.
+type CosmosKeyAlgo = "secp256k1" | "ethsecp256k1";
+
+function keyAlgoForAddress(
+  pubkey: Uint8Array,
+  address: string
+): CosmosKeyAlgo | undefined {
+  const prefix = bech32Prefix(address);
+  if (deriveCosmosAddress(pubkey, prefix) === address) {
+    return "secp256k1";
+  }
+  if (deriveEthAddress(pubkey, prefix) === address) {
+    return "ethsecp256k1";
+  }
+  return undefined;
+}
+
+// Each Cosmos SDK chain has its own human-readable part (cosmos, celestia, axelar, ...),
+// and bech32 separates it from the data with the last "1" in the string.
+function bech32Prefix(address: string): string {
+  return address.slice(0, address.lastIndexOf("1"));
+}
+
 export async function verifyCosmosSignature(
   proof: SignatureProof
 ): Promise<SignatureProof> {
@@ -47,9 +83,10 @@ export async function verifyCosmosSignature(
     );
     const signatureBytes = base64ToUint8Array(proof.proof);
 
-    // Step 1: Derive address from pubkey
-    const derivedAddress = deriveCosmosAddress(pubKeyBytes);
-    if (derivedAddress !== address) {
+    // Step 1: The pubkey must derive to the signed address; which derivation matches
+    // also decides the digest used in step 3.
+    const algo = keyAlgoForAddress(pubKeyBytes, address);
+    if (!algo) {
       return { ...proof, status: ProofStatus.FAILED };
     }
 
@@ -71,9 +108,10 @@ export async function verifyCosmosSignature(
       memo: "",
     };
 
-    // Step 3: Serialize + hash
+    // Step 3: Serialize + hash (ADR-036 digests are keccak256 on eth-secp256k1 chains)
     const signBytes = await serializeSignDoc(signDoc);
-    const digest = sha256(signBytes);
+    const digest =
+      algo === "ethsecp256k1" ? keccak_256(signBytes) : sha256(signBytes);
 
     // Step 4: Verify using secp256k1
     const verified = secp256k1.verify(signatureBytes, digest, pubKeyBytes);

package/src/index.ts

@@ -6,16 +6,8 @@ import {
   ProofTypes,
   ProofStatus,
 } from "@notabene/javascript-sdk";
-import { verifyBTCSignature } from "./bitcoin";
-import { verifyPersonalSignEIP191 } from "./eth";
-import { verifySolanaSignature, verifySolanaSIWS } from "./solana";
-import { verifyPersonalSignTIP191 } from "./tron";
-import { verifyCIP8Signature } from "./cardano";
-import { verifyPersonalSignXRPL } from "./xrpl";
-import { verifyStellarSignature } from "./xlm";
-import { verifyConcordiumSignature } from "./concordium";
-import { verifyCosmosSignature } from "./cosmos";
 
+// Use dynamic imports to ensure Buffer is available before loading crypto libraries
 export async function verifyProof(
   proof: OwnershipProof,
   publicKey?: string,
@@ -35,29 +27,48 @@ export async function verifyProof(
           ? ProofStatus.FLAGGED
           : ProofStatus.FAILED,
       };
-    case ProofTypes.CIP8:
+    case ProofTypes.CIP8: {
+      const { verifyCIP8Signature } = await import("./cardano");
       return verifyCIP8Signature(proof as SignatureProof);
-    case ProofTypes.EIP191:
+    }
+    case ProofTypes.EIP191: {
+      const { verifyPersonalSignEIP191 } = await import("./eth");
       return verifyPersonalSignEIP191(proof as SignatureProof);
-    case ProofTypes.ED25519:
+    }
+    case ProofTypes.ED25519: {
+      const { verifySolanaSignature } = await import("./solana");
       return verifySolanaSignature(proof as SignatureProof);
-    case ProofTypes.SOL_SIWX:
+    }
+    case ProofTypes.SOL_SIWX: {
+      const { verifySolanaSIWS } = await import("./solana");
       return verifySolanaSIWS(proof as SignatureProof);
-    case ProofTypes.XRP_ED25519:
+    }
+    case ProofTypes.XRP_ED25519: {
+      const { verifyPersonalSignXRPL } = await import("./xrpl");
       return verifyPersonalSignXRPL(proof as SignatureProof, publicKey);
-    case ProofTypes.XLM_ED25519:
+    }
+    case ProofTypes.XLM_ED25519: {
+      const { verifyStellarSignature } = await import("./xlm");
       return verifyStellarSignature(proof as SignatureProof);
-    case ProofTypes.CONCORDIUM: 
+    }
+    case ProofTypes.CONCORDIUM: {
+      const { verifyConcordiumSignature } = await import("./concordium");
       return verifyConcordiumSignature(proof as SignatureProof);
-    case ProofTypes.COSMOS:
+    }
+    case ProofTypes.COSMOS: {
+      const { verifyCosmosSignature } = await import("./cosmos");
       return verifyCosmosSignature(proof as SignatureProof);
+    }
     case ProofTypes.EIP712:
     case ProofTypes.BIP137:
-    case ProofTypes.BIP322:
+    case ProofTypes.BIP322: {
+      const { verifyBTCSignature } = await import("./bitcoin");
       return verifyBTCSignature(proof as SignatureProof);
-    case ProofTypes.TIP191:
+    }
+    case ProofTypes.TIP191: {
+      const { verifyPersonalSignTIP191 } = await import("./tron");
       return verifyPersonalSignTIP191(proof as SignatureProof);
-    case ProofTypes.BIP137_XPUB:
+    }
     case ProofTypes.MicroTransfer:
   }
   return proof;