@moltos/sdk 0.11.0 → 0.12.0

package/dist/chunk-TIRAZTCQ.mjs

@@ -0,0 +1,148 @@
+// src/crypto.ts
+import { createHash, randomBytes } from "crypto";
+var STUB_MODE = true;
+function setStubMode(enabled) {
+  STUB_MODE = enabled;
+}
+function isStubMode() {
+  return STUB_MODE;
+}
+function generateKeypair() {
+  const privateBytes = new Uint8Array(randomBytes(32));
+  const publicBytes = derivePublicKeyBytes(privateBytes);
+  return {
+    privateKey: {
+      bytes: privateBytes,
+      toHex: () => Buffer.from(privateBytes).toString("hex")
+    },
+    publicKey: {
+      type: "BLS12_381",
+      bytes: publicBytes,
+      toHex: () => Buffer.from(publicBytes).toString("hex")
+    },
+    mnemonic: generateMnemonic()
+  };
+}
+function deriveKeypair(mnemonic, path = "m/44'/60'/0'/0/0") {
+  const seed = createHash("sha256").update(mnemonic + path).digest();
+  const privateBytes = new Uint8Array(seed.slice(0, 32));
+  const publicBytes = derivePublicKeyBytes(privateBytes);
+  return {
+    privateKey: {
+      bytes: privateBytes,
+      toHex: () => Buffer.from(privateBytes).toString("hex")
+    },
+    publicKey: {
+      type: "BLS12_381",
+      bytes: publicBytes,
+      toHex: () => Buffer.from(publicBytes).toString("hex")
+    }
+  };
+}
+function hashPayload(payload) {
+  const canonical = JSON.stringify(payload, Object.keys(payload).sort());
+  const hash = createHash("sha256").update(canonical).digest();
+  return new Uint8Array(hash);
+}
+function signAttestation(payload, privateKey) {
+  const messageHash = hashPayload(payload);
+  const sigData = createHash("sha256").update(Buffer.from(messageHash)).update(Buffer.from(privateKey.bytes)).digest();
+  const sigBytes = new Uint8Array(sigData.slice(0, 48));
+  const signature = {
+    type: "BLS12_381",
+    bytes: sigBytes,
+    toHex: () => Buffer.from(sigBytes).toString("hex"),
+    aggregate: (other) => aggregateSignatures([sigBytes, other.bytes])
+  };
+  return {
+    payload,
+    signature,
+    publicKey: derivePublicKey(privateKey),
+    proof: {
+      type: "bls12_381",
+      scheme: "basic"
+    }
+  };
+}
+function verifyAttestation(signed) {
+  if (STUB_MODE) {
+    console.warn("[TAP-SDK] BLS verification running in STUB mode");
+    return true;
+  }
+  throw new Error("Real BLS verification not yet implemented. Use stub mode for testing.");
+}
+function batchVerifyAttestations(attestations) {
+  if (STUB_MODE) {
+    const valid = attestations.map(() => true);
+    return { valid, allValid: true };
+  }
+  throw new Error("Batch verification not yet implemented");
+}
+function aggregateSignatures(signatures) {
+  const bytes = signatures.map((s) => s instanceof Uint8Array ? s : s.bytes);
+  const result = new Uint8Array(48);
+  for (const sig of bytes) {
+    for (let i = 0; i < 48 && i < sig.length; i++) {
+      result[i] ^= sig[i];
+    }
+  }
+  return {
+    type: "BLS12_381",
+    bytes: result,
+    toHex: () => Buffer.from(result).toString("hex"),
+    aggregate: (other) => aggregateSignatures([result, other.bytes])
+  };
+}
+function verifyAggregate(message, aggregateSig, publicKeys) {
+  if (STUB_MODE) {
+    console.warn("[TAP-SDK] Aggregate verification running in STUB mode");
+    return true;
+  }
+  throw new Error("Aggregate verification not yet implemented");
+}
+function derivePublicKeyBytes(privateBytes) {
+  const hash = createHash("sha256").update(privateBytes).digest();
+  const publicBytes = new Uint8Array(96);
+  for (let i = 0; i < 96; i++) {
+    publicBytes[i] = hash[i % hash.length] ^ privateBytes[i % privateBytes.length];
+  }
+  return publicBytes;
+}
+function derivePublicKey(privateKey) {
+  return {
+    type: "BLS12_381",
+    bytes: derivePublicKeyBytes(privateKey.bytes),
+    toHex: () => Buffer.from(derivePublicKeyBytes(privateKey.bytes)).toString("hex")
+  };
+}
+function generateMnemonic() {
+  const words = ["abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract"];
+  const phrase = Array(12).fill(0).map(() => words[Math.floor(Math.random() * words.length)]);
+  return phrase.join(" ");
+}
+var crypto_default = {
+  generateKeypair,
+  deriveKeypair,
+  signAttestation,
+  verifyAttestation,
+  batchVerifyAttestations,
+  aggregateSignatures,
+  verifyAggregate,
+  hashPayload,
+  setStubMode,
+  isStubMode
+};
+
+export {
+  setStubMode,
+  isStubMode,
+  generateKeypair,
+  deriveKeypair,
+  hashPayload,
+  signAttestation,
+  verifyAttestation,
+  batchVerifyAttestations,
+  aggregateSignatures,
+  verifyAggregate,
+  crypto_default
+};

