@buildonspark/issuer-sdk 0.0.21 → 0.0.23

package/dist/chunk-GB7N6I5O.js

@@ -0,0 +1,48 @@
+// buffer.js
+import { Buffer } from "buffer";
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = Buffer;
+}
+if (typeof global === "undefined") {
+  window.global = window.globalThis;
+}
+
+// src/types.ts
+var LayerType = /* @__PURE__ */ ((LayerType2) => {
+  LayerType2["L1"] = "L1";
+  LayerType2["SPARK"] = "SPARK";
+  return LayerType2;
+})(LayerType || {});
+var OperationType = /* @__PURE__ */ ((OperationType2) => {
+  OperationType2["USER_TRANSFER"] = "USER_TRANSFER";
+  OperationType2["USER_BURN"] = "USER_BURN";
+  OperationType2["ISSUER_ANNOUNCE"] = "ISSUER_ANNOUNCE";
+  OperationType2["ISSUER_MINT"] = "ISSUER_MINT";
+  OperationType2["ISSUER_TRANSFER"] = "ISSUER_TRANSFER";
+  OperationType2["ISSUER_FREEZE"] = "ISSUER_FREEZE";
+  OperationType2["ISSUER_UNFREEZE"] = "ISSUER_UNFREEZE";
+  OperationType2["ISSUER_BURN"] = "ISSUER_BURN";
+  return OperationType2;
+})(OperationType || {});
+var OnChainTransactionStatus = /* @__PURE__ */ ((OnChainTransactionStatus2) => {
+  OnChainTransactionStatus2["PENDING"] = "PENDING";
+  OnChainTransactionStatus2["CONFIRMED"] = "CONFIRMED";
+  OnChainTransactionStatus2["WAITING_MINED"] = "WAITING_MINED";
+  OnChainTransactionStatus2["MINED"] = "MINED";
+  OnChainTransactionStatus2["ATTACHING"] = "ATTACHING";
+  OnChainTransactionStatus2["ATTACHED"] = "ATTACHED";
+  return OnChainTransactionStatus2;
+})(OnChainTransactionStatus || {});
+var SparkTransactionStatus = /* @__PURE__ */ ((SparkTransactionStatus2) => {
+  SparkTransactionStatus2["STARTED"] = "STARTED";
+  SparkTransactionStatus2["SIGNED"] = "SIGNED";
+  SparkTransactionStatus2["FINALIZED"] = "FINALIZED";
+  return SparkTransactionStatus2;
+})(SparkTransactionStatus || {});
+
+export {
+  LayerType,
+  OperationType,
+  OnChainTransactionStatus,
+  SparkTransactionStatus
+};

package/dist/index.cjs

