@buildonspark/spark-sdk 0.1.44 → 0.1.45

package/dist/spark_bindings/native/index.js

@@ -0,0 +1,141 @@
+import "../../chunk-MVRQ5US7.js";
+
+// src/spark_bindings/native/index.ts
+import { NativeModules } from "react-native";
+var toNumberArray = (arr) => Array.from(arr);
+var toUint8Array = (arr) => new Uint8Array(arr);
+var { SparkFrostModule } = NativeModules;
+var NativeSparkFrost = class {
+  static async signFrost(params) {
+    if (!SparkFrostModule) {
+      throw new Error("NativeSparkFrost is not available in this environment");
+    }
+    const nativeParams = {
+      msg: toNumberArray(params.message),
+      keyPackage: {
+        secretKey: toNumberArray(params.keyPackage.secretKey),
+        publicKey: toNumberArray(params.keyPackage.publicKey),
+        verifyingKey: toNumberArray(params.keyPackage.verifyingKey)
+      },
+      nonce: {
+        hiding: toNumberArray(params.nonce.hiding),
+        binding: toNumberArray(params.nonce.binding)
+      },
+      selfCommitment: {
+        hiding: toNumberArray(params.selfCommitment.hiding),
+        binding: toNumberArray(params.selfCommitment.binding)
+      },
+      statechainCommitments: Object.fromEntries(
+        Object.entries(params.statechainCommitments ?? {}).map(([k, v]) => [
+          k,
+          {
+            hiding: toNumberArray(v.hiding),
+            binding: toNumberArray(v.binding)
+          }
+        ])
+      ),
+      adaptorPubKey: params.adaptorPubKey ? toNumberArray(params.adaptorPubKey) : void 0
+    };
+    const result = await SparkFrostModule.signFrost(nativeParams);
+    return toUint8Array(result);
+  }
+  static async aggregateFrost(params) {
+    const nativeParams = {
+      msg: toNumberArray(params.message),
+      statechainCommitments: Object.fromEntries(
+        Object.entries(params.statechainCommitments ?? {}).map(([k, v]) => [
+          k,
+          {
+            hiding: toNumberArray(v.hiding),
+            binding: toNumberArray(v.binding)
+          }
+        ])
+      ),
+      selfCommitment: {
+        hiding: toNumberArray(params.selfCommitment.hiding),
+        binding: toNumberArray(params.selfCommitment.binding)
+      },
+      statechainSignatures: Object.fromEntries(
+        Object.entries(params.statechainSignatures ?? {}).map(([k, v]) => [
+          k,
+          toNumberArray(v)
+        ])
+      ),
+      selfSignature: toNumberArray(params.selfSignature),
+      statechainPublicKeys: Object.fromEntries(
+        Object.entries(params.statechainPublicKeys ?? {}).map(([k, v]) => [
+          k,
+          toNumberArray(v)
+        ])
+      ),
+      selfPublicKey: toNumberArray(params.selfPublicKey),
+      verifyingKey: toNumberArray(params.verifyingKey),
+      adaptorPubKey: params.adaptorPubKey ? toNumberArray(params.adaptorPubKey) : void 0
+    };
+    const result = await SparkFrostModule.aggregateFrost(nativeParams);
+    return toUint8Array(result);
+  }
+  static async createDummyTx(address, amountSats) {
+    if (!SparkFrostModule) {
+      console.error("NativeSparkFrost.ts: SparkFrostModule is not available.");
+      throw new Error("SparkFrostModule is not available");
+    }
+    try {
+      const bridgeParams = {
+        address,
+        amountSats: amountSats.toString()
+        // JS sends string for bigint
+      };
+      const result = await SparkFrostModule.createDummyTx(bridgeParams);
+      if (result && Array.isArray(result.tx) && typeof result.txid === "string") {
+        return {
+          tx: toUint8Array(result.tx),
+          txid: result.txid
+        };
+      } else {
+        console.error(
+          "NativeSparkFrost.ts: Invalid result structure from native call. Result:",
+          result
+        );
+        throw new Error(
+          "Invalid result structure from createDummyTx native call"
+        );
+      }
+    } catch (e) {
+      console.error(
+        "NativeSparkFrost.ts: Error during SparkFrostModule.createDummyTx call:",
+        e
+      );
+      throw e;
+    }
+  }
+  static async encryptEcies(msg, publicKey) {
+    const result = await SparkFrostModule.encryptEcies({
+      msg: toNumberArray(msg),
+      publicKey: toNumberArray(publicKey)
+    });
+    return toUint8Array(result);
+  }
+  static async decryptEcies(encryptedMsg, privateKey) {
+    const result = await SparkFrostModule.decryptEcies({
+      encryptedMsg: toNumberArray(encryptedMsg),
+      privateKey: toNumberArray(privateKey)
+    });
+    return toUint8Array(result);
+  }
+};
+async function createDummyTx(address, amountSats) {
+  return NativeSparkFrost.createDummyTx(address, amountSats);
+}
+async function encryptEcies(msg, publicKey) {
+  return NativeSparkFrost.encryptEcies(msg, publicKey);
+}
+async function decryptEcies(encryptedMsg, privateKey) {
+  return NativeSparkFrost.decryptEcies(encryptedMsg, privateKey);
+}
+export {
+  NativeSparkFrost,
+  createDummyTx,
+  decryptEcies,
+  encryptEcies
+};