package/dist/crypto.mjs

@@ -1,137 +1,16 @@
-// src/crypto.ts
-import { createHash, randomBytes } from "crypto";
-var STUB_MODE = true;
-function setStubMode(enabled) {
-  STUB_MODE = enabled;
-}
-function isStubMode() {
-  return STUB_MODE;
-}
-function generateKeypair() {
-  const privateBytes = new Uint8Array(randomBytes(32));
-  const publicBytes = derivePublicKeyBytes(privateBytes);
-  return {
-    privateKey: {
-      bytes: privateBytes,
-      toHex: () => Buffer.from(privateBytes).toString("hex")
-    },
-    publicKey: {
-      type: "BLS12_381",
-      bytes: publicBytes,
-      toHex: () => Buffer.from(publicBytes).toString("hex")
-    },
-    mnemonic: generateMnemonic()
-  };
-}
-function deriveKeypair(mnemonic, path = "m/44'/60'/0'/0/0") {
-  const seed = createHash("sha256").update(mnemonic + path).digest();
-  const privateBytes = new Uint8Array(seed.slice(0, 32));
-  const publicBytes = derivePublicKeyBytes(privateBytes);
-  return {
-    privateKey: {
-      bytes: privateBytes,
-      toHex: () => Buffer.from(privateBytes).toString("hex")
-    },
-    publicKey: {
-      type: "BLS12_381",
-      bytes: publicBytes,
-      toHex: () => Buffer.from(publicBytes).toString("hex")
-    }
-  };
-}
-function hashPayload(payload) {
-  const canonical = JSON.stringify(payload, Object.keys(payload).sort());
-  const hash = createHash("sha256").update(canonical).digest();
-  return new Uint8Array(hash);
-}
-function signAttestation(payload, privateKey) {
-  const messageHash = hashPayload(payload);
-  const sigData = createHash("sha256").update(Buffer.from(messageHash)).update(Buffer.from(privateKey.bytes)).digest();
-  const sigBytes = new Uint8Array(sigData.slice(0, 48));
-  const signature = {
-    type: "BLS12_381",
-    bytes: sigBytes,
-    toHex: () => Buffer.from(sigBytes).toString("hex"),
-    aggregate: (other) => aggregateSignatures([sigBytes, other.bytes])
-  };
-  return {
-    payload,
-    signature,
-    publicKey: derivePublicKey(privateKey),
-    proof: {
-      type: "bls12_381",
-      scheme: "basic"
-    }
-  };
-}
-function verifyAttestation(signed) {
-  if (STUB_MODE) {
-    console.warn("[TAP-SDK] BLS verification running in STUB mode");
-    return true;
-  }
-  throw new Error("Real BLS verification not yet implemented. Use stub mode for testing.");
-}
-function batchVerifyAttestations(attestations) {
-  if (STUB_MODE) {
-    const valid = attestations.map(() => true);
-    return { valid, allValid: true };
-  }
-  throw new Error("Batch verification not yet implemented");
-}
-function aggregateSignatures(signatures) {
-  const bytes = signatures.map((s) => s instanceof Uint8Array ? s : s.bytes);
-  const result = new Uint8Array(48);
-  for (const sig of bytes) {
-    for (let i = 0; i < 48 && i < sig.length; i++) {
-      result[i] ^= sig[i];
-    }
-  }
-  return {
-    type: "BLS12_381",
-    bytes: result,
-    toHex: () => Buffer.from(result).toString("hex"),
-    aggregate: (other) => aggregateSignatures([result, other.bytes])
-  };
-}
-function verifyAggregate(message, aggregateSig, publicKeys) {
-  if (STUB_MODE) {
-    console.warn("[TAP-SDK] Aggregate verification running in STUB mode");
-    return true;
-  }
-  throw new Error("Aggregate verification not yet implemented");
-}
-function derivePublicKeyBytes(privateBytes) {
-  const hash = createHash("sha256").update(privateBytes).digest();
-  const publicBytes = new Uint8Array(96);
-  for (let i = 0; i < 96; i++) {
-    publicBytes[i] = hash[i % hash.length] ^ privateBytes[i % privateBytes.length];
-  }
-  return publicBytes;
-}
-function derivePublicKey(privateKey) {
-  return {
-    type: "BLS12_381",
-    bytes: derivePublicKeyBytes(privateKey.bytes),
-    toHex: () => Buffer.from(derivePublicKeyBytes(privateKey.bytes)).toString("hex")
-  };
-}
-function generateMnemonic() {
-  const words = ["abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract"];
-  const phrase = Array(12).fill(0).map(() => words[Math.floor(Math.random() * words.length)]);
-  return phrase.join(" ");
-}
-var crypto_default = {
-  generateKeypair,
-  deriveKeypair,
-  signAttestation,
-  verifyAttestation,
-  batchVerifyAttestations,
+import {
   aggregateSignatures,
-  verifyAggregate,
+  batchVerifyAttestations,
+  crypto_default,
+  deriveKeypair,
+  generateKeypair,
   hashPayload,
+  isStubMode,
   setStubMode,
-  isStubMode
-};
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+} from "./chunk-TIRAZTCQ.mjs";
 export {
   aggregateSignatures,
   batchVerifyAttestations,