@@ -0,0 +1,518 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  IssuerSparkWallet: () => IssuerSparkWallet
+});
+module.exports = __toCommonJS(index_exports);
+
+// buffer.js
+var import_buffer = require("buffer");
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = import_buffer.Buffer;
+}
+if (typeof global === "undefined") {
+  window.global = window.globalThis;
+}
+
+// src/issuer-spark-wallet.ts
+var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
+var import_spark_sdk = require("@buildonspark/spark-sdk");
+var import_utils5 = require("@buildonspark/spark-sdk/utils");
+var import_utils6 = require("@noble/curves/abstract/utils");
+var import_bip39 = require("@scure/bip39");
+var import_english = require("@scure/bip39/wordlists/english");
+
+// src/services/freeze.ts
+var import_utils2 = require("@buildonspark/spark-sdk/utils");
+
+// src/utils/token-hashing.ts
+var import_utils = require("@scure/btc-signer/utils");
+function hashFreezeTokensPayload(payload) {
+  if (!payload) {
+    throw new Error("freeze tokens payload cannot be nil");
+  }
+  let allHashes = [];
+  const ownerPubKeyHash = import_utils.sha256.create();
+  if (payload.ownerPublicKey) {
+    ownerPubKeyHash.update(payload.ownerPublicKey);
+  }
+  allHashes.push(ownerPubKeyHash.digest());
+  const tokenPubKeyHash = import_utils.sha256.create();
+  if (payload.tokenPublicKey) {
+    tokenPubKeyHash.update(payload.tokenPublicKey);
+  }
+  allHashes.push(tokenPubKeyHash.digest());
+  const shouldUnfreezeHash = import_utils.sha256.create();
+  shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
+  allHashes.push(shouldUnfreezeHash.digest());
+  const timestampHash = import_utils.sha256.create();
+  if (payload.issuerProvidedTimestamp) {
+    const timestampBytes = new Uint8Array(8);
+    new DataView(timestampBytes.buffer).setBigUint64(
+      0,
+      BigInt(payload.issuerProvidedTimestamp),
+      true
+      // true for little-endian
+    );
+    timestampHash.update(timestampBytes);
+  }
+  allHashes.push(timestampHash.digest());
+  const operatorPubKeyHash = import_utils.sha256.create();
+  if (payload.operatorIdentityPublicKey) {
+    operatorPubKeyHash.update(payload.operatorIdentityPublicKey);
+  }
+  allHashes.push(operatorPubKeyHash.digest());
+  const finalHash = import_utils.sha256.create();
+  for (const hash of allHashes) {
+    finalHash.update(hash);
+  }
+  return finalHash.digest();
+}
+
+// src/services/freeze.ts
+var TokenFreezeService = class {
+  config;
+  connectionManager;
+  constructor(config, connectionManager) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+  }
+  async freezeTokens(ownerPublicKey, tokenPublicKey) {
+    return this.freezeOperation(ownerPublicKey, tokenPublicKey, false);
+  }
+  async unfreezeTokens(ownerPublicKey, tokenPublicKey) {
+    return this.freezeOperation(ownerPublicKey, tokenPublicKey, true);
+  }
+  async freezeOperation(ownerPublicKey, tokenPublicKey, shouldUnfreeze) {
+    const signingOperators = this.config.getSigningOperators();
+    const issuerProvidedTimestamp = Date.now();
+    const freezeResponses = await Promise.allSettled(
+      Object.entries(signingOperators).map(async ([identifier, operator]) => {
+        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
+        const freezeTokensPayload = {
+          ownerPublicKey,
+          tokenPublicKey,
+          shouldUnfreeze,
+          issuerProvidedTimestamp,
+          operatorIdentityPublicKey: operator.identityPublicKey
+        };
+        const hashedPayload = hashFreezeTokensPayload(freezeTokensPayload);
+        const issuerSignature = await this.config.signer.signMessageWithIdentityKey(hashedPayload);
+        const response = await internalSparkClient.freeze_tokens({
+          freezeTokensPayload,
+          issuerSignature
+        });
+        return {
+          identifier,
+          response
+        };
+      })
+    );
+    const successfulResponses = (0, import_utils2.validateResponses)(freezeResponses);
+    return successfulResponses[0].response;
+  }
+};
+
+// src/services/token-transactions.ts
+var import_token_transactions = require("@buildonspark/spark-sdk/token-transactions");
+var import_utils3 = require("@noble/curves/abstract/utils");
+var IssuerTokenTransactionService = class extends import_token_transactions.TokenTransactionService {
+  constructor(config, connectionManager) {
+    super(config, connectionManager);
+  }
+  async constructMintTokenTransaction(tokenPublicKey, tokenAmount) {
+    return {
+      tokenInput: {
+        $case: "mintInput",
+        mintInput: {
+          issuerPublicKey: tokenPublicKey,
+          issuerProvidedTimestamp: Date.now()
+        }
+      },
+      outputLeaves: [
+        {
+          ownerPublicKey: tokenPublicKey,
+          tokenPublicKey,
+          tokenAmount: (0, import_utils3.numberToBytesBE)(tokenAmount, 16)
+        }
+      ],
+      sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys()
+    };
+  }
+};
+
+// src/utils/type-mappers.ts
+var import_utils4 = require("@noble/curves/abstract/utils");
+
+// src/utils/enum-mappers.ts
+var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
+function mapOperationType(type) {
+  switch (type) {
+    case import_lrc20_sdk.Lrc20Protos.OperationType.USER_TRANSFER:
+      return "USER_TRANSFER" /* USER_TRANSFER */;
+    case import_lrc20_sdk.Lrc20Protos.OperationType.USER_BURN:
+      return "USER_BURN" /* USER_BURN */;
+    case import_lrc20_sdk.Lrc20Protos.OperationType.ISSUER_ANNOUNCE:
+      return "ISSUER_ANNOUNCE" /* ISSUER_ANNOUNCE */;
+    case import_lrc20_sdk.Lrc20Protos.OperationType.ISSUER_MINT:
+      return "ISSUER_MINT" /* ISSUER_MINT */;
+    case import_lrc20_sdk.Lrc20Protos.OperationType.ISSUER_TRANSFER:
+      return "ISSUER_TRANSFER" /* ISSUER_TRANSFER */;
+    case import_lrc20_sdk.Lrc20Protos.OperationType.ISSUER_FREEZE:
+      return "ISSUER_FREEZE" /* ISSUER_FREEZE */;
+    case import_lrc20_sdk.Lrc20Protos.OperationType.ISSUER_UNFREEZE:
+      return "ISSUER_UNFREEZE" /* ISSUER_UNFREEZE */;
+    case import_lrc20_sdk.Lrc20Protos.OperationType.ISSUER_BURN:
+      return "ISSUER_BURN" /* ISSUER_BURN */;
+    default:
+      return "USER_TRANSFER" /* USER_TRANSFER */;
+  }
+}
+function mapOnChainTransactionStatus(status) {
+  switch (status) {
+    case import_lrc20_sdk.Lrc20Protos.OnChainTransactionStatus.PENDING:
+      return "PENDING" /* PENDING */;
+    case import_lrc20_sdk.Lrc20Protos.OnChainTransactionStatus.CONFIRMED:
+      return "CONFIRMED" /* CONFIRMED */;
+    case import_lrc20_sdk.Lrc20Protos.OnChainTransactionStatus.WAITING_MINED:
+      return "WAITING_MINED" /* WAITING_MINED */;
+    case import_lrc20_sdk.Lrc20Protos.OnChainTransactionStatus.MINED:
+      return "MINED" /* MINED */;
+    case import_lrc20_sdk.Lrc20Protos.OnChainTransactionStatus.ATTACHING:
+      return "ATTACHING" /* ATTACHING */;
+    case import_lrc20_sdk.Lrc20Protos.OnChainTransactionStatus.ATTACHED:
+      return "ATTACHED" /* ATTACHED */;
+    default:
+      return "PENDING" /* PENDING */;
+  }
+}
+function mapSparkTransactionStatus(status) {
+  switch (status) {
+    case import_lrc20_sdk.Lrc20Protos.SparkTransactionStatus.STARTED:
+      return "STARTED" /* STARTED */;
+    case import_lrc20_sdk.Lrc20Protos.SparkTransactionStatus.SIGNED:
+      return "SIGNED" /* SIGNED */;
+    case import_lrc20_sdk.Lrc20Protos.SparkTransactionStatus.FINALIZED:
+      return "FINALIZED" /* FINALIZED */;
+    default:
+      return "STARTED" /* STARTED */;
+  }
+}
+function mapLayer(layer) {
+  switch (layer) {
+    case 0:
+      return "L1" /* L1 */;
+    case 1:
+      return "SPARK" /* SPARK */;
+    default:
+      return "L1" /* L1 */;
+  }
+}
+
+// src/utils/type-mappers.ts
+function convertToTokenPubKeyInfoResponse(tokenPubkeyInfo) {
+  return {
+    announcement: tokenPubkeyInfo?.announcement ? {
+      tokenPubkey: {
+        pubkey: (0, import_utils4.bytesToHex)(tokenPubkeyInfo.announcement.tokenPubkey.pubkey)
+      },
+      name: tokenPubkeyInfo.announcement.name,
+      symbol: tokenPubkeyInfo.announcement.symbol,
+      decimal: tokenPubkeyInfo.announcement.decimal,
+      maxSupply: tokenPubkeyInfo.announcement.maxSupply,
+      isFreezable: tokenPubkeyInfo.announcement.isFreezable
+    } : null,
+    totalSupply: tokenPubkeyInfo?.totalSupply ?? "0"
+  };
+}
+function convertTokenActivityToHexEncoded(rawTransactions) {
+  const response = {
+    transactions: rawTransactions.transactions.map((transaction) => {
+      if (!transaction.transaction) {
+        return { transaction: void 0 };
+      }
+      if (transaction.transaction.$case === "onChain") {
+        const onChain = transaction.transaction.onChain;
+        return {
+          transaction: {
+            $case: "onChain",
+            onChain: {
+              operationType: mapOperationType(onChain.operationType),
+              transactionHash: (0, import_utils4.bytesToHex)(onChain.transactionHash),
+              rawtx: (0, import_utils4.bytesToHex)(onChain.rawtx),
+              status: mapOnChainTransactionStatus(onChain.status),
+              inputs: onChain.inputs.map((input) => ({
+                rawTx: (0, import_utils4.bytesToHex)(input.rawTx),
+                vout: input.vout,
+                amountSats: input.amountSats,
+                tokenPublicKey: input.tokenPublicKey,
+                tokenAmount: input.tokenAmount ? (0, import_utils4.bytesToNumberBE)(input.tokenAmount).toString() : void 0
+              })),
+              outputs: onChain.outputs.map((output) => ({
+                rawTx: (0, import_utils4.bytesToHex)(output.rawTx),
+                vout: output.vout,
+                amountSats: output.amountSats,
+                tokenPublicKey: output.tokenPublicKey,
+                tokenAmount: output.tokenAmount ? (0, import_utils4.bytesToNumberBE)(output.tokenAmount).toString() : void 0
+              })),
+              broadcastedAt: onChain.broadcastedAt,
+              confirmedAt: onChain.confirmedAt
+            }
+          }
+        };
+      } else if (transaction.transaction.$case === "spark") {
+        const spark = transaction.transaction.spark;
+        return {
+          transaction: {
+            $case: "spark",
+            spark: {
+              operationType: mapOperationType(spark.operationType),
+              transactionHash: (0, import_utils4.bytesToHex)(spark.transactionHash),
+              status: mapSparkTransactionStatus(spark.status),
+              confirmedAt: spark.confirmedAt,
+              leavesToCreate: spark.leavesToCreate.map((leaf) => ({
+                tokenPublicKey: (0, import_utils4.bytesToHex)(leaf.tokenPublicKey),
+                id: leaf.id,
+                ownerPublicKey: (0, import_utils4.bytesToHex)(leaf.ownerPublicKey),
+                revocationPublicKey: (0, import_utils4.bytesToHex)(leaf.revocationPublicKey),
+                withdrawalBondSats: leaf.withdrawalBondSats,
+                withdrawalLocktime: leaf.withdrawalLocktime,
+                tokenAmount: (0, import_utils4.bytesToNumberBE)(leaf.tokenAmount).toString(),
+                createTxHash: (0, import_utils4.bytesToHex)(leaf.createTxHash),
+                createTxVoutIndex: leaf.createTxVoutIndex,
+                spendTxHash: leaf.spendTxHash ? (0, import_utils4.bytesToHex)(leaf.spendTxHash) : void 0,
+                spendTxVoutIndex: leaf.spendTxVoutIndex,
+                isFrozen: leaf.isFrozen
+              })),
+              leavesToSpend: spark.leavesToSpend.map((leaf) => ({
+                tokenPublicKey: (0, import_utils4.bytesToHex)(leaf.tokenPublicKey),
+                id: leaf.id,
+                ownerPublicKey: (0, import_utils4.bytesToHex)(leaf.ownerPublicKey),
+                revocationPublicKey: (0, import_utils4.bytesToHex)(leaf.revocationPublicKey),
+                withdrawalBondSats: leaf.withdrawalBondSats,
+                withdrawalLocktime: leaf.withdrawalLocktime,
+                tokenAmount: (0, import_utils4.bytesToNumberBE)(leaf.tokenAmount).toString(),
+                createTxHash: (0, import_utils4.bytesToHex)(leaf.createTxHash),
+                createTxVoutIndex: leaf.createTxVoutIndex,
+                spendTxHash: leaf.spendTxHash ? (0, import_utils4.bytesToHex)(leaf.spendTxHash) : void 0,
+                spendTxVoutIndex: leaf.spendTxVoutIndex,
+                isFrozen: leaf.isFrozen
+              })),
+              sparkOperatorIdentityPublicKeys: spark.sparkOperatorIdentityPublicKeys.map((key) => (0, import_utils4.bytesToHex)(key))
+            }
+          }
+        };
+      }
+      return { transaction: void 0 };
+    }),
+    nextCursor: rawTransactions.nextCursor ? {
+      lastTransactionHash: (0, import_utils4.bytesToHex)(rawTransactions.nextCursor.lastTransactionHash),
+      layer: mapLayer(rawTransactions.nextCursor.layer)
+    } : void 0
+  };
+  return response;
+}
+
+// src/issuer-spark-wallet.ts
+var BURN_ADDRESS = "02".repeat(33);
+var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk.SparkWallet {
+  issuerTokenTransactionService;
+  tokenFreezeService;
+  tokenPublicKeyInfo;
+  static async initialize(options) {
+    const wallet = new _IssuerSparkWallet(options.options);
+    const initResponse = await wallet.initIssuerWallet(options.mnemonicOrSeed);
+    return {
+      wallet,
+      ...initResponse
+    };
+  }
+  constructor(configOptions) {
+    super(configOptions);
+    this.issuerTokenTransactionService = new IssuerTokenTransactionService(
+      this.config,
+      this.connectionManager
+    );
+    this.tokenFreezeService = new TokenFreezeService(
+      this.config,
+      this.connectionManager
+    );
+  }
+  async initIssuerWallet(mnemonicOrSeed) {
+    const initResponse = await super.initWallet(mnemonicOrSeed);
+    mnemonicOrSeed = mnemonicOrSeed || initResponse?.mnemonic;
+    if (mnemonicOrSeed) {
+      let seed;
+      if (typeof mnemonicOrSeed !== "string") {
+        seed = mnemonicOrSeed;
+      } else {
+        if ((0, import_bip39.validateMnemonic)(mnemonicOrSeed, import_english.wordlist)) {
+          seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
+        } else {
+          seed = (0, import_utils6.hexToBytes)(mnemonicOrSeed);
+        }
+      }
+      const hdkey = (0, import_utils5.getMasterHDKeyFromSeed)(seed);
+      const accountType = this.config.getNetwork() === import_utils5.Network.REGTEST ? 0 : 1;
+      const identityKey = hdkey.derive(`m/8797555'/${accountType}'/0'`);
+      const network = this.config.getNetwork();
+      this.lrc20Wallet = new import_lrc20_sdk2.LRCWallet(
+        (0, import_utils6.bytesToHex)(identityKey.privateKey),
+        import_utils5.LRC_WALLET_NETWORK[network],
+        import_utils5.LRC_WALLET_NETWORK_TYPE[network]
+      );
+    }
+    return initResponse;
+  }
+  async getIssuerTokenBalance() {
+    const publicKey = await super.getIdentityPublicKey();
+    const balanceObj = await this.getBalance();
+    if (!balanceObj.tokenBalances || !balanceObj.tokenBalances.has(publicKey)) {
+      return {
+        balance: 0n
+      };
+    }
+    return {
+      balance: balanceObj.tokenBalances.get(publicKey).balance
+    };
+  }
+  async getIssuerTokenInfo() {
+    if (this.tokenPublicKeyInfo) {
+      return convertToTokenPubKeyInfoResponse(this.tokenPublicKeyInfo);
+    }
+    const tokenPublicKey = (0, import_utils6.bytesToHex)(this.lrc20Wallet.pubkey);
+    const rawTokenPubkeyInfo = await this.lrc20Wallet.getTokenPubkeyInfo(tokenPublicKey);
+    this.tokenPublicKeyInfo = rawTokenPubkeyInfo;
+    if (!rawTokenPubkeyInfo) {
+      return null;
+    }
+    return convertToTokenPubKeyInfoResponse(rawTokenPubkeyInfo);
+  }
+  async getIssuerTokenPublicKey() {
+    return await super.getIdentityPublicKey();
+  }
+  async mintTokens(tokenAmount) {
+    var tokenPublicKey = await super.getIdentityPublicKey();
+    const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
+      (0, import_utils6.hexToBytes)(tokenPublicKey),
+      tokenAmount
+    );
+    return await this.issuerTokenTransactionService.broadcastTokenTransaction(
+      tokenTransaction
+    );
+  }
+  async burnTokens(tokenAmount, selectedLeaves) {
+    return await this.transferTokens({
+      tokenPublicKey: await super.getIdentityPublicKey(),
+      tokenAmount,
+      receiverSparkAddress: BURN_ADDRESS,
+      selectedLeaves
+    });
+  }
+  async freezeTokens(ownerPublicKey) {
+    await this.syncTokenLeaves();
+    const tokenPublicKey = await super.getIdentityPublicKey();
+    const response = await this.tokenFreezeService.freezeTokens(
+      (0, import_utils6.hexToBytes)(ownerPublicKey),
+      (0, import_utils6.hexToBytes)(tokenPublicKey)
+    );
+    const tokenAmount = (0, import_utils6.bytesToNumberBE)(response.impactedTokenAmount);
+    return {
+      impactedLeafIds: response.impactedLeafIds,
+      impactedTokenAmount: tokenAmount
+    };
+  }
+  async unfreezeTokens(ownerPublicKey) {
+    await this.syncTokenLeaves();
+    const tokenPublicKey = await super.getIdentityPublicKey();
+    const response = await this.tokenFreezeService.unfreezeTokens(
+      (0, import_utils6.hexToBytes)(ownerPublicKey),
+      (0, import_utils6.hexToBytes)(tokenPublicKey)
+    );
+    const tokenAmount = (0, import_utils6.bytesToNumberBE)(response.impactedTokenAmount);
+    return {
+      impactedLeafIds: response.impactedLeafIds,
+      impactedTokenAmount: tokenAmount
+    };
+  }
+  async getTokenActivity(pageSize = 100, cursor, operationTypes, beforeTimestamp, afterTimestamp) {
+    const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
+    const transactions = await lrc20Client.listTransactions({
+      tokenPublicKey: (0, import_utils6.hexToBytes)(await super.getIdentityPublicKey()),
+      cursor,
+      pageSize,
+      beforeTimestamp,
+      afterTimestamp,
+      operationTypes
+    });
+    return convertTokenActivityToHexEncoded(transactions);
+  }
+  async getIssuerTokenActivity(pageSize = 100, cursor, operationTypes, beforeTimestamp, afterTimestamp) {
+    const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
+    const transactions = await lrc20Client.listTransactions({
+      tokenPublicKey: (0, import_utils6.hexToBytes)(await super.getIdentityPublicKey()),
+      ownerPublicKey: (0, import_utils6.hexToBytes)(await super.getIdentityPublicKey()),
+      cursor,
+      pageSize,
+      beforeTimestamp,
+      afterTimestamp,
+      operationTypes
+    });
+    return convertTokenActivityToHexEncoded(transactions);
+  }
+  async announceTokenL1({
+    tokenName,
+    tokenTicker,
+    decimals,
+    maxSupply,
+    isFreezable,
+    feeRateSatsPerVb = 2
+  }) {
+    await this.lrc20Wallet.syncWallet();
+    const tokenPublicKey = new import_lrc20_sdk2.TokenPubkey(this.lrc20Wallet.pubkey);
+    const announcement = new import_lrc20_sdk2.TokenPubkeyAnnouncement(
+      tokenPublicKey,
+      tokenName,
+      tokenTicker,
+      decimals,
+      maxSupply,
+      isFreezable
+    );
+    const tx = await this.lrc20Wallet.prepareAnnouncement(
+      announcement,
+      feeRateSatsPerVb
+    );
+    return await this.lrc20Wallet.broadcastRawBtcTransaction(
+      tx.bitcoin_tx.toHex()
+    );
+  }
+  mintTokensL1(tokenAmount) {
+    throw new Error("Not implemented");
+  }
+  transferTokensL1(tokenAmount, p2trAddress) {
+    throw new Error("Not implemented");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IssuerSparkWallet
+});

