@buildonspark/issuer-sdk 0.0.84 → 0.0.85

package/dist/index.node.d.cts

@@ -0,0 +1,14 @@
+import { I as IssuerSparkWallet } from './issuer-spark-wallet-BFzkv4X5.cjs';
+export { a as IssuerTokenMetadata, T as TokenDistribution } from './issuer-spark-wallet-BFzkv4X5.cjs';
+import { SparkWalletProps } from '@buildonspark/spark-sdk';
+import '@buildonspark/spark-sdk/proto/spark';
+
+declare class IssuerSparkWalletNodeJS extends IssuerSparkWallet {
+    static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{
+        mnemonic?: string | undefined;
+        wallet: IssuerSparkWalletNodeJS;
+    }>;
+    protected initializeTracerEnv({ spanProcessors, traceUrls, }: Parameters<IssuerSparkWallet["initializeTracerEnv"]>[0]): void;
+}
+
+export { IssuerSparkWalletNodeJS as IssuerSparkWallet };

package/dist/index.node.d.ts

@@ -0,0 +1,14 @@
+import { I as IssuerSparkWallet } from './issuer-spark-wallet-BFzkv4X5.js';
+export { a as IssuerTokenMetadata, T as TokenDistribution } from './issuer-spark-wallet-BFzkv4X5.js';
+import { SparkWalletProps } from '@buildonspark/spark-sdk';
+import '@buildonspark/spark-sdk/proto/spark';
+
+declare class IssuerSparkWalletNodeJS extends IssuerSparkWallet {
+    static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{
+        mnemonic?: string | undefined;
+        wallet: IssuerSparkWalletNodeJS;
+    }>;
+    protected initializeTracerEnv({ spanProcessors, traceUrls, }: Parameters<IssuerSparkWallet["initializeTracerEnv"]>[0]): void;
+}
+
+export { IssuerSparkWalletNodeJS as IssuerSparkWallet };

package/dist/index.node.js

@@ -0,0 +1,34 @@
+import {
+  IssuerSparkWallet
+} from "./chunk-HOLMXKFE.js";
+import "./chunk-7B4B24XF.js";
+
+// src/issuer-wallet/issuer-spark-wallet.node.ts
+import {
+  initializeTracerEnv as initializeTracerEnvNodeJS
+} from "@buildonspark/spark-sdk";
+var IssuerSparkWalletNodeJS = class _IssuerSparkWalletNodeJS extends IssuerSparkWallet {
+  static async initialize({
+    mnemonicOrSeed,
+    accountNumber,
+    signer,
+    options
+  }) {
+    const wallet = new _IssuerSparkWalletNodeJS(options, signer);
+    wallet.initializeTracer(wallet);
+    const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
+    return {
+      wallet,
+      ...initResponse
+    };
+  }
+  initializeTracerEnv({
+    spanProcessors,
+    traceUrls
+  }) {
+    initializeTracerEnvNodeJS({ spanProcessors, traceUrls });
+  }
+};
+export {
+  IssuerSparkWalletNodeJS as IssuerSparkWallet
+};

package/dist/issuer-spark-wallet-BFzkv4X5.d.cts

