@buildonspark/spark-sdk 0.1.46 → 0.2.0

package/dist/chunk-KMUMFYFX.js

@@ -1,137 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-GSI4OLXZ.js";
-import {
-  SparkAddress
-} from "./chunk-BGGEVUJK.js";
-
-// src/address/address.ts
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
-import { bech32m } from "@scure/base";
-import { UUID } from "uuidv7";
-import { bytesToNumberBE } from "@noble/curves/abstract/utils";
-var AddressNetwork = {
-  MAINNET: "sp",
-  TESTNET: "spt",
-  REGTEST: "sprt",
-  SIGNET: "sps",
-  LOCAL: "spl"
-};
-function encodeSparkAddress(payload) {
-  try {
-    isValidPublicKey(payload.identityPublicKey);
-    let paymentIntentFields;
-    if (payload.paymentIntentFields) {
-      paymentIntentFields = payload.paymentIntentFields;
-    }
-    const sparkAddressProto = SparkAddress.create({
-      identityPublicKey: hexToBytes(payload.identityPublicKey),
-      paymentIntentFields
-    });
-    const serializedPayload = SparkAddress.encode(sparkAddressProto).finish();
-    const words = bech32m.toWords(serializedPayload);
-    return bech32m.encode(
-      AddressNetwork[payload.network],
-      words,
-      500
-    );
-  } catch (error) {
-    throw new ValidationError(
-      "Failed to encode Spark address",
-      {
-        field: "publicKey",
-        value: payload.identityPublicKey
-      },
-      error
-    );
-  }
-}
-function decodeSparkAddress(address, network) {
-  try {
-    const decoded = bech32m.decode(address, 500);
-    if (decoded.prefix !== AddressNetwork[network]) {
-      throw new ValidationError("Invalid Spark address prefix", {
-        field: "address",
-        value: address,
-        expected: `prefix='${AddressNetwork[network]}'`
-      });
-    }
-    const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
-    const publicKey = bytesToHex(payload.identityPublicKey);
-    isValidPublicKey(publicKey);
-    const paymentIntentFields = payload.paymentIntentFields;
-    return {
-      identityPublicKey: publicKey,
-      network,
-      paymentIntentFields: paymentIntentFields && {
-        id: UUID.ofInner(paymentIntentFields.id).toString(),
-        assetIdentifier: paymentIntentFields.assetIdentifier ? bytesToHex(paymentIntentFields.assetIdentifier) : void 0,
-        assetAmount: bytesToNumberBE(paymentIntentFields.assetAmount),
-        memo: paymentIntentFields.memo
-      }
-    };
-  } catch (error) {
-    if (error instanceof ValidationError) {
-      throw error;
-    }
-    throw new ValidationError(
-      "Failed to decode Spark address",
-      {
-        field: "address",
-        value: address
-      },
-      error
-    );
-  }
-}
-function isValidSparkAddress(address) {
-  try {
-    const network = Object.entries(AddressNetwork).find(
-      ([_, prefix]) => address.startsWith(prefix)
-    )?.[0];
-    if (!network) {
-      throw new ValidationError("Invalid Spark address network", {
-        field: "network",
-        value: address,
-        expected: Object.values(AddressNetwork)
-      });
-    }
-    decodeSparkAddress(address, network);
-    return true;
-  } catch (error) {
-    if (error instanceof ValidationError) {
-      throw error;
-    }
-    throw new ValidationError(
-      "Invalid Spark address",
-      {
-        field: "address",
-        value: address
-      },
-      error
-    );
-  }
-}
-function isValidPublicKey(publicKey) {
-  try {
-    const point = secp256k1.ProjectivePoint.fromHex(publicKey);
-    point.assertValidity();
-  } catch (error) {
-    throw new ValidationError(
-      "Invalid public key",
-      {
-        field: "publicKey",
-        value: publicKey
-      },
-      error
-    );
-  }
-}
-
-export {
-  encodeSparkAddress,
-  decodeSparkAddress,
-  isValidSparkAddress,
-  isValidPublicKey
-};