@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/chunk-GSI4OLXZ.js

@@ -1,117 +0,0 @@
-// src/errors/base.ts
-import { bytesToHex } from "@noble/hashes/utils";
-var SparkSDKError = class extends Error {
-  context;
-  originalError;
-  constructor(message, context = {}, originalError) {
-    const msg = getMessage(message, context, originalError);
-    super(msg);
-    this.name = this.constructor.name;
-    this.context = context;
-    this.originalError = originalError;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  toString() {
-    return this.message;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      context: this.context,
-      originalError: this.originalError ? {
-        name: this.originalError.name,
-        message: this.originalError.message,
-        stack: this.originalError.stack
-      } : void 0,
-      stack: this.stack
-    };
-  }
-};
-function getMessage(message, context = {}, originalError) {
-  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${safeStringify(value)}`).join(", ");
-  const originalErrorStr = originalError ? `
-Original Error: ${originalError.message}` : "";
-  return `SparkSDKError: ${message}${contextStr ? `
-Context: ${contextStr}` : ""}${originalErrorStr}`;
-}
-function safeStringify(value) {
-  const replacer = (_, v) => {
-    if (typeof v === "bigint") {
-      return v.toString();
-    }
-    if (v instanceof Uint8Array) {
-      return formatUint8Array(v);
-    }
-    return v;
-  };
-  if (typeof value === "bigint") {
-    return `"${value.toString()}"`;
-  }
-  if (value instanceof Uint8Array) {
-    return `"${formatUint8Array(value)}"`;
-  }
-  try {
-    const result = JSON.stringify(value, replacer);
-    return result === void 0 ? String(value) : result;
-  } catch {
-    try {
-      return String(value);
-    } catch {
-      return "[Unserializable]";
-    }
-  }
-}
-function formatUint8Array(arr) {
-  return `Uint8Array(0x${bytesToHex(arr)})`;
-}
-
-// src/errors/types.ts
-var NetworkError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var ValidationError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var InternalValidationError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var AuthenticationError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var RPCError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var ConfigurationError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var NotImplementedError = class extends SparkSDKError {
-  constructor(message, context, originalError) {
-    super(message, context, originalError);
-  }
-};
-
-export {
-  SparkSDKError,
-  NetworkError,
-  ValidationError,
-  InternalValidationError,
-  AuthenticationError,
-  RPCError,
-  ConfigurationError,
-  NotImplementedError
-};

package/dist/chunk-GZ5IPPJ2.js

@@ -1,170 +0,0 @@
-import {
-  SparkServiceDefinition
-} from "./chunk-NTFKFRQ2.js";
-import {
-  clientEnv,
-  isBun,
-  isReactNative
-} from "./chunk-7V6N75CC.js";
-import {
-  NetworkError
-} from "./chunk-GSI4OLXZ.js";
-
-// src/services/lrc-connection.ts
-import { isNode } from "@lightsparkdev/core";
-import { retryMiddleware } from "nice-grpc-client-middleware-retry";
-import { Metadata } from "nice-grpc-common";
-var Lrc20ConnectionManager = class {
-  config;
-  lrc20Client;
-  constructor(config) {
-    this.config = config;
-  }
-  async closeConnection() {
-    this.lrc20Client?.close?.();
-  }
-  async createChannelWithTLS(address, certPath) {
-    try {
-      if (isNode && !isBun) {
-        const grpcModule = await import("nice-grpc");
-        const { ChannelCredentials, createChannel } = "default" in grpcModule ? grpcModule.default : grpcModule;
-        if (certPath) {
-          try {
-            const fs = await import("fs");
-            const cert = fs.readFileSync(certPath);
-            return createChannel(address, ChannelCredentials.createSsl(cert));
-          } catch (error) {
-            console.error("Error reading certificate:", error);
-            return createChannel(
-              address,
-              ChannelCredentials.createSsl(null, null, null, {
-                rejectUnauthorized: false
-              })
-            );
-          }
-        } else {
-          return createChannel(
-            address,
-            ChannelCredentials.createSsl(null, null, null, {
-              rejectUnauthorized: false
-            })
-          );
-        }
-      } else {
-        const grpcModule = await import("nice-grpc-web");
-        const { createChannel, FetchTransport } = "default" in grpcModule ? grpcModule.default : grpcModule;
-        const { XHRTransport } = await import("./xhr-transport-RH6LDRXS.js");
-        return createChannel(
-          address,
-          isReactNative ? XHRTransport() : FetchTransport()
-        );
-      }
-    } catch (error) {
-      console.error("Channel creation error:", error);
-      throw new NetworkError(
-        "Failed to create channel",
-        {
-          url: address,
-          operation: "createChannel",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async createLrc20Client(certPath) {
-    if (this.lrc20Client) {
-      return this.lrc20Client;
-    }
-    const channel = await this.createChannelWithTLS(
-      this.config.getLrc20Address(),
-      certPath
-    );
-    const middleware = this.createMiddleware();
-    const client = await this.createGrpcClient(
-      SparkServiceDefinition,
-      channel,
-      true,
-      middleware
-    );
-    this.lrc20Client = client;
-    return client;
-  }
-  createMiddleware() {
-    if (isNode) {
-      return this.createNodeMiddleware();
-    } else {
-      return this.createBrowserMiddleware();
-    }
-  }
-  createNodeMiddleware() {
-    return async function* (call, options) {
-      return yield* call.next(call.request, {
-        ...options,
-        metadata: Metadata(options.metadata).set("X-Client-Env", clientEnv)
-      });
-    }.bind(this);
-  }
-  createBrowserMiddleware() {
-    return async function* (call, options) {
-      return yield* call.next(call.request, {
-        ...options,
-        metadata: Metadata(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("X-Client-Env", clientEnv)
-      });
-    }.bind(this);
-  }
-  async createGrpcClient(defintion, channel, withRetries, middleware) {
-    let clientFactory;
-    const retryOptions = {
-      retry: true,
-      retryMaxAttempts: 3
-    };
-    let options = {};
-    const isNodeChannel = "close" in channel;
-    if (isNode && isNodeChannel && !isBun) {
-      const grpcModule = await import("nice-grpc");
-      const { openTelemetryClientMiddleware } = await import("nice-grpc-opentelemetry");
-      const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;
-      clientFactory = createClientFactory();
-      if (withRetries) {
-        options = retryOptions;
-        clientFactory = clientFactory.use(openTelemetryClientMiddleware()).use(retryMiddleware);
-      }
-      if (middleware) {
-        clientFactory = clientFactory.use(middleware);
-      }
-      const client = clientFactory.create(defintion, channel, {
-        "*": options
-      });
-      return {
-        ...client,
-        close: channel.close.bind(channel)
-      };
-    } else if (!isNodeChannel) {
-      const grpcModule = await import("nice-grpc-web");
-      const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;
-      clientFactory = createClientFactory();
-      if (withRetries) {
-        options = retryOptions;
-        clientFactory = clientFactory.use(retryMiddleware);
-      }
-      if (middleware) {
-        clientFactory = clientFactory.use(middleware);
-      }
-      const client = clientFactory.create(defintion, channel, {
-        "*": options
-      });
-      return {
-        ...client,
-        close: void 0
-      };
-    } else {
-      throw new Error("Channel does not have close in NodeJS environment");
-    }
-  }
-};
-
-export {
-  Lrc20ConnectionManager
-};

package/dist/chunk-HWJWKEIU.js

@@ -1,75 +0,0 @@
-import {
-  NetworkError
-} from "./chunk-GSI4OLXZ.js";
-
-// src/utils/token-transactions.ts
-import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
-function calculateAvailableTokenAmount(outputLeaves) {
-  return outputLeaves.reduce(
-    (sum, output) => sum + BigInt(bytesToNumberBE(output.output.tokenAmount)),
-    BigInt(0)
-  );
-}
-function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, tokenPublicKey) {
-  const tokenPubKeyHex = bytesToHex(tokenPublicKey);
-  const tokenOutputsAvailable = tokenOutputs.get(tokenPubKeyHex);
-  if (!tokenOutputsAvailable) {
-    return false;
-  }
-  if (selectedOutputs.length === 0 || tokenOutputsAvailable.length < selectedOutputs.length) {
-    return false;
-  }
-  const availableOutputIds = new Set(
-    tokenOutputsAvailable.map((output) => output.output.id)
-  );
-  for (const selectedOutput of selectedOutputs) {
-    if (!selectedOutput.output?.id || !availableOutputIds.has(selectedOutput.output.id)) {
-      return false;
-    }
-  }
-  return true;
-}
-function filterTokenBalanceForTokenPublicKey(tokenBalances, publicKey) {
-  if (!tokenBalances) {
-    return { balance: 0n };
-  }
-  const tokenBalance = [...tokenBalances.entries()].find(
-    ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
-  );
-  if (!tokenBalance) {
-    return {
-      balance: 0n
-    };
-  }
-  return {
-    balance: tokenBalance[1].balance
-  };
-}
-
-// src/utils/response-validation.ts
-function collectResponses(responses) {
-  const successfulResponses = responses.filter(
-    (result) => result.status === "fulfilled"
-  ).map((result) => result.value);
-  const failedResponses = responses.filter(
-    (result) => result.status === "rejected"
-  );
-  if (failedResponses.length > 0) {
-    const errors = failedResponses.map((result) => result.reason).join("\n");
-    throw new NetworkError(
-      `${failedResponses.length} out of ${responses.length} requests failed, please try again`,
-      {
-        errorCount: failedResponses.length,
-        errors
-      }
-    );
-  }
-  return successfulResponses;
-}
-
-export {
-  calculateAvailableTokenAmount,
-  checkIfSelectedOutputsAreAvailable,
-  filterTokenBalanceForTokenPublicKey,
-  collectResponses
-};

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