@@ -0,0 +1,164 @@
+import { SparkWallet, SparkWalletProps, ConfigOptions, SparkSigner, Bech32mTokenIdentifier } from '@buildonspark/spark-sdk';
+import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto/spark';
+
+/**
+ * Token metadata containing essential information about issuer's token.
+ * This is the wallet's internal representation with JavaScript-friendly types.
+ *
+ * rawTokenIdentifier: This is the raw binary token identifier - This is used to encode the human readable token identifier.
+ *
+ * tokenPublicKey: This is the hex-encoded public key of the token issuer - Same as issuerPublicKey.
+ *
+ * @example
+ * ```typescript
+ * const tokenMetadata: IssuerTokenMetadata = {
+ *   rawTokenIdentifier: new Uint8Array([1, 2, 3]),
+ *   tokenPublicKey: "0348fbb...",
+ *   tokenName: "SparkToken",
+ *   tokenTicker: "SPK",
+ *   decimals: 8,
+ *   maxSupply: 1000000n
+ *   isFreezable: true
+ * };
+ * ```
+ */
+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;
+};
+interface TokenDistribution {
+    totalCirculatingSupply: bigint;
+    totalIssued: bigint;
+    totalBurned: bigint;
+    numHoldingAddress: number;
+    numConfirmedTransactions: bigint;
+}
+
+/**
+ * Represents a Spark wallet with minting capabilities.
+ * This class extends the base SparkWallet with additional functionality for token minting,
+ * burning, and freezing operations.
+ */
+declare class IssuerSparkWallet extends SparkWallet {
+    private issuerTokenTransactionService;
+    private tokenFreezeService;
+    protected tracerId: string;
+    /**
+     * Initializes a new IssuerSparkWallet instance.
+     * @param options - Configuration options for the wallet
+     * @returns An object containing the initialized wallet and initialization response
+     */
+    static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{
+        mnemonic?: string | undefined;
+        wallet: IssuerSparkWallet;
+    }>;
+    protected constructor(configOptions?: ConfigOptions, signer?: SparkSigner);
+    /**
+     * Gets the token balance for the issuer's token.
+     * @returns An object containing the token balance as a bigint
+     */
+    getIssuerTokenBalance(): Promise<{
+        tokenIdentifier: Bech32mTokenIdentifier | undefined;
+        balance: bigint;
+    }>;
+    /**
+     * Retrieves information about the issuer's token.
+     * @returns An object containing token information including public key, name, symbol, decimals, max supply, and freeze status
+     * @throws {NetworkError} If the token metadata cannot be retrieved
+     */
+    getIssuerTokenMetadata(): Promise<IssuerTokenMetadata>;
+    /**
+     * Retrieves the bech32m encoded token identifier for the issuer's token.
+     * @returns The bech32m encoded token identifier for the issuer's token
+     * @throws {NetworkError} If the token identifier cannot be retrieved
+     */
+    getIssuerTokenIdentifier(): 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>.
+     *
+     * @returns The transaction ID of the announcement.
+     *
+     * @throws {ValidationError} If `decimals` is not a safe integer or other validation fails.
+     * @throws {NetworkError} If the announcement transaction cannot be broadcast.
+     */
+    createToken({ tokenName, tokenTicker, decimals, isFreezable, maxSupply, }: {
+        tokenName: string;
+        tokenTicker: string;
+        decimals: number;
+        isFreezable: boolean;
+        maxSupply?: bigint;
+    }): Promise<string>;
+    /**
+     * Mints new tokens
+     * @param tokenAmount - The amount of tokens to mint
+     * @returns The transaction ID of the mint operation
+     */
+    mintTokens(tokenAmount: bigint): Promise<string>;
+    /**
+     * Burns issuer's tokens
+     * @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
+     */
+    burnTokens(tokenAmount: bigint, selectedOutputs?: OutputWithPreviousTransactionData[]): Promise<string>;
+    /**
+     * Freezes tokens associated with a specific Spark address.
+     * @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
+     */
+    freezeTokens(sparkAddress: string): Promise<{
+        impactedOutputIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    /**
+     * Unfreezes previously frozen tokens associated with a specific Spark address.
+     * @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
+     */
+    unfreezeTokens(sparkAddress: string): Promise<{
+        impactedOutputIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    /**
+     * Retrieves the distribution information for the issuer's token.
+     * @throws {NotImplementedError} This feature is not yet supported
+     */
+    getIssuerTokenDistribution(): Promise<TokenDistribution>;
+    /**
+     * Announces a new token on the L1 (Bitcoin) network.
+     * @param tokenName - The name of the token
+     * @param tokenTicker - The ticker symbol for the token
+     * @param decimals - The number of decimal places for the token
+     * @param maxSupply - The maximum supply of the token
+     * @param isFreezable - Whether the token can be frozen
+     * @param feeRateSatsPerVb - The fee rate in satoshis per virtual byte (default: 4.0)
+     * @returns The transaction ID of the announcement
+     * @throws {ValidationError} If decimals is not a safe integer
+     * @throws {NetworkError} If the announcement transaction cannot be broadcast
+     */
+    announceTokenL1(tokenName: string, tokenTicker: string, decimals: number, maxSupply: bigint, isFreezable: boolean, feeRateSatsPerVb?: number): Promise<string>;
+    protected getTraceName(methodName: string): string;
+    private wrapPublicIssuerSparkWalletMethodWithOtelSpan;
+    private wrapIssuerSparkWalletMethodsWithTracing;
+}
+
+export { IssuerSparkWallet as I, type TokenDistribution as T, type IssuerTokenMetadata as a };

package/dist/issuer-spark-wallet-BFzkv4X5.d.ts

@@ -0,0 +1,164 @@
+import { SparkWallet, SparkWalletProps, ConfigOptions, SparkSigner, Bech32mTokenIdentifier } from '@buildonspark/spark-sdk';
+import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto/spark';
+
+/**
+ * Token metadata containing essential information about issuer's token.
+ * This is the wallet's internal representation with JavaScript-friendly types.
+ *
+ * rawTokenIdentifier: This is the raw binary token identifier - This is used to encode the human readable token identifier.
+ *
+ * tokenPublicKey: This is the hex-encoded public key of the token issuer - Same as issuerPublicKey.
+ *
+ * @example
+ * ```typescript
+ * const tokenMetadata: IssuerTokenMetadata = {
+ *   rawTokenIdentifier: new Uint8Array([1, 2, 3]),
+ *   tokenPublicKey: "0348fbb...",
+ *   tokenName: "SparkToken",
+ *   tokenTicker: "SPK",
+ *   decimals: 8,
+ *   maxSupply: 1000000n
+ *   isFreezable: true
+ * };
+ * ```
+ */
+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;
+};
+interface TokenDistribution {
+    totalCirculatingSupply: bigint;
+    totalIssued: bigint;
+    totalBurned: bigint;
+    numHoldingAddress: number;
+    numConfirmedTransactions: bigint;
+}
+
+/**
+ * Represents a Spark wallet with minting capabilities.
+ * This class extends the base SparkWallet with additional functionality for token minting,
+ * burning, and freezing operations.
+ */
+declare class IssuerSparkWallet extends SparkWallet {
+    private issuerTokenTransactionService;
+    private tokenFreezeService;
+    protected tracerId: string;
+    /**
+     * Initializes a new IssuerSparkWallet instance.
+     * @param options - Configuration options for the wallet
+     * @returns An object containing the initialized wallet and initialization response
+     */
+    static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{
+        mnemonic?: string | undefined;
+        wallet: IssuerSparkWallet;
+    }>;
+    protected constructor(configOptions?: ConfigOptions, signer?: SparkSigner);
+    /**
+     * Gets the token balance for the issuer's token.
+     * @returns An object containing the token balance as a bigint
+     */
+    getIssuerTokenBalance(): Promise<{
+        tokenIdentifier: Bech32mTokenIdentifier | undefined;
+        balance: bigint;
+    }>;
+    /**
+     * Retrieves information about the issuer's token.
+     * @returns An object containing token information including public key, name, symbol, decimals, max supply, and freeze status
+     * @throws {NetworkError} If the token metadata cannot be retrieved
+     */
+    getIssuerTokenMetadata(): Promise<IssuerTokenMetadata>;
+    /**
+     * Retrieves the bech32m encoded token identifier for the issuer's token.
+     * @returns The bech32m encoded token identifier for the issuer's token
+     * @throws {NetworkError} If the token identifier cannot be retrieved
+     */
+    getIssuerTokenIdentifier(): 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>.
+     *
+     * @returns The transaction ID of the announcement.
+     *
+     * @throws {ValidationError} If `decimals` is not a safe integer or other validation fails.
+     * @throws {NetworkError} If the announcement transaction cannot be broadcast.
+     */
+    createToken({ tokenName, tokenTicker, decimals, isFreezable, maxSupply, }: {
+        tokenName: string;
+        tokenTicker: string;
+        decimals: number;
+        isFreezable: boolean;
+        maxSupply?: bigint;
+    }): Promise<string>;
+    /**
+     * Mints new tokens
+     * @param tokenAmount - The amount of tokens to mint
+     * @returns The transaction ID of the mint operation
+     */
+    mintTokens(tokenAmount: bigint): Promise<string>;
+    /**
+     * Burns issuer's tokens
+     * @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
+     */
+    burnTokens(tokenAmount: bigint, selectedOutputs?: OutputWithPreviousTransactionData[]): Promise<string>;
+    /**
+     * Freezes tokens associated with a specific Spark address.
+     * @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
+     */
+    freezeTokens(sparkAddress: string): Promise<{
+        impactedOutputIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    /**
+     * Unfreezes previously frozen tokens associated with a specific Spark address.
+     * @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
+     */
+    unfreezeTokens(sparkAddress: string): Promise<{
+        impactedOutputIds: string[];
+        impactedTokenAmount: bigint;
+    }>;
+    /**
+     * Retrieves the distribution information for the issuer's token.
+     * @throws {NotImplementedError} This feature is not yet supported
+     */
+    getIssuerTokenDistribution(): Promise<TokenDistribution>;
+    /**
+     * Announces a new token on the L1 (Bitcoin) network.
+     * @param tokenName - The name of the token
+     * @param tokenTicker - The ticker symbol for the token
+     * @param decimals - The number of decimal places for the token
+     * @param maxSupply - The maximum supply of the token
+     * @param isFreezable - Whether the token can be frozen
+     * @param feeRateSatsPerVb - The fee rate in satoshis per virtual byte (default: 4.0)
+     * @returns The transaction ID of the announcement
+     * @throws {ValidationError} If decimals is not a safe integer
+     * @throws {NetworkError} If the announcement transaction cannot be broadcast
+     */
+    announceTokenL1(tokenName: string, tokenTicker: string, decimals: number, maxSupply: bigint, isFreezable: boolean, feeRateSatsPerVb?: number): Promise<string>;
+    protected getTraceName(methodName: string): string;
+    private wrapPublicIssuerSparkWalletMethodWithOtelSpan;
+    private wrapIssuerSparkWalletMethodsWithTracing;
+}
+
+export { IssuerSparkWallet as I, type TokenDistribution as T, type IssuerTokenMetadata as a };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/issuer-sdk",
-  "version": "0.0.84",
+  "version": "0.0.85",
   "description": "Spark Issuer SDK for token issuance",
   "license": "Apache-2.0",
   "module": "./dist/index.js",
@@ -9,8 +9,26 @@
   "homepage": "https://github.com/buildonspark/spark",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "node": {
+          "types": "./dist/index.node.d.ts",
+          "default": "./dist/index.node.js"
+        },
+        "default": {
+          "types": "./dist/index.d.ts",
+          "default": "./dist/index.js"
+        }
+      },
+      "require": {
+        "node": {
+          "types": "./dist/index.node.d.cts",
+          "default": "./dist/index.node.cjs"
+        },
+        "default": {
+          "types": "./dist/index.d.cts",
+          "default": "./dist/index.cjs"
+        }
+      }
     },
     "./proto/spark": {
       "import": "./dist/proto/spark.js",
@@ -54,8 +72,8 @@
     "types": "tsc"
   },
   "dependencies": {
-    "@buildonspark/lrc20-sdk": "0.0.60",
-    "@buildonspark/spark-sdk": "0.2.5",
+    "@buildonspark/lrc20-sdk": "0.0.61",
+    "@buildonspark/spark-sdk": "0.2.6",
     "@lightsparkdev/core": "^1.4.2",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",

package/src/index.node.ts

@@ -0,0 +1,2 @@
+export { IssuerSparkWalletNodeJS as IssuerSparkWallet } from "./issuer-wallet/issuer-spark-wallet.node.js";
+export * from "./issuer-wallet/types.js";

package/src/index.ts

@@ -1,2 +1,2 @@
-export * from "./issuer-wallet/issuer-spark-wallet.js";
+export { IssuerSparkWalletBrowser as IssuerSparkWallet } from "./issuer-wallet/issuer-spark-wallet.browser.js";
 export * from "./issuer-wallet/types.js";

package/src/issuer-wallet/issuer-spark-wallet.browser.ts

@@ -0,0 +1,33 @@
+import { IssuerSparkWallet as BaseIssuerSparkWallet } from "./issuer-spark-wallet.js";
+import {
+  initializeTracerEnv as initializeTracerEnvBrowser,
+  type SparkWalletProps,
+} from "@buildonspark/spark-sdk";
+
+export class IssuerSparkWalletBrowser extends BaseIssuerSparkWallet {
+  public static async initialize({
+    mnemonicOrSeed,
+    accountNumber,
+    signer,
+    options,
+  }: SparkWalletProps) {
+    const wallet = new IssuerSparkWalletBrowser(options, signer);
+    wallet.initializeTracer(wallet);
+
+    const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
+
+    return {
+      wallet,
+      ...initResponse,
+    };
+  }
+
+  protected initializeTracerEnv({
+    spanProcessors,
+    traceUrls,
+  }: Parameters<BaseIssuerSparkWallet["initializeTracerEnv"]>[0]) {
+    initializeTracerEnvBrowser({ spanProcessors, traceUrls });
+  }
+}
+
+export { IssuerSparkWalletBrowser as IssuerSparkWallet };

package/src/issuer-wallet/issuer-spark-wallet.node.ts

@@ -0,0 +1,33 @@
+import { IssuerSparkWallet as BaseIssuerSparkWallet } from "./issuer-spark-wallet.js";
+import {
+  initializeTracerEnv as initializeTracerEnvNodeJS,
+  type SparkWalletProps,
+} from "@buildonspark/spark-sdk";
+
+export class IssuerSparkWalletNodeJS extends BaseIssuerSparkWallet {
+  public static async initialize({
+    mnemonicOrSeed,
+    accountNumber,
+    signer,
+    options,
+  }: SparkWalletProps) {
+    const wallet = new IssuerSparkWalletNodeJS(options, signer);
+    wallet.initializeTracer(wallet);
+
+    const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
+
+    return {
+      wallet,
+      ...initResponse,
+    };
+  }
+
+  protected initializeTracerEnv({
+    spanProcessors,
+    traceUrls,
+  }: Parameters<BaseIssuerSparkWallet["initializeTracerEnv"]>[0]) {
+    initializeTracerEnvNodeJS({ spanProcessors, traceUrls });
+  }
+}
+
+export { IssuerSparkWalletNodeJS as IssuerSparkWallet };

package/src/issuer-wallet/issuer-spark-wallet.ts

@@ -57,62 +57,16 @@ export class IssuerSparkWallet extends SparkWallet {
     options,
   }: SparkWalletProps) {
     const wallet = new IssuerSparkWallet(options, signer);
+    wallet.initializeTracer(wallet);
 
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
 
-    if (isNode) {
-      wallet.wrapIssuerSparkWalletWithTracing();
-    }
-
     return {
       wallet,
       ...initResponse,
     };
   }
 
