@buildonspark/issuer-sdk 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @buildonspark/issuer-sdk
 
+## 0.1.7
+
+### Patch Changes
+
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.5.7
+
 ## 0.1.6
 
 ### Patch Changes

package/dist/index.browser.d.ts

@@ -1,7 +1,7 @@
-import { Bech32mTokenIdentifier, SparkWallet, ConfigOptions, SparkSigner, WalletConfigService, ConnectionManager } from '@buildonspark/spark-sdk';
-export { AggregateFrostParams, ConfigOptions, DefaultSparkSigner, DerivedHDKey, DummyTx, IKeyPackage, KeyDerivation, KeyDerivationType, KeyPair, SignFrostParams, SigningCommitment, SigningCommitmentWithOptionalNonce, SigningNonce, SparkSigner, SplitSecretWithProofsParams, SubtractSplitAndEncryptParams, SubtractSplitAndEncryptResult, UnsafeStatelessSparkSigner, WalletConfig, WalletConfigService } from '@buildonspark/spark-sdk';
-import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto/spark_token';
+import { AggregateFrostParams, Bech32mTokenIdentifier, ConfigOptions, ConfigOptions as ConfigOptions$1, ConnectionManager, DefaultSparkSigner, DerivedHDKey, DummyTx, IKeyPackage, KeyDerivation, KeyDerivationType, KeyPair, SignFrostParams, SigningCommitment, SigningCommitmentWithOptionalNonce, SigningNonce, SparkSigner, SparkSigner as SparkSigner$1, SparkWallet, SplitSecretWithProofsParams, SubtractSplitAndEncryptParams, SubtractSplitAndEncryptResult, UnsafeStatelessSparkSigner, WalletConfig, WalletConfigService, WalletConfigService as WalletConfigService$1 } from "@buildonspark/spark-sdk";
+import { OutputWithPreviousTransactionData } from "@buildonspark/spark-sdk/proto/spark_token";
 
+//#region src/issuer-wallet/types.d.ts
 /**
  * Token metadata containing essential information about issuer's token.
  * This is the wallet's internal representation with JavaScript-friendly types.
@@ -24,31 +24,22 @@ import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto
  * ```
  */
 type IssuerTokenMetadata = {
-    /** Raw binary token identifier - This is used to encode the human readable token identifier */
-    rawTokenIdentifier: Uint8Array;
-    /** Public key of the token issuer - Same as issuerPublicKey */
-    tokenPublicKey: string;
-    /** Human-readable name of the token (e.g., SparkToken)*/
-    tokenName: string;
-    /** Short ticker symbol for the token (e.g., "SPK") */
-    tokenTicker: string;
-    /** Number of decimal places for token amounts */
-    decimals: number;
-    /** Maximum supply of tokens that can ever be minted */
-    maxSupply: bigint;
-    /** Whether the token is freezable */
-    isFreezable: boolean;
-    /** Extra metadata of the token */
-    extraMetadata?: Uint8Array;
-    /** Bech32m encoded token identifier */
-    bech32mTokenIdentifier: Bech32mTokenIdentifier;
+  /** Raw binary token identifier - This is used to encode the human readable token identifier */rawTokenIdentifier: Uint8Array; /** Public key of the token issuer - Same as issuerPublicKey */
+  tokenPublicKey: string; /** Human-readable name of the token (e.g., SparkToken)*/
+  tokenName: string; /** Short ticker symbol for the token (e.g., "SPK") */
+  tokenTicker: string; /** Number of decimal places for token amounts */
+  decimals: number; /** Maximum supply of tokens that can ever be minted */
+  maxSupply: bigint; /** Whether the token is freezable */
+  isFreezable: boolean; /** Extra metadata of the token */
+  extraMetadata?: Uint8Array; /** Bech32m encoded token identifier */
+  bech32mTokenIdentifier: Bech32mTokenIdentifier;
 };
 interface TokenDistribution {
-    totalCirculatingSupply: bigint;
-    totalIssued: bigint;
-    totalBurned: bigint;
-    numHoldingAddress: number;
-    numConfirmedTransactions: bigint;
+  totalCirculatingSupply: bigint;
+  totalIssued: bigint;
+  totalBurned: bigint;
+  numHoldingAddress: number;
+  numConfirmedTransactions: bigint;
 }
 /**
  * Details of a token creation.
@@ -65,225 +56,240 @@ interface TokenDistribution {
  * ```
  */
 interface TokenCreationDetails {
-    /** Bech32m encoded token identifier */
-    tokenIdentifier: Bech32mTokenIdentifier;
-    /** Transaction hash of the announcement */
-    transactionHash: string;
+  /** Bech32m encoded token identifier */
+  tokenIdentifier: Bech32mTokenIdentifier;
+  /** Transaction hash of the announcement */
+  transactionHash: string;
 }