package/dist/index.d.cts

@@ -0,0 +1,110 @@
+import { CreateLightningInvoiceParams, PayLightningInvoiceParams, TokenInfo, SparkWallet, SparkWalletProps } from '@buildonspark/spark-sdk';
+import { QueryAllTransfersResponse, Transfer, LeafWithPreviousTransactionData, TokenTransactionWithStatus } from '@buildonspark/spark-sdk/proto/spark';
+import { ListAllTokenTransactionsCursor, OperationType } from '@buildonspark/lrc20-sdk/proto/rpc/v1/types';
+import { LRCWallet } from '@buildonspark/lrc20-sdk';
+import { LightningReceiveRequest } from '@buildonspark/spark-sdk/types';
+import { GetTokenActivityResponse, TokenPubKeyInfoResponse } from './types.cjs';
+
+/**
+ * Interface for the IssuerSparkWallet that includes all functions from both SparkWallet and IssuerSparkWallet
+ */
+interface IssuerWalletInterface {
+    getIdentityPublicKey(): Promise<string>;
+    getSparkAddress(): Promise<string>;
+    getTransfers(limit?: number, offset?: number): Promise<QueryAllTransfersResponse>;
+    getBalance(forceRefetch?: boolean): Promise<{
+        balance: bigint;
+        tokenBalances: Map<string, {
+            balance: bigint;
+        }>;
+    }>;
+    getDepositAddress(): Promise<string>;
+    transfer(params: {
+        receiverSparkAddress: string;
+        amountSats: number;
+    }): Promise<Transfer | string>;
+    createLightningInvoice(params: CreateLightningInvoiceParams): Promise<LightningReceiveRequest>;
+    payLightningInvoice(params: PayLightningInvoiceParams): Promise<any>;
+    withdraw(params: {
+        onchainAddress: string;
+        amountSats?: number;
+    }): Promise<any>;
+    transferTokens(params: {
+        tokenPublicKey: string;
+        tokenAmount: bigint;
+        receiverSparkAddress: string;
+        selectedLeaves?: LeafWithPreviousTransactionData[];
+    }): Promise<string>;
+    getIssuerTokenPublicKey(): Promise<string>;
+    getIssuerTokenBalance(): Promise<{
+        balance: bigint;
+    }>;
+    mintTokens(tokenAmount: bigint): Promise<string>;
+    getTokenActivity(pageSize: number, cursor?: ListAllTokenTransactionsCursor, operationTypes?: OperationType[], beforeTimestamp?: Date): Promise<GetTokenActivityResponse>;
+    getIssuerTokenActivity(pageSize: number, cursor?: ListAllTokenTransactionsCursor, operationTypes?: OperationType[], beforeTimestamp?: Date, afterTimestamp?: Date): Promise<GetTokenActivityResponse>;
+    getTokenTransactions(tokenPublicKeys: string[], tokenTransactionHashes?: string[]): Promise<TokenTransactionWithStatus[]>;
+    getTokenInfo(): Promise<TokenInfo[]>;
+    getIssuerTokenInfo(): Promise<TokenPubKeyInfoResponse | null>;
+    burnTokens(tokenAmount: bigint, selectedLeaves?: LeafWithPreviousTransactionData[]): Promise<string>;
+    freezeTokens(ownerPublicKey: string): Promise<{
+        impactedLeafIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    unfreezeTokens(ownerPublicKey: string): Promise<{
+        impactedLeafIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    getTokenL1Address(): Promise<string>;
+    announceTokenL1(params: {
+        lrc20Wallet: LRCWallet;
+        tokenName: string;
+        tokenTicker: string;
+        decimals: number;
+        maxSupply: bigint;
+        isFreezable: boolean;
+        feeRateSatsPerVb?: number;
+    }): Promise<string>;
+    mintTokensL1(tokenAmount: bigint): Promise<string>;
+    transferTokensL1(tokenAmount: bigint, p2trAddress: string): Promise<string>;
+}
+
+declare class IssuerSparkWallet extends SparkWallet implements IssuerWalletInterface {
+    private issuerTokenTransactionService;
+    private tokenFreezeService;
+    private tokenPublicKeyInfo?;
+    static initialize(options: SparkWalletProps): Promise<{
+        mnemonic?: string | undefined;
+        wallet: IssuerSparkWallet;
+    }>;
+    private constructor();
+    private initIssuerWallet;
+    getIssuerTokenBalance(): Promise<{
+        balance: bigint;
+    }>;
+    getIssuerTokenInfo(): Promise<TokenPubKeyInfoResponse | null>;
+    getIssuerTokenPublicKey(): Promise<string>;
+    mintTokens(tokenAmount: bigint): Promise<string>;
+    burnTokens(tokenAmount: bigint, selectedLeaves?: LeafWithPreviousTransactionData[]): Promise<string>;
+    freezeTokens(ownerPublicKey: string): Promise<{
+        impactedLeafIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    unfreezeTokens(ownerPublicKey: string): Promise<{
+        impactedLeafIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    getTokenActivity(pageSize?: number, cursor?: ListAllTokenTransactionsCursor, operationTypes?: OperationType[], beforeTimestamp?: Date, afterTimestamp?: Date): Promise<GetTokenActivityResponse>;
+    getIssuerTokenActivity(pageSize?: number, cursor?: ListAllTokenTransactionsCursor, operationTypes?: OperationType[], beforeTimestamp?: Date, afterTimestamp?: Date): Promise<GetTokenActivityResponse>;
+    announceTokenL1({ tokenName, tokenTicker, decimals, maxSupply, isFreezable, feeRateSatsPerVb, }: {
+        tokenName: any;
+        tokenTicker: any;
+        decimals: any;
+        maxSupply: any;
+        isFreezable: any;
+        feeRateSatsPerVb?: number | undefined;
+    }): Promise<string>;
+    mintTokensL1(tokenAmount: bigint): Promise<string>;
+    transferTokensL1(tokenAmount: bigint, p2trAddress: string): Promise<string>;
+}
+
+export { IssuerSparkWallet };