@buildonspark/issuer-sdk 0.0.110 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @buildonspark/issuer-sdk
 
+## 0.1.1
+
+### Patch Changes
+
+- **Token transaction v3**
+  - Updated test configs and expanded test coverage to include both v2 and v3 token transactions
+
+  **Extra metadata field available when creating new tokens**
+  - Added a field to accept additional bytes data to attach to token creates
+
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.5.1
+
+## 0.1.0
+
+### Minor Changes
+
+- - **Entry points & module resolution**
+    - The package now provides distinct entrypoints:
+      - `index.browser` (default `module`/`import` for browser/bundlers).
+      - `index.node` for Node environments.
+      - `index.react-native` for React Native.
+    - The `exports` map was simplified and modernized so:
+      - `import { IssuerSparkWallet } from "@buildonspark/issuer-sdk"` resolves correctly in Node ESM, bundlers, and React Native without manual path selection.
+      - Type definitions for browser/Node/React Native are correctly wired.
+  - **Shared API surface**
+    - A new `index-shared` consolidates type and helper re‑exports:
+      - Re‑exports signer types (`DefaultSparkSigner`, `UnsafeStatelessSparkSigner`, `SparkSigner` and related Frost types).
+      - Re‑exports `WalletConfig`, `ConfigOptions`, and issuer‑specific types (`IssuerTokenMetadata`, etc.).
+    - Public API usage for typical consumers (importing `IssuerSparkWallet` and issuer types) remains the same; only the internal file layout and `exports` map changed.
+  - **Token transaction v3 support**
+    - `IssuerTokenTransactionService` gained:
+      - `constructPartialCreateTokenTransaction(...)` and `constructPartialMintTokenTransaction(...)` that build v3 `PartialTokenTransaction` objects with metadata and withdraw parameters.
+      - These complement the existing v2 `constructCreateTokenTransaction` and `constructMintTokenTransaction`.
+    - `IssuerSparkWallet.createToken` and `mintTokens` now:
+      - Check `config.getTokenTransactionVersion()`.
+      - Use v2 full transactions and `broadcastTokenTransaction(...)` when `"V2"`.
+      - Use v3 partial transactions and `broadcastTokenTransactionV3(...)` when `"V3"`.
+  - **Error and method wrapping**
+    - Issuer services and `IssuerSparkWallet` now emit the same simplified `SparkError` family used in `spark-sdk`, aligning error handling semantics for issuers with the core wallet.
+    - Public issuer wallet methods are wrapped via `SparkWallet.wrapMethod`, so they benefit from the centralized error‑wrapping and consistent error surface.
+
+### Patch Changes
+
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.5.0
+
 ## 0.0.110
 
 ### Patch Changes

package/dist/{issuer-spark-wallet-BdN--ywq.d.cts → index.browser.d.ts}