-  private wrapIssuerSparkWalletWithTracing() {
-    this.getIssuerTokenBalance = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.getIssuerTokenBalance",
-      this.getIssuerTokenBalance.bind(this),
-    );
-    this.getIssuerTokenMetadata = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.getIssuerTokenMetadata",
-      this.getIssuerTokenMetadata.bind(this),
-    );
-    this.getIssuerTokenIdentifier = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.getIssuerTokenIdentifier",
-      this.getIssuerTokenIdentifier.bind(this),
-    );
-    this.createToken = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.createToken",
-      this.createToken.bind(this),
-    );
-    this.mintTokens = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.mintTokens",
-      this.mintTokens.bind(this),
-    );
-    this.burnTokens = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.burnTokens",
-      this.burnTokens.bind(this),
-    );
-    this.freezeTokens = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.freezeTokens",
-      this.freezeTokens.bind(this),
-    );
-    this.unfreezeTokens = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.unfreezeTokens",
-      this.unfreezeTokens.bind(this),
-    );
-    this.getIssuerTokenDistribution = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.getIssuerTokenDistribution",
-      this.getIssuerTokenDistribution.bind(this),
-    );
-    this.announceTokenL1 = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.announceTokenL1",
-      this.announceTokenL1.bind(this),
-    );
-  }
-
   protected constructor(configOptions?: ConfigOptions, signer?: SparkSigner) {
     super(configOptions, signer);
     this.issuerTokenTransactionService = new IssuerTokenTransactionService(
@@ -123,6 +77,7 @@ export class IssuerSparkWallet extends SparkWallet {
       this.config,
       this.connectionManager,
     );
+    this.wrapIssuerSparkWalletMethodsWithTracing();
   }
 
   /**
@@ -226,7 +181,7 @@ export class IssuerSparkWallet extends SparkWallet {
    * @returns The bech32m encoded token identifier for the issuer's token
    * @throws {NetworkError} If the token identifier cannot be retrieved
    */
-  public async getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier | null> {
+  public async getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier> {
     const tokenMetadata = await this.getIssuerTokenMetadata();
 
     return encodeBech32mTokenIdentifier({
@@ -329,11 +284,8 @@ export class IssuerSparkWallet extends SparkWallet {
       identityPublicKey: BURN_ADDRESS,
       network: this.config.getNetworkType(),
     });
-    const issuerTokenIdentifier: Bech32mTokenIdentifier | null =
+    const issuerTokenIdentifier: Bech32mTokenIdentifier =
       await this.getIssuerTokenIdentifier();
-    if (issuerTokenIdentifier === null) {
-      throw new ValidationError("Issuer token identifier not found");
-    }
 
     return await this.transferTokens({
       tokenIdentifier: issuerTokenIdentifier,
@@ -358,13 +310,6 @@ export class IssuerSparkWallet extends SparkWallet {
     );
 
     const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
-    if (issuerTokenIdentifier === null) {
-      throw new ValidationError("Issuer token identifier not found", {
-        field: "issuerTokenIdentifier",
-        value: issuerTokenIdentifier,
-        expected: "non-null token identifier",
-      });
-    }
 
     const rawTokenIdentifier = decodeBech32mTokenIdentifier(
       issuerTokenIdentifier,
@@ -400,13 +345,6 @@ export class IssuerSparkWallet extends SparkWallet {
     );
 
     const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
-    if (issuerTokenIdentifier === null) {
-      throw new ValidationError("Issuer token identifier not found", {
-        field: "issuerTokenIdentifier",
-        value: issuerTokenIdentifier,
-        expected: "non-null token identifier",
-      });
-    }
 
     const rawTokenIdentifier = decodeBech32mTokenIdentifier(
       issuerTokenIdentifier,
@@ -498,4 +436,46 @@ export class IssuerSparkWallet extends SparkWallet {
       );
     }
   }
+
+  protected getTraceName(methodName: string) {
+    return `IssuerSparkWallet.${methodName}`;
+  }
+
+  private wrapPublicIssuerSparkWalletMethodWithOtelSpan<
+    M extends keyof IssuerSparkWallet,
+  >(methodName: M) {
+    const original = this[methodName];
+
+    if (typeof original !== "function") {
+      throw new Error(
+        `Method ${methodName} is not a function on IssuerSparkWallet.`,
+      );
+    }
+
+    const wrapped = this.wrapWithOtelSpan(
+      this.getTraceName(methodName),
+      original.bind(this) as (...args: unknown[]) => Promise<unknown>,
+    ) as IssuerSparkWallet[M];
+
+    (this as IssuerSparkWallet)[methodName] = wrapped;
+  }
+
+  private wrapIssuerSparkWalletMethodsWithTracing() {
+    const methods = [
+      "getIssuerTokenBalance",
+      "getIssuerTokenMetadata",
+      "getIssuerTokenIdentifier",
+      "createToken",
+      "mintTokens",
+      "burnTokens",
+      "freezeTokens",
+      "unfreezeTokens",
+      "getIssuerTokenDistribution",
+      "announceTokenL1",
+    ] as const;
+
+    methods.forEach((m) =>
+      this.wrapPublicIssuerSparkWalletMethodWithOtelSpan(m),
+    );
+  }
 }