@buildonspark/spark-sdk 0.1.43 → 0.1.45

package/dist/spark_bindings/native/index.cjs

@@ -0,0 +1,183 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/spark_bindings/native/index.ts
+var native_exports = {};
+__export(native_exports, {
+  NativeSparkFrost: () => NativeSparkFrost,
+  createDummyTx: () => createDummyTx,
+  decryptEcies: () => decryptEcies,
+  encryptEcies: () => encryptEcies
+});
+module.exports = __toCommonJS(native_exports);
+
+// buffer.js
+var import_buffer = require("buffer");
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = import_buffer.Buffer;
+}
+if (typeof window !== "undefined") {
+  if (typeof window.global === "undefined") {
+    window.global = window;
+  }
+  if (typeof window.globalThis === "undefined") {
+    window.globalThis = window;
+  }
+}
+
+// src/spark_bindings/native/index.ts
+var import_react_native = require("react-native");
+var toNumberArray = (arr) => Array.from(arr);
+var toUint8Array = (arr) => new Uint8Array(arr);
+var { SparkFrostModule } = import_react_native.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NativeSparkFrost,
+  createDummyTx,
+  decryptEcies,
+  encryptEcies
+});

package/dist/spark_bindings/native/index.d.cts

@@ -0,0 +1,14 @@
+import { S as SignFrostParams, A as AggregateFrostParams, D as DummyTx } from '../../types-C-Rp0Oo7.cjs';
+
+declare class NativeSparkFrost {
+    static signFrost(params: SignFrostParams): Promise<Uint8Array>;
+    static aggregateFrost(params: AggregateFrostParams): Promise<Uint8Array>;
+    static createDummyTx(address: string, amountSats: bigint): Promise<DummyTx>;
+    static encryptEcies(msg: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    static decryptEcies(encryptedMsg: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;
+}
+declare function createDummyTx(address: string, amountSats: bigint): Promise<DummyTx>;
+declare function encryptEcies(msg: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+declare function decryptEcies(encryptedMsg: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;
+
+export { NativeSparkFrost, createDummyTx, decryptEcies, encryptEcies };

package/dist/spark_bindings/native/index.d.ts

@@ -0,0 +1,14 @@
+import { S as SignFrostParams, A as AggregateFrostParams, D as DummyTx } from '../../types-C-Rp0Oo7.js';
+
+declare class NativeSparkFrost {
+    static signFrost(params: SignFrostParams): Promise<Uint8Array>;
+    static aggregateFrost(params: AggregateFrostParams): Promise<Uint8Array>;
+    static createDummyTx(address: string, amountSats: bigint): Promise<DummyTx>;
+    static encryptEcies(msg: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    static decryptEcies(encryptedMsg: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;
+}
+declare function createDummyTx(address: string, amountSats: bigint): Promise<DummyTx>;
+declare function encryptEcies(msg: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+declare function decryptEcies(encryptedMsg: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;
+
+export { NativeSparkFrost, createDummyTx, decryptEcies, encryptEcies };

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
+};