@@ -1,4 +1,5 @@
-import { SparkWallet, ConfigOptions, SparkSigner, Bech32mTokenIdentifier } from '@buildonspark/spark-sdk';
+import { SparkWallet, ConfigOptions, SparkSigner, Bech32mTokenIdentifier, 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';
 
 /**
@@ -37,6 +38,8 @@ type IssuerTokenMetadata = {
     maxSupply: bigint;
     /** Whether the token is freezable */
     isFreezable: boolean;
+    /** Extra metadata of the token */
+    extraMetadata?: Uint8Array;
 };
 interface TokenDistribution {
     totalCirculatingSupply: bigint;
@@ -71,13 +74,13 @@ declare abstract class IssuerSparkWallet extends SparkWallet {
     /**
      * 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
+     * @throws {SparkRequestError} 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
+     * @throws {SparkRequestError} If the token identifier cannot be retrieved
      */
     getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier>;
     /**
@@ -89,18 +92,20 @@ declare abstract class IssuerSparkWallet extends SparkWallet {
      * @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.
      *
      * @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.
+     * @throws {SparkValidationError} If `decimals` is not a safe integer or other validation fails.
+     * @throws {SparkRequestError} If the announcement transaction cannot be broadcast.
      */
-    createToken({ tokenName, tokenTicker, decimals, isFreezable, maxSupply, }: {
+    createToken({ tokenName, tokenTicker, decimals, isFreezable, maxSupply, extraMetadata, }: {
         tokenName: string;
         tokenTicker: string;
         decimals: number;
         isFreezable: boolean;
         maxSupply?: bigint;
+        extraMetadata?: Uint8Array;
     }): Promise<string>;
     /**
      * Mints new tokens
@@ -135,12 +140,16 @@ declare abstract class IssuerSparkWallet extends SparkWallet {
     }>;
     /**
      * Retrieves the distribution information for the issuer's token.
-     * @throws {NotImplementedError} This feature is not yet supported
+     * @throws {SparkError} This feature is not yet supported
      */
     getIssuerTokenDistribution(): Promise<TokenDistribution>;
     protected getTraceName(methodName: string): string;
-    private wrapPublicIssuerSparkWalletMethodWithOtelSpan;
-    private wrapIssuerSparkWalletMethodsWithTracing;
+    private wrapIssuerPublicMethod;
+    private wrapIssuerSparkWalletMethods;
 }
 
-export { IssuerSparkWallet as I, type TokenDistribution as T, type IssuerTokenMetadata as a };
+declare class IssuerSparkWalletBrowser extends IssuerSparkWallet {
+    protected buildConnectionManager(config: WalletConfigService): ConnectionManager;
+}
+
+export { IssuerSparkWalletBrowser as IssuerSparkWallet, type IssuerTokenMetadata, type TokenDistribution };

package/dist/{chunk-M6QULHGS.js → index.browser.js}

@@ -1,6 +1,16 @@
-import {
-  Buffer
-} from "./chunk-7B4B24XF.js";
+// buffer.js
+import { Buffer } from "buffer";
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = Buffer;
+}
+if (typeof window !== "undefined") {
+  if (typeof window.global === "undefined") {
+    window.global = window;
+  }
+  if (typeof window.globalThis === "undefined") {
+    window.globalThis = window;
+  }
+}
 
 // src/issuer-wallet/issuer-spark-wallet.ts
 import {
@@ -8,26 +18,26 @@ import {
   decodeSparkAddress,
   encodeBech32mTokenIdentifier,
   encodeSparkAddress,
-  NetworkError as NetworkError2,
-  NotImplementedError,
+  SparkError,
   SparkWallet,
-  ValidationError as ValidationError3
+  SparkRequestError as SparkRequestError2,
+  SparkValidationError as SparkValidationError3
 } from "@buildonspark/spark-sdk";
 import { bytesToHex, bytesToNumberBE, hexToBytes as hexToBytes2 } from "@noble/curves/utils";
 
 // src/services/freeze.ts
 import {
-  NetworkError,
+  SparkRequestError,
   collectResponses
 } from "@buildonspark/spark-sdk";
 import { hexToBytes } from "@noble/curves/utils";
 
 // src/utils/token-hashing.ts
 import { sha256 } from "@scure/btc-signer/utils";
-import { ValidationError } from "@buildonspark/spark-sdk";
+import { SparkValidationError } from "@buildonspark/spark-sdk";
 function hashFreezeTokensPayload(payload) {
   if (!payload) {
-    throw new ValidationError("Freeze tokens payload cannot be nil", {
+    throw new SparkValidationError("Freeze tokens payload cannot be nil", {
       field: "payload",
       value: payload,
       expected: "valid freeze tokens payload"
@@ -127,14 +137,9 @@ var TokenFreezeService = class {
             response
           };
         } catch (error) {
-          throw new NetworkError(
+          throw new SparkRequestError(
             `Failed to send a freeze/unfreeze operation to operator: ${operator.address}`,
-            {
-              operation: "freeze_tokens",
-              errorCount: 1,
-              errors: error instanceof Error ? error.message : String(error)
-            },
-            error instanceof Error ? error : void 0
+            { operation: "freeze_tokens", error }
           );
         }
       })
@@ -177,7 +182,35 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
       invoiceAttachments: []
     };
   }
-  async constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable) {
+  async constructPartialMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
+    return {
+      version: 3,
+      tokenTransactionMetadata: {
+        network: this.config.getNetworkProto(),
+        sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
+        validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
+        clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+        invoiceAttachments: []
+      },
+      tokenInputs: {
+        $case: "mintInput",
+        mintInput: {
+          issuerPublicKey: issuerTokenPublicKey,
+          tokenIdentifier: rawTokenIdentifierBytes
+        }
+      },
+      partialTokenOutputs: [
+        {
+          ownerPublicKey: issuerTokenPublicKey,
+          tokenIdentifier: rawTokenIdentifierBytes,
+          withdrawBondSats: this.config.getExpectedWithdrawBondSats(),
+          withdrawRelativeBlockLocktime: this.config.getExpectedWithdrawRelativeBlockLocktime(),
+          tokenAmount: numberToBytesBE(tokenAmount, 16)
+        }
+      ]
+    };
+  }
+  async constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
     return {
       version: 2,
       network: this.config.getNetworkProto(),
@@ -189,7 +222,8 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
           tokenTicker,
           decimals,
           maxSupply: numberToBytesBE(maxSupply, 16),
-          isFreezable
+          isFreezable,
+          extraMetadata
         }
       },
       tokenOutputs: [],
@@ -199,10 +233,35 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
       invoiceAttachments: []
     };
   }
+  async constructPartialCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
+    return {
+      version: 3,
+      tokenTransactionMetadata: {
+        network: this.config.getNetworkProto(),
+        sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
+        validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
+        clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+        invoiceAttachments: []
+      },
+      tokenInputs: {
+        $case: "createInput",
+        createInput: {
+          issuerPublicKey: tokenPublicKey,
+          tokenName,
+          tokenTicker,
+          decimals,
+          maxSupply: numberToBytesBE(maxSupply, 16),
+          isFreezable,
+          extraMetadata
+        }
+      },
+      partialTokenOutputs: []
+    };
+  }
 };
 
 // src/utils/create-validation.ts
