@buildonspark/issuer-sdk 0.0.22 → 0.0.23

package/dist/index.d.ts

@@ -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.js';
+
+/**
+ * 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 };

package/dist/index.js

@@ -0,0 +1,497 @@
+import "./chunk-GB7N6I5O.js";
+
+// src/issuer-spark-wallet.ts
+import {
+  LRCWallet,
+  TokenPubkey,
+  TokenPubkeyAnnouncement
+} from "@buildonspark/lrc20-sdk";
+import { SparkWallet } from "@buildonspark/spark-sdk";
+import {
+  getMasterHDKeyFromSeed,
+  LRC_WALLET_NETWORK,
+  LRC_WALLET_NETWORK_TYPE,
+  Network
+} from "@buildonspark/spark-sdk/utils";
+import {
+  bytesToHex as bytesToHex2,
+  bytesToNumberBE as bytesToNumberBE2,
+  hexToBytes
+} from "@noble/curves/abstract/utils";
+import { validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+
+// src/services/freeze.ts
+import { validateResponses } from "@buildonspark/spark-sdk/utils";
+
+// src/utils/token-hashing.ts
+import { sha256 } from "@scure/btc-signer/utils";
+function hashFreezeTokensPayload(payload) {
+  if (!payload) {
+    throw new Error("freeze tokens payload cannot be nil");
+  }
+  let allHashes = [];
+  const ownerPubKeyHash = sha256.create();
+  if (payload.ownerPublicKey) {
+    ownerPubKeyHash.update(payload.ownerPublicKey);
+  }
+  allHashes.push(ownerPubKeyHash.digest());
+  const tokenPubKeyHash = sha256.create();
+  if (payload.tokenPublicKey) {
+    tokenPubKeyHash.update(payload.tokenPublicKey);
+  }
+  allHashes.push(tokenPubKeyHash.digest());
+  const shouldUnfreezeHash = sha256.create();
+  shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
+  allHashes.push(shouldUnfreezeHash.digest());
+  const timestampHash = 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 = sha256.create();
+  if (payload.operatorIdentityPublicKey) {
+    operatorPubKeyHash.update(payload.operatorIdentityPublicKey);
+  }
+  allHashes.push(operatorPubKeyHash.digest());
+  const finalHash = 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 = validateResponses(freezeResponses);
+    return successfulResponses[0].response;
+  }
+};
+
+// src/services/token-transactions.ts
+import { TokenTransactionService } from "@buildonspark/spark-sdk/token-transactions";
+import { numberToBytesBE } from "@noble/curves/abstract/utils";
+var IssuerTokenTransactionService = class extends 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: numberToBytesBE(tokenAmount, 16)
+        }
+      ],
+      sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys()
+    };
+  }
+};
+
+// src/utils/type-mappers.ts
+import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
+
+// src/utils/enum-mappers.ts
+import { Lrc20Protos } from "@buildonspark/lrc20-sdk";
+function mapOperationType(type) {
+  switch (type) {
+    case Lrc20Protos.OperationType.USER_TRANSFER:
+      return "USER_TRANSFER" /* USER_TRANSFER */;
+    case Lrc20Protos.OperationType.USER_BURN:
+      return "USER_BURN" /* USER_BURN */;
+    case Lrc20Protos.OperationType.ISSUER_ANNOUNCE:
+      return "ISSUER_ANNOUNCE" /* ISSUER_ANNOUNCE */;
+    case Lrc20Protos.OperationType.ISSUER_MINT:
+      return "ISSUER_MINT" /* ISSUER_MINT */;
+    case Lrc20Protos.OperationType.ISSUER_TRANSFER:
+      return "ISSUER_TRANSFER" /* ISSUER_TRANSFER */;
+    case Lrc20Protos.OperationType.ISSUER_FREEZE:
+      return "ISSUER_FREEZE" /* ISSUER_FREEZE */;
+    case Lrc20Protos.OperationType.ISSUER_UNFREEZE:
+      return "ISSUER_UNFREEZE" /* ISSUER_UNFREEZE */;
+    case Lrc20Protos.OperationType.ISSUER_BURN:
+      return "ISSUER_BURN" /* ISSUER_BURN */;
+    default:
+      return "USER_TRANSFER" /* USER_TRANSFER */;
+  }
+}
+function mapOnChainTransactionStatus(status) {
+  switch (status) {
+    case Lrc20Protos.OnChainTransactionStatus.PENDING:
+      return "PENDING" /* PENDING */;
+    case Lrc20Protos.OnChainTransactionStatus.CONFIRMED:
+      return "CONFIRMED" /* CONFIRMED */;
+    case Lrc20Protos.OnChainTransactionStatus.WAITING_MINED:
+      return "WAITING_MINED" /* WAITING_MINED */;
+    case Lrc20Protos.OnChainTransactionStatus.MINED:
+      return "MINED" /* MINED */;
+    case Lrc20Protos.OnChainTransactionStatus.ATTACHING:
+      return "ATTACHING" /* ATTACHING */;
+    case Lrc20Protos.OnChainTransactionStatus.ATTACHED:
+      return "ATTACHED" /* ATTACHED */;
+    default:
+      return "PENDING" /* PENDING */;
+  }
+}
+function mapSparkTransactionStatus(status) {
+  switch (status) {
+    case Lrc20Protos.SparkTransactionStatus.STARTED:
+      return "STARTED" /* STARTED */;
+    case Lrc20Protos.SparkTransactionStatus.SIGNED:
+      return "SIGNED" /* SIGNED */;
+    case 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: 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: bytesToHex(onChain.transactionHash),
+              rawtx: bytesToHex(onChain.rawtx),
+              status: mapOnChainTransactionStatus(onChain.status),
+              inputs: onChain.inputs.map((input) => ({
+                rawTx: bytesToHex(input.rawTx),
+                vout: input.vout,
+                amountSats: input.amountSats,
+                tokenPublicKey: input.tokenPublicKey,
+                tokenAmount: input.tokenAmount ? bytesToNumberBE(input.tokenAmount).toString() : void 0
+              })),
+              outputs: onChain.outputs.map((output) => ({
+                rawTx: bytesToHex(output.rawTx),
+                vout: output.vout,
+                amountSats: output.amountSats,
+                tokenPublicKey: output.tokenPublicKey,
+                tokenAmount: output.tokenAmount ? 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: bytesToHex(spark.transactionHash),
+              status: mapSparkTransactionStatus(spark.status),
+              confirmedAt: spark.confirmedAt,
+              leavesToCreate: spark.leavesToCreate.map((leaf) => ({
+                tokenPublicKey: bytesToHex(leaf.tokenPublicKey),
+                id: leaf.id,
+                ownerPublicKey: bytesToHex(leaf.ownerPublicKey),
+                revocationPublicKey: bytesToHex(leaf.revocationPublicKey),
+                withdrawalBondSats: leaf.withdrawalBondSats,
+                withdrawalLocktime: leaf.withdrawalLocktime,
+                tokenAmount: bytesToNumberBE(leaf.tokenAmount).toString(),
+                createTxHash: bytesToHex(leaf.createTxHash),
+                createTxVoutIndex: leaf.createTxVoutIndex,
+                spendTxHash: leaf.spendTxHash ? bytesToHex(leaf.spendTxHash) : void 0,
+                spendTxVoutIndex: leaf.spendTxVoutIndex,
+                isFrozen: leaf.isFrozen
+              })),
+              leavesToSpend: spark.leavesToSpend.map((leaf) => ({
+                tokenPublicKey: bytesToHex(leaf.tokenPublicKey),
+                id: leaf.id,
+                ownerPublicKey: bytesToHex(leaf.ownerPublicKey),
+                revocationPublicKey: bytesToHex(leaf.revocationPublicKey),
+                withdrawalBondSats: leaf.withdrawalBondSats,
+                withdrawalLocktime: leaf.withdrawalLocktime,
+                tokenAmount: bytesToNumberBE(leaf.tokenAmount).toString(),
+                createTxHash: bytesToHex(leaf.createTxHash),
+                createTxVoutIndex: leaf.createTxVoutIndex,
+                spendTxHash: leaf.spendTxHash ? bytesToHex(leaf.spendTxHash) : void 0,
+                spendTxVoutIndex: leaf.spendTxVoutIndex,
+                isFrozen: leaf.isFrozen
+              })),
+              sparkOperatorIdentityPublicKeys: spark.sparkOperatorIdentityPublicKeys.map((key) => bytesToHex(key))
+            }
+          }
+        };
+      }
+      return { transaction: void 0 };
+    }),
+    nextCursor: rawTransactions.nextCursor ? {
+      lastTransactionHash: 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 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 (validateMnemonic(mnemonicOrSeed, wordlist)) {
+          seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
+        } else {
+          seed = hexToBytes(mnemonicOrSeed);
+        }
+      }
+      const hdkey = getMasterHDKeyFromSeed(seed);
+      const accountType = this.config.getNetwork() === Network.REGTEST ? 0 : 1;
+      const identityKey = hdkey.derive(`m/8797555'/${accountType}'/0'`);
+      const network = this.config.getNetwork();
+      this.lrc20Wallet = new LRCWallet(
+        bytesToHex2(identityKey.privateKey),
+        LRC_WALLET_NETWORK[network],
+        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 = bytesToHex2(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(
+      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(
+      hexToBytes(ownerPublicKey),
+      hexToBytes(tokenPublicKey)
+    );
+    const tokenAmount = bytesToNumberBE2(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(
+      hexToBytes(ownerPublicKey),
+      hexToBytes(tokenPublicKey)
+    );
+    const tokenAmount = bytesToNumberBE2(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: 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: hexToBytes(await super.getIdentityPublicKey()),
+      ownerPublicKey: 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 TokenPubkey(this.lrc20Wallet.pubkey);
+    const announcement = new 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");
+  }
+};
+export {
+  IssuerSparkWallet
+};

package/dist/types.cjs

@@ -0,0 +1,77 @@
+"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/types.ts
+var types_exports = {};
+__export(types_exports, {
+  LayerType: () => LayerType,
+  OnChainTransactionStatus: () => OnChainTransactionStatus,
+  OperationType: () => OperationType,
+  SparkTransactionStatus: () => SparkTransactionStatus
+});
+module.exports = __toCommonJS(types_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/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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LayerType,
+  OnChainTransactionStatus,
+  OperationType,
+  SparkTransactionStatus
+});