-
+//#endregion
+//#region src/issuer-wallet/issuer-spark-wallet.d.ts
 /**
  * Represents a Spark wallet with minting capabilities.
  * This class extends the base SparkWallet with additional functionality for token minting,
  * burning, and freezing operations.
  */
 declare abstract class IssuerSparkWallet extends SparkWallet {
-    private issuerTokenTransactionService;
-    private tokenFreezeService;
-    protected tracerId: string;
-    /**
-     * Initializes a new IssuerSparkWallet instance.
-     * Inherits the generic static initialize from the base class.
-     */
-    constructor(configOptions?: ConfigOptions, signer?: SparkSigner);
-    /**
-     * Gets the token balance for the issuer's token.
-     * @deprecated Use getIssuerTokenBalances() instead. This method will be removed in a future version.
-     * @returns An object containing the token balance as a bigint
-     *
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     */
-    getIssuerTokenBalance(): Promise<{
-        tokenIdentifier: Bech32mTokenIdentifier | undefined;
-        balance: bigint;
-    }>;
-    /**
-     * Gets the token balances for the tokens that were issued by this user.
-     * @returns An array of objects containing the token identifier and balance
-     */
-    getIssuerTokenBalances(): Promise<{
-        tokenIdentifier: Bech32mTokenIdentifier | undefined;
-        balance: bigint;
-    }[]>;
-    /**
-     * Retrieves information about the issuer's token.
-     * @deprecated Use getIssuerTokensMetadata() instead. This method will be removed in a future version.
-     * @returns An object containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
-     * @throws {SparkRequestError} If the token metadata cannot be retrieved
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     */
-    getIssuerTokenMetadata(): Promise<IssuerTokenMetadata>;
-    /**
-     * Retrieves information about the tokens that were issued by this user.
-     * @param tokenIdentifiers - Optional array of specific token identifiers to fetch.
-     *                           If omitted, all tokens for this issuer are fetched.
-     * @returns An array of objects containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
-     * @throws {SparkRequestError} If the token metadata cannot be retrieved
-     */
-    getIssuerTokensMetadata(tokenIdentifiers?: Bech32mTokenIdentifier[]): Promise<IssuerTokenMetadata[]>;
-    /**
-     * Retrieves the bech32m encoded token identifier for the issuer's token.
-     * @deprecated Use getIssuerTokenIdentifiers() instead. This method will be removed in a future version.
-     * @returns The bech32m encoded token identifier for the issuer's token
-     * @throws {SparkRequestError} If the token identifier cannot be retrieved
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     */
-    getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier>;
-    /**
-     * Retrieves the bech32m encoded token identifier for the issuer's token.
-     * @returns The bech32m encoded token identifier for the issuer's token
-     * @throws {SparkRequestError} If the token identifier cannot be retrieved
-     */
-    getIssuerTokenIdentifiers(): Promise<Bech32mTokenIdentifier[]>;
-    /**
-     * Create a new token on Spark.
-     *
-     * @param params - Object containing token creation parameters.
-     * @param params.tokenName - The name of the token.
-     * @param params.tokenTicker - The ticker symbol for the token.
-     * @param params.decimals - The number of decimal places for the token.
-     * @param params.isFreezable - Whether the token can be frozen.
-     * @param [params.maxSupply=0n] - (Optional) The maximum supply of the token. Defaults to <code>0n</code>.
-     * @param params.extraMetadata - (Optional) This can be used to store additional bytes data to be associated with a token, like image data.
-     * @param params.returnIdentifierForCreate - (Optional) Whether to return the token identifier in addition to the transaction hash. Defaults to <code>false</code>.
-     * @returns The transaction hash of the announcement or TokenCreationDetails if `returnIdentifierForCreate` is true.
-     * @throws {SparkValidationError} If `decimals` is not a safe integer or other validation fails.
-     * @throws {SparkRequestError} If the announcement transaction cannot be broadcast.
-     */
-    createToken(params: {
-        tokenName: string;
-        tokenTicker: string;
-        decimals: number;
-        isFreezable: boolean;
-        maxSupply?: bigint;
-        extraMetadata?: Uint8Array;
-        returnIdentifierForCreate?: false;
-    }): Promise<string>;
-    createToken(params: {
-        tokenName: string;
-        tokenTicker: string;
-        decimals: number;
-        isFreezable: boolean;
-        maxSupply?: bigint;
-        extraMetadata?: Uint8Array;
-        returnIdentifierForCreate: true;
-    }): Promise<TokenCreationDetails>;
-    /**
-     * @deprecated Use mintTokens({ tokenAmount, tokenIdentifier }) instead. This method will be removed in a future version.
-     * @param amount - The amount of tokens to mint
-     * @returns The transaction ID of the mint operation
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     * @throws {SparkValidationError} If no tokens are found for this issuer
-     */
-    mintTokens(amount: bigint): Promise<string>;
-    /**
-     * Mints new tokens
-     * @param params - Object containing token minting parameters.
-     * @param params.tokenAmount - The amount of tokens to mint
-     * @param params.tokenIdentifier - The bech32m encoded token identifier
-     * @returns The transaction ID of the mint operation
-     * @throws {SparkValidationError} If no tokens are found for this issuer
-     */
-    mintTokens({ tokenAmount, tokenIdentifier, }: {
-        tokenAmount: bigint;
-        tokenIdentifier: Bech32mTokenIdentifier;
-    }): Promise<string>;
-    /**
-     * Burns issuer's tokens
-     * @deprecated Use burnTokens({ tokenAmount, tokenIdentifier, selectedOutputs }) instead. This method will be removed in a future version.
-     * @param tokenAmount - The amount of tokens to burn
-     * @param selectedOutputs - Optional array of outputs to use for the burn operation
-     * @returns The transaction ID of the burn operation
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     * @throws {SparkValidationError} If no tokens are found for this issuer
-     */
-    burnTokens(tokenAmount: bigint, selectedOutputs?: OutputWithPreviousTransactionData[]): Promise<string>;
-    /**
-     * Burns issuer's tokens
-     * @param params - Object containing token burning parameters.
-     * @param params.tokenAmount - The amount of tokens to burn
-     * @param params.tokenIdentifier - The bech32m encoded token identifier
-     * @param params.selectedOutputs - Optional array of outputs to use for the burn operation
-     * @returns The transaction ID of the burn operation
-     */
-    burnTokens({ tokenAmount, tokenIdentifier, selectedOutputs, }: {
-        tokenAmount: bigint;
-        tokenIdentifier: Bech32mTokenIdentifier;
-        selectedOutputs?: OutputWithPreviousTransactionData[];
-    }): Promise<string>;
-    /**
-     * Freezes tokens associated with a specific Spark address.
-     * @deprecated Use freezeToken({ tokenIdentifier, sparkAddress }) instead. This method will be removed in a future version.
-     * @param sparkAddress - The Spark address whose tokens should be frozen
-     * @returns An object containing the IDs of impacted outputs and the total amount of frozen tokens
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     * @throws {SparkValidationError} If no tokens are found for this issuer
-     */
-    freezeTokens(sparkAddress: string): Promise<{
-        impactedOutputIds: string[];
-        impactedTokenAmount: bigint;
-    }>;
-    /**
-     * Freezes tokens associated with a specific Spark address.
-     * @param params - Object containing token freezing parameters.
-     * @param params.tokenIdentifier - The bech32m encoded token identifier
-     * @param params.sparkAddress - The Spark address whose tokens should be frozen
-     * @returns An object containing the IDs of impacted outputs and the total amount of frozen tokens
-     */
-    freezeTokens({ tokenIdentifier, sparkAddress, }: {
-        tokenIdentifier: Bech32mTokenIdentifier;
-        sparkAddress: string;
-    }): Promise<{
-        impactedOutputIds: string[];
-        impactedTokenAmount: bigint;
-    }>;
-    /**
-     * Unfreezes previously frozen tokens associated with a specific Spark address.
-     * @deprecated Use unfreezeToken({ tokenIdentifier, sparkAddress }) instead. This method will be removed in a future version.
-     * @param sparkAddress - The Spark address whose tokens should be unfrozen
-     * @returns An object containing the IDs of impacted outputs and the total amount of unfrozen tokens
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     * @throws {SparkValidationError} If no tokens are found for this issuer
-     */
-    unfreezeTokens(sparkAddress: string): Promise<{
-        impactedOutputIds: string[];
-        impactedTokenAmount: bigint;
-    }>;
-    /**
-     * Unfreezes previously frozen tokens associated with a specific Spark address.
-     * @param params - Object containing token unfreezing parameters.
-     * @param params.tokenIdentifier - The bech32m encoded token identifier
-     * @param params.sparkAddress - The Spark address whose tokens should be unfrozen
-     * @returns An object containing the IDs of impacted outputs and the total amount of unfrozen tokens
-     * @throws {SparkValidationError} If multiple tokens are found for this issuer
-     * @throws {SparkValidationError} If no tokens are found for this issuer
-     */
-    unfreezeTokens({ tokenIdentifier, sparkAddress, }: {
-        tokenIdentifier: Bech32mTokenIdentifier;
-        sparkAddress: string;
-    }): Promise<{
-        impactedOutputIds: string[];
-        impactedTokenAmount: bigint;
-    }>;
-    /**
-     * Retrieves the distribution information for the issuer's token.
-     * @throws {SparkError} This feature is not yet supported
-     */
-    getIssuerTokenDistribution(): Promise<TokenDistribution>;
-    /**
-     * This validates that the token belongs to this issuer.
-     * If a token is in the cache, it must belong to this issuer.
-     * @param tokenIdentifier - The bech32m encoded token identifier
-     * @throws {SparkValidationError} If the token is not found for this issuer
-     * @private
-     */
-    private validateTokenIssuer;
-    protected getTraceName(methodName: string): string;
-    private wrapIssuerPublicMethod;
-    private wrapIssuerSparkWalletMethods;
+  private issuerTokenTransactionService;
+  private tokenFreezeService;
+  protected tracerId: string;
+  /**
+       * Initializes a new IssuerSparkWallet instance.
+       * Inherits the generic static initialize from the base class.
+       */
+  constructor(configOptions?: ConfigOptions$1, signer?: SparkSigner$1);
+  /**
+       * Gets the token balance for the issuer's token.
+       * @deprecated Use getIssuerTokenBalances() instead. This method will be removed in a future version.
+       * @returns An object containing the token balance as a bigint
+       *
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       */
+  getIssuerTokenBalance(): Promise<{
+    tokenIdentifier: Bech32mTokenIdentifier | undefined;
+    balance: bigint;
+  }>;
+  /**
+       * Gets the token balances for the tokens that were issued by this user.
+       * @returns An array of objects containing the token identifier and balance
+       */
+  getIssuerTokenBalances(): Promise<{
+    tokenIdentifier: Bech32mTokenIdentifier | undefined;
+    balance: bigint;
+  }[]>;
+  /**
+       * Retrieves information about the issuer's token.
+       * @deprecated Use getIssuerTokensMetadata() instead. This method will be removed in a future version.
+       * @returns An object containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
+       * @throws {SparkRequestError} If the token metadata cannot be retrieved
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       */
+  getIssuerTokenMetadata(): Promise<IssuerTokenMetadata>;
+  /**
+       * Retrieves information about the tokens that were issued by this user.
+       * @param tokenIdentifiers - Optional array of specific token identifiers to fetch.
+       *                           If omitted, all tokens for this issuer are fetched.
+       * @returns An array of objects containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
+       * @throws {SparkRequestError} If the token metadata cannot be retrieved
+       */
+  getIssuerTokensMetadata(tokenIdentifiers?: Bech32mTokenIdentifier[]): Promise<IssuerTokenMetadata[]>;
+  /**
+       * Retrieves the bech32m encoded token identifier for the issuer's token.
+       * @deprecated Use getIssuerTokenIdentifiers() instead. This method will be removed in a future version.
+       * @returns The bech32m encoded token identifier for the issuer's token
+       * @throws {SparkRequestError} If the token identifier cannot be retrieved
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       */
+  getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier>;
+  /**
+       * Retrieves the bech32m encoded token identifier for the issuer's token.
+       * @returns The bech32m encoded token identifier for the issuer's token
+       * @throws {SparkRequestError} If the token identifier cannot be retrieved
+       */
+  getIssuerTokenIdentifiers(): Promise<Bech32mTokenIdentifier[]>;
+  /**
+       * Create a new token on Spark.
+       *
+       * @param params - Object containing token creation parameters.
+       * @param params.tokenName - The name of the token.
+       * @param params.tokenTicker - The ticker symbol for the token.
+       * @param params.decimals - The number of decimal places for the token.
+       * @param params.isFreezable - Whether the token can be frozen.
+       * @param [params.maxSupply=0n] - (Optional) The maximum supply of the token. Defaults to <code>0n</code>.
+       * @param params.extraMetadata - (Optional) This can be used to store additional bytes data to be associated with a token, like image data.
+       * @param params.returnIdentifierForCreate - (Optional) Whether to return the token identifier in addition to the transaction hash. Defaults to <code>false</code>.
+       * @returns The transaction hash of the announcement or TokenCreationDetails if `returnIdentifierForCreate` is true.
+       * @throws {SparkValidationError} If `decimals` is not a safe integer or other validation fails.
+       * @throws {SparkRequestError} If the announcement transaction cannot be broadcast.
+       */
+  createToken(params: {
+    tokenName: string;
+    tokenTicker: string;
+    decimals: number;
+    isFreezable: boolean;
+    maxSupply?: bigint;
+    extraMetadata?: Uint8Array;
+    returnIdentifierForCreate?: false;
+  }): Promise<string>;
+  createToken(params: {
+    tokenName: string;
+    tokenTicker: string;
+    decimals: number;
+    isFreezable: boolean;
+    maxSupply?: bigint;
+    extraMetadata?: Uint8Array;
+    returnIdentifierForCreate: true;
+  }): Promise<TokenCreationDetails>;
+  /**
+       * @deprecated Use mintTokens({ tokenAmount, tokenIdentifier }) instead. This method will be removed in a future version.
+       * @param amount - The amount of tokens to mint
+       * @returns The transaction ID of the mint operation
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       * @throws {SparkValidationError} If no tokens are found for this issuer
+       */
+  mintTokens(amount: bigint): Promise<string>;
+  /**
+       * Mints new tokens
+       * @param params - Object containing token minting parameters.
+       * @param params.tokenAmount - The amount of tokens to mint
+       * @param params.tokenIdentifier - The bech32m encoded token identifier
+       * @returns The transaction ID of the mint operation
+       * @throws {SparkValidationError} If no tokens are found for this issuer
+       */
+  mintTokens({
+    tokenAmount,
+    tokenIdentifier
+  }: {
+    tokenAmount: bigint;
+    tokenIdentifier: Bech32mTokenIdentifier;
+  }): Promise<string>;
+  /**
+       * Burns issuer's tokens
+       * @deprecated Use burnTokens({ tokenAmount, tokenIdentifier, selectedOutputs }) instead. This method will be removed in a future version.
+       * @param tokenAmount - The amount of tokens to burn
+       * @param selectedOutputs - Optional array of outputs to use for the burn operation
+       * @returns The transaction ID of the burn operation
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       * @throws {SparkValidationError} If no tokens are found for this issuer
+       */
+  burnTokens(tokenAmount: bigint, selectedOutputs?: OutputWithPreviousTransactionData[]): Promise<string>;
+  /**
+       * Burns issuer's tokens
+       * @param params - Object containing token burning parameters.
+       * @param params.tokenAmount - The amount of tokens to burn
+       * @param params.tokenIdentifier - The bech32m encoded token identifier
+       * @param params.selectedOutputs - Optional array of outputs to use for the burn operation
+       * @returns The transaction ID of the burn operation
+       */
+  burnTokens({
+    tokenAmount,
+    tokenIdentifier,
+    selectedOutputs
+  }: {
+    tokenAmount: bigint;
+    tokenIdentifier: Bech32mTokenIdentifier;
+    selectedOutputs?: OutputWithPreviousTransactionData[];
+  }): Promise<string>;
+  /**
+       * Freezes tokens associated with a specific Spark address.
+       * @deprecated Use freezeToken({ tokenIdentifier, sparkAddress }) instead. This method will be removed in a future version.
+       * @param sparkAddress - The Spark address whose tokens should be frozen
+       * @returns An object containing the IDs of impacted outputs and the total amount of frozen tokens
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       * @throws {SparkValidationError} If no tokens are found for this issuer
+       */
+  freezeTokens(sparkAddress: string): Promise<{
+    impactedOutputIds: string[];
+    impactedTokenAmount: bigint;
+  }>;
+  /**
+       * Freezes tokens associated with a specific Spark address.
+       * @param params - Object containing token freezing parameters.
+       * @param params.tokenIdentifier - The bech32m encoded token identifier
+       * @param params.sparkAddress - The Spark address whose tokens should be frozen
+       * @returns An object containing the IDs of impacted outputs and the total amount of frozen tokens
+       */
+  freezeTokens({
+    tokenIdentifier,
+    sparkAddress
+  }: {
+    tokenIdentifier: Bech32mTokenIdentifier;
+    sparkAddress: string;
+  }): Promise<{
+    impactedOutputIds: string[];
+    impactedTokenAmount: bigint;
+  }>;
+  /**
+       * Unfreezes previously frozen tokens associated with a specific Spark address.
+       * @deprecated Use unfreezeToken({ tokenIdentifier, sparkAddress }) instead. This method will be removed in a future version.
+       * @param sparkAddress - The Spark address whose tokens should be unfrozen
+       * @returns An object containing the IDs of impacted outputs and the total amount of unfrozen tokens
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       * @throws {SparkValidationError} If no tokens are found for this issuer
+       */
+  unfreezeTokens(sparkAddress: string): Promise<{
+    impactedOutputIds: string[];
+    impactedTokenAmount: bigint;
+  }>;
+  /**
+       * Unfreezes previously frozen tokens associated with a specific Spark address.
+       * @param params - Object containing token unfreezing parameters.
+       * @param params.tokenIdentifier - The bech32m encoded token identifier
+       * @param params.sparkAddress - The Spark address whose tokens should be unfrozen
+       * @returns An object containing the IDs of impacted outputs and the total amount of unfrozen tokens
+       * @throws {SparkValidationError} If multiple tokens are found for this issuer
+       * @throws {SparkValidationError} If no tokens are found for this issuer
+       */
+  unfreezeTokens({
+    tokenIdentifier,
+    sparkAddress
+  }: {
+    tokenIdentifier: Bech32mTokenIdentifier;
+    sparkAddress: string;
+  }): Promise<{
+    impactedOutputIds: string[];
+    impactedTokenAmount: bigint;
+  }>;
+  /**
+       * Retrieves the distribution information for the issuer's token.
+       * @throws {SparkError} This feature is not yet supported
+       */
+  getIssuerTokenDistribution(): Promise<TokenDistribution>;
+  /**
+       * This validates that the token belongs to this issuer.
+       * If a token is in the cache, it must belong to this issuer.
+       * @param tokenIdentifier - The bech32m encoded token identifier
+       * @throws {SparkValidationError} If the token is not found for this issuer
+       * @private
+       */
+  private validateTokenIssuer;
+  protected getTraceName(methodName: string): string;
+  private wrapIssuerPublicMethod;
+  private wrapIssuerSparkWalletMethods;
 }
-
+//#endregion
+//#region src/issuer-wallet/issuer-spark-wallet.browser.d.ts
 declare class IssuerSparkWalletBrowser extends IssuerSparkWallet {
-    protected buildConnectionManager(config: WalletConfigService): ConnectionManager;
+  protected buildConnectionManager(config: WalletConfigService$1): ConnectionManager;
 }
-
-export { IssuerSparkWalletBrowser as IssuerSparkWallet, type IssuerTokenMetadata, type TokenCreationDetails, type TokenDistribution };
+//#endregion
+export { type AggregateFrostParams, type ConfigOptions, DefaultSparkSigner, type DerivedHDKey, type DummyTx, type IKeyPackage, IssuerSparkWalletBrowser as IssuerSparkWallet, IssuerTokenMetadata, type KeyDerivation, type KeyDerivationType, type KeyPair, type SignFrostParams, type SigningCommitment, type SigningCommitmentWithOptionalNonce, type SigningNonce, type SparkSigner, type SplitSecretWithProofsParams, type SubtractSplitAndEncryptParams, type SubtractSplitAndEncryptResult, TokenCreationDetails, TokenDistribution, UnsafeStatelessSparkSigner, WalletConfig, type WalletConfigService };