-import { ValidationError as ValidationError2 } from "@buildonspark/spark-sdk";
+import { SparkValidationError as SparkValidationError2 } from "@buildonspark/spark-sdk";
 function isNfcNormalized(value) {
   return value.normalize("NFC") === value;
 }
@@ -212,24 +271,28 @@ var MIN_SYMBOL_SIZE = 3;
 var MAX_SYMBOL_SIZE = 6;
 var MAX_DECIMALS = 255;
 var MAXIMUM_MAX_SUPPLY = (1n << 128n) - 1n;
-function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply) {
+var MAX_TOKEN_CONTENT_SIZE = 1024;
+function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply, extraMetadata) {
   if (!isNfcNormalized(tokenName)) {
-    throw new ValidationError2("Token name must be NFC-normalised UTF-8", {
+    throw new SparkValidationError2("Token name must be NFC-normalised UTF-8", {
       field: "tokenName",
       value: tokenName,
       expected: "NFC normalised string"
     });
   }
   if (!isNfcNormalized(tokenTicker)) {
-    throw new ValidationError2("Token ticker must be NFC-normalised UTF-8", {
-      field: "tokenTicker",
-      value: tokenTicker,
-      expected: "NFC normalised string"
-    });
+    throw new SparkValidationError2(
+      "Token ticker must be NFC-normalised UTF-8",
+      {
+        field: "tokenTicker",
+        value: tokenTicker,
+        expected: "NFC normalised string"
+      }
+    );
   }
   const nameBytes = Buffer.from(tokenName, "utf-8").length;
   if (nameBytes < MIN_NAME_SIZE || nameBytes > MAX_NAME_SIZE) {
-    throw new ValidationError2(
+    throw new SparkValidationError2(
       `Token name must be between ${MIN_NAME_SIZE} and ${MAX_NAME_SIZE} bytes`,
       {
         field: "tokenName",
@@ -241,7 +304,7 @@ function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply) {
   }
   const tickerBytes = Buffer.from(tokenTicker, "utf-8").length;
   if (tickerBytes < MIN_SYMBOL_SIZE || tickerBytes > MAX_SYMBOL_SIZE) {
-    throw new ValidationError2(
+    throw new SparkValidationError2(
       `Token ticker must be between ${MIN_SYMBOL_SIZE} and ${MAX_SYMBOL_SIZE} bytes`,
       {
         field: "tokenTicker",
@@ -252,7 +315,7 @@ function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply) {
     );
   }
   if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > MAX_DECIMALS) {
-    throw new ValidationError2(
+    throw new SparkValidationError2(
       `Decimals must be an integer between 0 and ${MAX_DECIMALS}`,
       {
         field: "decimals",
@@ -262,12 +325,22 @@ function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply) {
     );
   }
   if (maxSupply < 0n || maxSupply > MAXIMUM_MAX_SUPPLY) {
-    throw new ValidationError2(`maxSupply must be between 0 and 2^128-1`, {
+    throw new SparkValidationError2(`maxSupply must be between 0 and 2^128-1`, {
       field: "maxSupply",
       value: maxSupply.toString(),
       expected: `>=0 and <=${MAXIMUM_MAX_SUPPLY.toString()}`
     });
   }
+  if (extraMetadata && extraMetadata.length > MAX_TOKEN_CONTENT_SIZE) {
+    throw new SparkValidationError2(
+      `Extra metadata must be less than ${MAX_TOKEN_CONTENT_SIZE} bytes`,
+      {
+        field: "extraMetadata",
+        value: extraMetadata.length,
+        expected: `<${MAX_TOKEN_CONTENT_SIZE}`
+      }
+    );
+  }
 }
 
 // src/issuer-wallet/issuer-spark-wallet.ts
@@ -290,7 +363,7 @@ var IssuerSparkWallet = class extends SparkWallet {
       this.config,
       this.connectionManager
     );
-    this.wrapIssuerSparkWalletMethodsWithTracing();
+    this.wrapIssuerSparkWalletMethods();
   }
   /**
    * Gets the token balance for the issuer's token.
@@ -316,7 +389,7 @@ var IssuerSparkWallet = class extends SparkWallet {
   /**
    * 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
+   * @throws {SparkRequestError} If the token metadata cannot be retrieved
    */
   async getIssuerTokenMetadata() {
     const issuerPublicKey = await super.getIdentityPublicKey();
@@ -333,7 +406,8 @@ var IssuerSparkWallet = class extends SparkWallet {
         tokenTicker: metadata.tokenTicker,
         decimals: metadata.decimals,
         maxSupply: bytesToNumberBE(metadata.maxSupply),
-        isFreezable: metadata.isFreezable
+        isFreezable: metadata.isFreezable,
+        extraMetadata: metadata.extraMetadata
       };
     }
     const sparkTokenClient = await this.connectionManager.createSparkTokenClient(
@@ -344,7 +418,7 @@ var IssuerSparkWallet = class extends SparkWallet {
         issuerPublicKeys: Array.of(hexToBytes2(issuerPublicKey))
       });
       if (response.tokenMetadata.length === 0) {
-        throw new ValidationError3(
+        throw new SparkValidationError3(
           "Token metadata not found - If a token has not yet been created, please create it first. Try again in a few seconds.",
           {
             field: "tokenMetadata",
@@ -368,19 +442,17 @@ var IssuerSparkWallet = class extends SparkWallet {
         tokenTicker: metadata.tokenTicker,
         decimals: metadata.decimals,
         maxSupply: bytesToNumberBE(metadata.maxSupply),
-        isFreezable: metadata.isFreezable
+        isFreezable: metadata.isFreezable,
+        extraMetadata: metadata.extraMetadata
       };
     } catch (error) {
-      throw new NetworkError2("Failed to fetch token metadata", {
-        errorCount: 1,
-        errors: error instanceof Error ? error.message : String(error)
-      });
+      throw new SparkRequestError2("Failed to fetch token metadata", { error });
     }
   }
   /**
    * 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
+   * @throws {SparkRequestError} If the token identifier cannot be retrieved
    */
   async getIssuerTokenIdentifier() {
     const tokenMetadata = await this.getIssuerTokenMetadata();
@@ -398,32 +470,56 @@ var IssuerSparkWallet = class extends SparkWallet {
    * @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.
    *
    * @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.
+   * @throws {SparkValidationError} If `decimals` is not a safe integer or other validation fails.
+   * @throws {SparkRequestError} If the announcement transaction cannot be broadcast.
    */
   async createToken({
     tokenName,
     tokenTicker,
     decimals,
     isFreezable,
-    maxSupply = 0n
+    maxSupply = 0n,
+    extraMetadata
   }) {
-    validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply);
-    const issuerPublicKey = await super.getIdentityPublicKey();
-    const tokenTransaction = await this.issuerTokenTransactionService.constructCreateTokenTransaction(
-      hexToBytes2(issuerPublicKey),
+    validateTokenParameters(
       tokenName,
       tokenTicker,
       decimals,
       maxSupply,
-      isFreezable
-    );
-    return await this.issuerTokenTransactionService.broadcastTokenTransaction(
-      tokenTransaction
+      extraMetadata
     );
+    const issuerPublicKey = await super.getIdentityPublicKey();
+    if (this.config.getTokenTransactionVersion() === "V2") {
+      const tokenTransaction = await this.issuerTokenTransactionService.constructCreateTokenTransaction(
+        hexToBytes2(issuerPublicKey),
+        tokenName,
+        tokenTicker,
+        decimals,
+        maxSupply,
+        isFreezable,
+        extraMetadata
+      );
+      return await this.issuerTokenTransactionService.broadcastTokenTransaction(
+        tokenTransaction
+      );
+    } else {
+      const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialCreateTokenTransaction(
+        hexToBytes2(issuerPublicKey),
+        tokenName,
+        tokenTicker,
+        decimals,
+        maxSupply,
+        isFreezable,
+        extraMetadata
+      );
+      return await this.issuerTokenTransactionService.broadcastTokenTransactionV3(
+        partialTokenTransaction
+      );
+    }
   }
   /**
    * Mints new tokens
@@ -435,14 +531,25 @@ var IssuerSparkWallet = class extends SparkWallet {
     const issuerTokenPublicKeyBytes = hexToBytes2(issuerTokenPublicKey);
     const tokenMetadata = await this.getIssuerTokenMetadata();
     const rawTokenIdentifier = tokenMetadata.rawTokenIdentifier;
-    const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-      rawTokenIdentifier,
-      issuerTokenPublicKeyBytes,
-      tokenAmount
-    );
-    return await this.issuerTokenTransactionService.broadcastTokenTransaction(
-      tokenTransaction
-    );
+    if (this.config.getTokenTransactionVersion() === "V2") {
+      const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
+        rawTokenIdentifier,
+        issuerTokenPublicKeyBytes,
+        tokenAmount
+      );
+      return await this.issuerTokenTransactionService.broadcastTokenTransaction(
+        tokenTransaction
+      );
+    } else {
+      const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialMintTokenTransaction(
+        rawTokenIdentifier,
+        issuerTokenPublicKeyBytes,
+        tokenAmount
+      );
+      return await this.issuerTokenTransactionService.broadcastTokenTransactionV3(
+        partialTokenTransaction
+      );
+    }
   }
   /**
    * Burns issuer's tokens
@@ -517,45 +624,66 @@ var IssuerSparkWallet = class extends SparkWallet {
   }
   /**
    * Retrieves the distribution information for the issuer's token.
-   * @throws {NotImplementedError} This feature is not yet supported
+   * @throws {SparkError} This feature is not yet supported
    */
   async getIssuerTokenDistribution() {
-    throw new NotImplementedError("Token distribution is not yet supported");
+    throw new SparkError("Token distribution is not yet supported");
   }
   getTraceName(methodName) {
     return `IssuerSparkWallet.${methodName}`;
   }
-  wrapPublicIssuerSparkWalletMethodWithOtelSpan(methodName) {
+  wrapIssuerPublicMethod(methodName) {
     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)
+    const originalFn = original;
+    const wrapped = SparkWallet.wrapMethod(
+      String(methodName),
+      originalFn,
+      this
     );
     this[methodName] = wrapped;
   }
-  wrapIssuerSparkWalletMethodsWithTracing() {
-    const methods = [
-      "getIssuerTokenBalance",
-      "getIssuerTokenMetadata",
-      "getIssuerTokenIdentifier",
-      "createToken",
-      "mintTokens",
-      "burnTokens",
-      "freezeTokens",
-      "unfreezeTokens",
-      "getIssuerTokenDistribution"
-    ];
-    methods.forEach(
-      (m) => this.wrapPublicIssuerSparkWalletMethodWithOtelSpan(m)
+  wrapIssuerSparkWalletMethods() {
+    PUBLIC_ISSUER_SPARK_WALLET_METHODS.forEach(
+      (m) => this.wrapIssuerPublicMethod(m)
     );
   }
 };
+var PUBLIC_ISSUER_SPARK_WALLET_METHODS = [
+  "getIssuerTokenBalance",
+  "getIssuerTokenMetadata",
+  "getIssuerTokenIdentifier",
+  "createToken",
+  "mintTokens",
+  "burnTokens",
+  "freezeTokens",
+  "unfreezeTokens",
+  "getIssuerTokenDistribution"
+];
+
+// src/issuer-wallet/issuer-spark-wallet.browser.ts
+import {
+  ConnectionManager
+} from "@buildonspark/spark-sdk";
+var IssuerSparkWalletBrowser = class extends IssuerSparkWallet {
+  buildConnectionManager(config) {
+    return new ConnectionManager(config);
+  }
+};
 
+// src/index-shared.ts
+import {
+  DefaultSparkSigner,
+  UnsafeStatelessSparkSigner
+} from "@buildonspark/spark-sdk";
+import { WalletConfig } from "@buildonspark/spark-sdk";
 export {
-  IssuerSparkWallet
+  DefaultSparkSigner,
+  IssuerSparkWalletBrowser as IssuerSparkWallet,
+  UnsafeStatelessSparkSigner,
+  WalletConfig
 };