@buildonspark/spark-sdk 0.2.10 → 0.2.12

package/src/proto/spark_authn.ts

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.7.5
+//   protoc-gen-ts_proto  v2.7.7
 //   protoc               v5.29.3
 // source: spark_authn.proto
 

package/src/proto/spark_token.ts

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.7.5
+//   protoc-gen-ts_proto  v2.7.7
 //   protoc               v5.29.3
 // source: spark_token.proto
 

package/src/proto/validate/validate.ts

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.7.5
+//   protoc-gen-ts_proto  v2.7.7
 //   protoc               v5.29.3
 // source: validate/validate.proto
 
@@ -1788,16 +1788,12 @@ export const FloatRules: MessageFns<FloatRules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(45).float(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.float(v);
+      writer.uint32(53).float(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.float(v);
+      writer.uint32(61).float(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -1984,16 +1980,12 @@ export const DoubleRules: MessageFns<DoubleRules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(41).double(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.double(v);
+      writer.uint32(49).double(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.double(v);
+      writer.uint32(57).double(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -2180,16 +2172,12 @@ export const Int32Rules: MessageFns<Int32Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(40).int32(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.int32(v);
+      writer.uint32(48).int32(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.int32(v);
+      writer.uint32(56).int32(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -2376,16 +2364,12 @@ export const Int64Rules: MessageFns<Int64Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(40).int64(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.int64(v);
+      writer.uint32(48).int64(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.int64(v);
+      writer.uint32(56).int64(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -2572,16 +2556,12 @@ export const UInt32Rules: MessageFns<UInt32Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(40).uint32(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.uint32(v);
+      writer.uint32(48).uint32(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.uint32(v);
+      writer.uint32(56).uint32(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -2768,16 +2748,12 @@ export const UInt64Rules: MessageFns<UInt64Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(40).uint64(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.uint64(v);
+      writer.uint32(48).uint64(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.uint64(v);
+      writer.uint32(56).uint64(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -2964,16 +2940,12 @@ export const SInt32Rules: MessageFns<SInt32Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(40).sint32(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.sint32(v);
+      writer.uint32(48).sint32(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.sint32(v);
+      writer.uint32(56).sint32(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -3160,16 +3132,12 @@ export const SInt64Rules: MessageFns<SInt64Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(40).sint64(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.sint64(v);
+      writer.uint32(48).sint64(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.sint64(v);
+      writer.uint32(56).sint64(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -3356,16 +3324,12 @@ export const Fixed32Rules: MessageFns<Fixed32Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(45).fixed32(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.fixed32(v);
+      writer.uint32(53).fixed32(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.fixed32(v);
+      writer.uint32(61).fixed32(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -3552,16 +3516,12 @@ export const Fixed64Rules: MessageFns<Fixed64Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(41).fixed64(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.fixed64(v);
+      writer.uint32(49).fixed64(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.fixed64(v);
+      writer.uint32(57).fixed64(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -3748,16 +3708,12 @@ export const SFixed32Rules: MessageFns<SFixed32Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(45).sfixed32(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.sfixed32(v);
+      writer.uint32(53).sfixed32(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.sfixed32(v);
+      writer.uint32(61).sfixed32(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -3944,16 +3900,12 @@ export const SFixed64Rules: MessageFns<SFixed64Rules> = {
     if (message.gte !== undefined && message.gte !== 0) {
       writer.uint32(41).sfixed64(message.gte);
     }
-    writer.uint32(50).fork();
     for (const v of message.in) {
-      writer.sfixed64(v);
+      writer.uint32(49).sfixed64(v!);
     }
-    writer.join();
-    writer.uint32(58).fork();
     for (const v of message.notIn) {
-      writer.sfixed64(v);
+      writer.uint32(57).sfixed64(v!);
     }
-    writer.join();
     if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
       writer.uint32(64).bool(message.ignoreEmpty);
     }
@@ -5025,16 +4977,12 @@ export const EnumRules: MessageFns<EnumRules> = {
     if (message.definedOnly !== undefined && message.definedOnly !== false) {
       writer.uint32(16).bool(message.definedOnly);
     }
-    writer.uint32(26).fork();
     for (const v of message.in) {
-      writer.int32(v);
+      writer.uint32(24).int32(v!);
     }
-    writer.join();
-    writer.uint32(34).fork();
     for (const v of message.notIn) {
-      writer.int32(v);
+      writer.uint32(32).int32(v!);
     }
-    writer.join();
     return writer;
   },
 

package/src/services/deposit.ts

@@ -28,6 +28,11 @@ import { ConnectionManager } from "./connection.js";
 type ValidateDepositAddressParams = {
   address: Address;
   userPubkey: Uint8Array;
+  verifyCoordinatorProof?: boolean;
+};
+
+export type GenerateStaticDepositAddressParams = {
+  signingPubkey: Uint8Array;
 };
 
 export type GenerateDepositAddressParams = {
@@ -43,8 +48,6 @@ export type CreateTreeRootParams = {
   vout: number;
 };
 
-const INITIAL_TIME_LOCK = 2000;
-
 export class DepositService {
   private readonly config: WalletConfigService;
   private readonly connectionManager: ConnectionManager;
@@ -60,6 +63,7 @@ export class DepositService {
   private async validateDepositAddress({
     address,
     userPubkey,
+    verifyCoordinatorProof = false,
   }: ValidateDepositAddressParams) {
     if (
       !address.depositAddressProof ||
@@ -106,7 +110,10 @@ export class DepositService {
 
     const addrHash = sha256(address.address);
     for (const operator of Object.values(this.config.getSigningOperators())) {
-      if (operator.identifier === this.config.getCoordinatorIdentifier()) {
+      if (
+        operator.identifier === this.config.getCoordinatorIdentifier() &&
+        !verifyCoordinatorProof
+      ) {
         continue;
       }
 
@@ -121,7 +128,11 @@ export class DepositService {
       }
       const sig = secp256k1.Signature.fromDER(operatorSig);
 
-      const isVerified = secp256k1.verify(sig, addrHash, operatorPubkey);
+      const isVerified = secp256k1.verify(
+        sig.toCompactRawBytes(),
+        addrHash,
+        operatorPubkey,
+      );
       if (!isVerified) {
         throw new ValidationError("Operator signature verification failed", {
           field: "operatorSignature",
@@ -131,6 +142,51 @@ export class DepositService {
     }
   }
 
+  async generateStaticDepositAddress({
+    signingPubkey,
+  }: GenerateStaticDepositAddressParams): Promise<GenerateDepositAddressResponse> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    let depositResp: GenerateDepositAddressResponse;
+    try {
+      depositResp = await sparkClient.generate_static_deposit_address({
+        signingPublicKey: signingPubkey,
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        network: this.config.getNetworkProto(),
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to generate static deposit address",
+        {
+          operation: "generate_static_deposit_address",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error),
+        },
+        error as Error,
+      );
+    }
+
+    if (!depositResp.depositAddress) {
+      throw new ValidationError(
+        "No static deposit address response from coordinator",
+        {
+          field: "depositAddress",
+          value: depositResp,
+        },
+      );
+    }
+
+    await this.validateDepositAddress({
+      address: depositResp.depositAddress,
+      userPubkey: signingPubkey,
+      verifyCoordinatorProof: true,
+    });
+
+    return depositResp;
+  }
+
   async generateDepositAddress({
     signingPubkey,
     leafId,

package/src/services/lightning.ts

@@ -1,9 +1,9 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
 import {
   bytesToNumberBE,
   hexToBytes,
   numberToBytesBE,
-} from "@noble/curves/abstract/utils";
-import { secp256k1 } from "@noble/curves/secp256k1";
+} from "@noble/curves/utils";
 import { sha256 } from "@noble/hashes/sha2";
 import { uuidv7 } from "uuidv7";
 import { NetworkError, ValidationError } from "../errors/types.js";

package/src/services/signing.ts

@@ -1,4 +1,4 @@
-import { hexToBytes } from "@noble/curves/abstract/utils";
+import { hexToBytes } from "@noble/curves/utils";
 import { Transaction } from "@scure/btc-signer";
 import { TransactionInput } from "@scure/btc-signer/psbt";
 import { ValidationError } from "../errors/types.js";

package/src/services/token-transactions.ts

@@ -1,9 +1,9 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
 import {
   bytesToHex,
   bytesToNumberBE,
   numberToBytesBE,
-} from "@noble/curves/abstract/utils";
-import { secp256k1 } from "@noble/curves/secp256k1";
+} from "@noble/curves/utils";
 import { hexToBytes } from "@noble/hashes/utils";
 import {
   InternalValidationError,
@@ -17,9 +17,7 @@ import {
   QueryTokenTransactionsRequest as QueryTokenTransactionsRequestV0,
   RevocationSecretWithIndex,
   SignTokenTransactionResponse,
-  SparkInvoiceFields,
   TokenTransaction as TokenTransactionV0,
-  TokenTransactionWithStatus as TokenTransactionWithStatusV0,
 } from "../proto/spark.js";
 import {
   InputTtxoSignaturesPerOperator,
@@ -28,7 +26,6 @@ import {
   SignatureWithIndex,
   TokenOutput,
   TokenTransaction,
-  TokenTransactionWithStatus as TokenTransactionWithStatusV1,
 } from "../proto/spark_token.js";
 import { TokenOutputsMap } from "../spark-wallet/types.js";
 import { SparkCallOptions } from "../types/grpc.js";

package/src/services/transfer.ts

@@ -1,10 +1,10 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
 import {
   bytesToHex,
   equalBytes,
   hexToBytes,
   numberToBytesBE,
-} from "@noble/curves/abstract/utils";
-import { secp256k1 } from "@noble/curves/secp256k1";
+} from "@noble/curves/utils";
 import { sha256 } from "@noble/hashes/sha2";
 import { Transaction } from "@scure/btc-signer";
 import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt";

package/src/services/xhr-transport.ts

@@ -100,7 +100,7 @@ export function XHRTransport(config?: XHRTransportConfig): Transport {
         break;
       }
 
-      requestBody = bodyBuffer!;
+      requestBody = bodyBuffer!.slice();
     } else {
       let iterator: AsyncIterator<Uint8Array> | undefined;
 
@@ -117,7 +117,7 @@ export function XHRTransport(config?: XHRTransportConfig): Transport {
           if (done) {
             controller.close();
           } else {
-            controller.enqueue(value);
+            controller.enqueue(value.slice());
           }
         },
         async cancel() {

package/src/signer/signer.ts

@@ -1,11 +1,11 @@
 import { privateNegate } from "@bitcoinerlab/secp256k1";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
 import {
   bytesToHex,
   bytesToNumberBE,
   equalBytes,
   hexToBytes,
-} from "@noble/curves/abstract/utils";
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+} from "@noble/curves/utils";
 import { sha256 } from "@noble/hashes/sha2";
 import { HDKey } from "@scure/bip32";
 import { generateMnemonic, mnemonicToSeed } from "@scure/bip39";

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

@@ -1,12 +1,12 @@
 import { isNode, isObject, mapCurrencyAmount } from "@lightsparkdev/core";
+import { secp256k1 } from "@noble/curves/secp256k1";
 import {
   bytesToHex,
   bytesToNumberBE,
   equalBytes,
   hexToBytes,
   numberToVarBytesBE,
-} from "@noble/curves/abstract/utils";
-import { secp256k1 } from "@noble/curves/secp256k1";
+} from "@noble/curves/utils";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import { Address, OutScript, Transaction } from "@scure/btc-signer";
@@ -100,7 +100,6 @@ import { EventEmitter } from "eventemitter3";
 import { ClientError, Status } from "nice-grpc-common";
 import { isReactNative } from "../constants.js";
 import { Network as NetworkProto, networkToJSON } from "../proto/spark.js";
-import { TokenTransactionWithStatus } from "../proto/spark_token.js";
 import {
   decodeInvoice,
   getNetworkFromInvoice,
@@ -126,6 +125,7 @@ import {
 } from "../utils/address.js";
 import { chunkArray } from "../utils/chunkArray.js";
 import { getFetch } from "../utils/fetch.js";
+import { HashSparkInvoice } from "../utils/invoice-hashing.js";
 import { addPublicKeys } from "../utils/keys.js";
 import { RetryContext, withRetry } from "../utils/retry.js";
 import {
@@ -145,7 +145,6 @@ import type {
   TransferParams,
   UserTokenMetadata,
 } from "./types.js";
-import { HashSparkInvoice } from "../utils/invoice-hashing.js";
 
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
@@ -1628,7 +1627,7 @@ export class SparkWallet extends EventEmitter {
    * @returns {Promise<string>} A Bitcoin address for depositing funds
    */
   public async getSingleUseDepositAddress(): Promise<string> {
-    return await this.generateDepositAddress(false);
+    return await this.generateDepositAddress();
   }
 
   /**
@@ -1638,47 +1637,38 @@ export class SparkWallet extends EventEmitter {
    * @returns {Promise<string>} A Bitcoin address for depositing funds
    */
   public async getStaticDepositAddress(): Promise<string> {
-    try {
-      return await this.generateDepositAddress(true);
-    } catch (error: any) {
-      if (error.message?.includes("static deposit address already exists")) {
-        // Query instead of checking error message in case error message changes.
-        const existingAddresses = await this.queryStaticDepositAddresses();
-        if (existingAddresses.length > 0 && existingAddresses[0]) {
-          return existingAddresses[0];
-        } else {
-          throw error;
-        }
-      } else {
-        throw error;
-      }
+    const signingPubkey =
+      await this.config.signer.getStaticDepositSigningKey(0);
+
+    const address = await this.depositService!.generateStaticDepositAddress({
+      signingPubkey,
+    });
+    if (!address.depositAddress) {
+      throw new RPCError("Failed to generate static deposit address", {
+        method: "generateStaticDepositAddress",
+        params: { signingPubkey },
+      });
     }
+
+    return address.depositAddress.address;
   }
 
   /**
    * Generates a deposit address for receiving funds.
-   *
-   * @param {boolean} static - Whether the address is static or single use
    * @returns {Promise<string>} A deposit address
    * @private
    */
-  private async generateDepositAddress(isStatic?: boolean): Promise<string> {
+  private async generateDepositAddress(): Promise<string> {
     const leafId = uuidv7();
-    let signingPubkey: Uint8Array;
-    if (isStatic) {
-      // TODO: Add support for multiple static deposit addresses
-      signingPubkey = await this.config.signer.getStaticDepositSigningKey(0);
-    } else {
-      signingPubkey = await this.config.signer.getPublicKeyFromDerivation({
-        type: KeyDerivationType.LEAF,
-        path: leafId,
-      });
-    }
+
+    const signingPubkey = await this.config.signer.getPublicKeyFromDerivation({
+      type: KeyDerivationType.LEAF,
+      path: leafId,
+    });
 
     const address = await this.depositService!.generateDepositAddress({
       signingPubkey,
       leafId,
-      isStatic,
     });
     if (!address.depositAddress) {
       throw new RPCError("Failed to generate deposit address", {
@@ -1713,6 +1703,7 @@ export class SparkWallet extends EventEmitter {
     depositAddress: string,
     limit: number = 100,
     offset: number = 0,
+    excludeClaimed: boolean = false,
   ): Promise<{ txid: string; vout: number }[]> {
     if (!depositAddress) {
       throw new ValidationError("Deposit address cannot be empty", {
@@ -1730,6 +1721,7 @@ export class SparkWallet extends EventEmitter {
         network: NetworkToProto[this.config.getNetwork()],
         limit,
         offset,
+        excludeClaimed,
       });
 
       return (

package/src/spark_bindings/wasm/index.ts

@@ -1,3 +1,5 @@
+import { bytesToHex } from "@noble/curves/utils";
+
 import {
   create_dummy_tx,
   decrypt_ecies,
@@ -16,6 +18,7 @@ import {
   ISigningNonce,
   SignFrostParams,
 } from "../types.js";
+import { SparkSdkLogger, LOGGER_NAMES } from "../../utils/logging.js";
 
 function createKeyPackage(params: IKeyPackage): KeyPackage {
   return new KeyPackage(
@@ -43,6 +46,13 @@ export function signFrost({
   statechainCommitments,
   adaptorPubKey,
 }: SignFrostParams): Uint8Array {
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", {
+    message: bytesToHex(message),
+    keyPackage: keyPackage,
+    nonce: nonce,
+    selfCommitment: selfCommitment,
+    statechainCommitments: statechainCommitments,
+  });
   return wasm_sign_frost(
     message,
     createKeyPackage(keyPackage),
@@ -64,6 +74,17 @@ export function aggregateFrost({
   verifyingKey,
   adaptorPubKey,
 }: AggregateFrostParams): Uint8Array {
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", {
+    message: bytesToHex(message),
+    statechainCommitments: statechainCommitments,
+    selfCommitment: selfCommitment,
+    statechainSignatures: statechainSignatures,
+    selfSignature: bytesToHex(selfSignature),
+    statechainPublicKeys: statechainPublicKeys,
+    selfPublicKey: bytesToHex(selfPublicKey),
+    verifyingKey: bytesToHex(verifyingKey),
+    adaptorPubKey: adaptorPubKey ? bytesToHex(adaptorPubKey) : undefined,
+  });
   return wasm_aggregate_frost(
     message,
     statechainCommitments,

package/src/tests/address.test.ts

@@ -1,26 +1,26 @@
 import { uuidv7obj } from "uuidv7";
 
-import {
-  Bech32mTokenIdentifier,
-  decodeBech32mTokenIdentifier,
-} from "../utils/token-identifier.js";
 import {
   bytesToHex,
   bytesToNumberBE,
   hexToBytes,
   numberToVarBytesBE,
-} from "@noble/curves/abstract/utils";
+} from "@noble/curves/utils";
+import { bech32m } from "@scure/base";
+import { SparkAddress } from "../proto/spark.js";
 import {
-  encodeSparkAddress,
+  bech32mDecode,
   decodeSparkAddress,
-  getNetworkFromSparkAddress,
+  encodeSparkAddress,
   encodeSparkAddressWithSignature,
+  getNetworkFromSparkAddress,
   SparkAddressData,
-  bech32mDecode,
   SparkAddressFormat,
 } from "../utils/address.js";
-import { SparkAddress } from "../proto/spark.js";
-import { bech32m } from "@scure/base";
+import {
+  Bech32mTokenIdentifier,
+  decodeBech32mTokenIdentifier,
+} from "../utils/token-identifier.js";
 
 describe("Spark Invoice Encode/Decode", () => {
   const testCases = [