@buildonspark/spark-sdk 0.2.7 → 0.2.9

package/src/tests/address.test.ts

@@ -10,7 +10,17 @@ import {
   hexToBytes,
   numberToVarBytesBE,
 } from "@noble/curves/abstract/utils";
-import { encodeSparkAddress, decodeSparkAddress } from "../utils/address.js";
+import {
+  encodeSparkAddress,
+  decodeSparkAddress,
+  getNetworkFromSparkAddress,
+  encodeSparkAddressWithSignature,
+  SparkAddressData,
+  bech32mDecode,
+  SparkAddressFormat,
+} from "../utils/address.js";
+import { SparkAddress } from "../proto/spark.js";
+import { bech32m } from "@scure/base";
 
 describe("Spark Invoice Encode/Decode", () => {
   const testCases = [
@@ -213,3 +223,79 @@ describe("Spark Invoice Encode/Decode", () => {
     });
   });
 });
+
+describe("getNetworkFromSparkAddress", () => {
+  test("REGTEST", () => {
+    const network = getNetworkFromSparkAddress(
+      "sprt1pgssx63fa5g6uyv450rajp5ndwy9laxzpsp9e37su58jddmcdsvhgm5n7y0ud6",
+    );
+    expect(network).toBe("REGTEST");
+  });
+  test("MAINNET", () => {
+    const network = getNetworkFromSparkAddress(
+      "sp1pgssxwh6hznfdc3c0cuqrhgttder539d52a0rqcf34amge69huh664gd2ew787",
+    );
+    expect(network).toBe("MAINNET");
+  });
+});
+
+describe("knownSparkAddress", () => {
+  test("known spark address decodes and encodes to the same address", () => {
+    const address =
+      "sprt1pgss8stv8nfkamyea7mtc8werley55anfnnpgtnglff0wmxwm52mkyk6zfeqsqgjzqqe3dvr6e48l2alnpagf7ny3vlj5pr5v4ehgv3pqwd7wxx3awkku9p3epk73na6hcf9220h8kue2tmlkqx8tcrfpsf5ywsvpzgd9px9qcgvpzy8ecp35fg2yq4r39r4njq3slgcul7laarh9sndex9uejz7vwrcrz4g7n4egvwt5yspvsdyped46sflczvrzh0jzksgqnvaqlk02cz4vkwjrkwuep9zsrz5vmjp7mqxq7762tfjczy07at2fvzd7cgk2sqsxrmqdxnpy464rmq2nzdqzpuhme";
+    const decoded = bech32mDecode(address as SparkAddressFormat);
+    const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
+
+    const { identityPublicKey, sparkInvoiceFields, signature } = payload;
+
+    const sparkAddressData: SparkAddressData = {
+      identityPublicKey: bytesToHex(identityPublicKey),
+      network: "REGTEST",
+      sparkInvoiceFields: sparkInvoiceFields,
+    };
+    const reEncoded = encodeSparkAddressWithSignature(
+      sparkAddressData,
+      signature,
+    );
+    expect(reEncoded).toBe(address);
+  });
+
+  test("known spark address decodes to expected fields", () => {
+    const address =
+      "sprt1pgss8stv8nfkamyea7mtc8werley55anfnnpgtnglff0wmxwm52mkyk6zfeqsqgjzqqe3dvr6e48l2alnpagf7ny3vl35fg2yq4r39r4njq3slgcul7laarh9sndex9uejz7vwrcrz4g7n4egvwt5yspvs4qgar9wd6ryggrn0n3350t44hpgvwgdh5vlw47zf2jnaeahx2j7lasp367q6gvzdpr5rqgjrfgf3gxzrqg3p7wqvdyped46sflczvrzh0jzksgqnvaqlk02cz4vkwjrkwuep9zsrz5vmjp7mqxq7762tfjczy07at2fvzd7cgk2sqsxrmqdxnpy464rmq2nzdqneal34";
+
+    const decoded = decodeSparkAddress(address, "REGTEST");
+
+    expect(decoded.network).toBe("REGTEST");
+    expect(decoded.identityPublicKey).toBe(
+      "03c16c3cd36eec99efb6bc1dd91ff24a53b34ce6142e68fa52f76ccedd15bb12da",
+    );
+
+    const f = decoded.sparkInvoiceFields!;
+    expect(f.version).toBe(1);
+    expect(f.id).toBe("0198b583-d66a-7fab-bf98-7a84fa648b3f");
+
+    expect(f.paymentType?.type).toBe("tokens");
+    expect(
+      f.paymentType && "tokenIdentifier" in f.paymentType
+        ? f.paymentType.tokenIdentifier
+        : undefined,
+    ).toBe("2a3894759c81187d18e7fdfef4772c26dc98bccc85e6387818aa8f4eb9431cba");
+    expect(
+      f.paymentType && "amount" in f.paymentType
+        ? f.paymentType.amount
+        : undefined,
+    ).toBe(100n);
+
+    expect(f.memo).toBe("test");
+    expect(f.senderPublicKey).toBe(
+      "039be718d1ebad6e1431c86de8cfbabe125529f73db9952f7fb00c75e0690c1342",
+    );
+
+    expect(f.expiryTime?.toISOString()).toBe("2025-08-17T00:57:52.969Z");
+
+    expect(decoded.signature).toBe(
+      "e5b5d413fc098315df215a0804d9d07ecf56055659d21d9dcc84a280c5466e41f6c0607bda52d32c088ff756a4b04df61165401030f6069a61257551ec0a989a",
+    );
+  });
+});

package/src/tests/integration/retry.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, jest } from "@jest/globals";
+import { DEFAULT_RETRY_CONFIG, withRetry } from "../../utils/retry.js";
+
+describe("Retry Test", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("should succeed on first attempt", async () => {
+    const operation = jest
+      .fn<() => Promise<string>>()
+      .mockResolvedValue("success");
+    const onRetry = jest.fn<() => Promise<void>>();
+    const onError = jest
+      .fn<() => string | undefined>()
+      .mockReturnValue(undefined);
+
+    const result = await withRetry<string>(operation, {
+      callbacks: {
+        onRetry,
+        onError,
+      },
+    });
+
+    expect(result).toBe("success");
+    expect(operation).toHaveBeenCalledTimes(1);
+    expect(onRetry).not.toHaveBeenCalled();
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("should retry on failure and then succeed", async () => {
+    const operation = jest
+      .fn<() => Promise<string>>()
+      .mockRejectedValueOnce(new Error("Network error"))
+      .mockRejectedValueOnce(new Error("Network error"))
+      .mockResolvedValue("success");
+
+    const onRetry = jest.fn<() => Promise<void>>();
+    const onError = jest
+      .fn<() => string | undefined>()
+      .mockReturnValue(undefined);
+
+    const promise = withRetry<string>(operation, {
+      callbacks: {
+        onRetry,
+        onError,
+      },
+    });
+
+    jest.runAllTimersAsync();
+
+    const result = await promise;
+
+    expect(result).toBe("success");
+    expect(operation).toHaveBeenCalledTimes(3);
+    expect(onRetry).toHaveBeenCalledTimes(2);
+    expect(onError).toHaveBeenCalledTimes(2);
+  }, 10000);
+
+  it("should fail after max attempts", async () => {
+    let operation = jest.fn<() => Promise<string>>();
+
+    for (let i = 0; i < DEFAULT_RETRY_CONFIG.maxAttempts; i++) {
+      operation = operation.mockRejectedValueOnce(new Error("Network error"));
+    }
+
+    const promise = withRetry<string>(operation);
+
+    jest.runAllTimersAsync();
+
+    await expect(promise).rejects.toThrow("Network error");
+    expect(operation).toHaveBeenCalledTimes(DEFAULT_RETRY_CONFIG.maxAttempts);
+  });
+});

package/src/tests/integration/ssp/static-deposit-validation.test.ts

@@ -71,7 +71,7 @@ describe("SSP static deposit validation tests", () => {
     // Invalid transaction ID
     await expect(
       userWallet.getClaimStaticDepositQuote("invalid-txid", vout!),
-    ).rejects.toThrow("Invalid transaction ID:");
+    ).rejects.toThrow(/InvalidInputException/);
 
     await new Promise((resolve) => setTimeout(resolve, 5000));
 

package/src/tests/integration/transfer.test.ts

@@ -745,7 +745,7 @@ describe.each(walletTypes)(
       //   "should not allow transfer from %s to %s network due to address validation",
       //   async (sourceNetwork, targetNetwork) => {
       //     const sourceOptions: ConfigOptions = {
-      //       network: sourceNetwork,
+      //       network: sourceNetwork
       //     };
       //     const targetOptions: ConfigOptions = {
       //       network: targetNetwork,
@@ -1036,4 +1036,288 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
     const newBalance = await sdk.getBalance();
     expect(newBalance.balance).toBe(1000n);
   });
+
+  it(`${name} - test transfer with retry`, async () => {
+    const faucet = BitcoinFaucet.getInstance();
+
+    const { wallet: sdk } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+      signer: new Signer(),
+    });
+
+    const depositResp = await sdk.getSingleUseDepositAddress();
+    if (!depositResp) {
+      throw new RPCError("Deposit address not found", {
+        method: "getDepositAddress",
+      });
+    }
+
+    const signedTx = await faucet.sendToAddress(depositResp, 1_000n);
+
+    await sdk.claimDeposit(signedTx.id);
+
+    const balance = await sdk.getBalance();
+    expect(balance.balance).toBe(1_000n);
+
+    const { wallet: sdk2 } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+      signer: new Signer(),
+    });
+
+    await sdk.transfer({
+      amountSats: 1000,
+      receiverSparkAddress: await sdk2.getSparkAddress(),
+    });
+
+    const pendingTransfers = await sdk2.queryPendingTransfers();
+    expect(pendingTransfers.transfers.length).toBe(1);
+    const transfer = pendingTransfers.transfers[0]!;
+
+    const originalClaimTransferCore = (sdk2 as any).claimTransferCore.bind(
+      sdk2,
+    );
+    const claimTransferCoreSpy = jest
+      .spyOn(sdk2 as any, "claimTransferCore")
+      .mockRejectedValueOnce(new Error("Network error"))
+      .mockImplementation(async (transfer) => {
+        return await originalClaimTransferCore(transfer);
+      });
+
+    await (sdk2 as any).claimTransfer({ transfer });
+
+    expect(claimTransferCoreSpy).toHaveBeenCalledTimes(2);
+    expect((await sdk2.getBalance()).balance).toBe(1000n);
+  });
+
+  it(`${name} - test claiming already claimed transfer`, async () => {
+    const faucet = BitcoinFaucet.getInstance();
+
+    const { wallet: sdk } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+      signer: new Signer(),
+    });
+
+    const depositResp = await sdk.getSingleUseDepositAddress();
+
+    if (!depositResp) {
+      throw new RPCError("Deposit address not found", {
+        method: "getDepositAddress",
+      });
+    }
+
+    const signedTx = await faucet.sendToAddress(depositResp, 1_000n);
+
+    await sdk.claimDeposit(signedTx.id);
+
+    const balance = await sdk.getBalance();
+    expect(balance.balance).toBe(1_000n);
+
+    const { wallet: sdk2 } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+      signer: new Signer(),
+    });
+
+    await sdk.transfer({
+      amountSats: 1000,
+      receiverSparkAddress: await sdk2.getSparkAddress(),
+    });
+
+    const pendingTransfers = await sdk2.queryPendingTransfers();
+    expect(pendingTransfers.transfers.length).toBe(1);
+    const transfer = pendingTransfers.transfers[0]!;
+
+    await (sdk2 as any).claimTransfer({ transfer });
+
+    const claimTransferCoreSpy = jest.spyOn(sdk2 as any, "claimTransferCore");
+
+    const claim1 = await (sdk2 as any).claimTransfer({
+      transfer: {
+        ...transfer,
+        status: TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAKED,
+      },
+    });
+    expect(claim1.length).toBe(0);
+
+    const claim2 = await (sdk2 as any).claimTransfer({
+      transfer: {
+        ...transfer,
+        status: TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAKED,
+      },
+    });
+    expect(claim2.length).toBe(0);
+
+    const claim3 = await (sdk2 as any).claimTransfer({
+      transfer,
+    });
+
+    expect(claim3.length).toBe(0);
+
+    // Expect 3 because we call claimTransfer 3 times and we expect there to be 0 retries
+    expect(claimTransferCoreSpy).toHaveBeenCalledTimes(3);
+  });
+
+  it(`${name} - test querying updated transfer after error`, async () => {
+    const faucet = BitcoinFaucet.getInstance();
+
+    const options: ConfigOptions = {
+      network: "LOCAL",
+    };
+
+    const { wallet: sdk } = await SparkWalletTesting.initialize({
+      options,
+      signer: new Signer(),
+    });
+
+    const depositResp = await sdk.getSingleUseDepositAddress();
+
+    if (!depositResp) {
+      throw new RPCError("Deposit address not found", {
+        method: "getDepositAddress",
+      });
+    }
+
+    const signedTx = await faucet.sendToAddress(depositResp, 1_000n);
+
+    await sdk.claimDeposit(signedTx.id);
+
+    const balance = await sdk.getBalance();
+    expect(balance.balance).toBe(1_000n);
+
+    const { wallet: sdk2 } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+      signer: new Signer(),
+    });
+
+    const receiverConfigService = new WalletConfigService(
+      options,
+      sdk2.getSigner(),
+    );
+    const receiverConnectionManager = new ConnectionManager(
+      receiverConfigService,
+    );
+    const receiverSigningService = new SigningService(receiverConfigService);
+    const receiverTransferService = new TransferService(
+      receiverConfigService,
+      receiverConnectionManager,
+      receiverSigningService,
+    );
+
+    await sdk.transfer({
+      amountSats: 1000,
+      receiverSparkAddress: await sdk2.getSparkAddress(),
+    });
+
+    const pendingTransfers = await sdk2.queryPendingTransfers();
+    expect(pendingTransfers.transfers.length).toBe(1);
+    const transfer = pendingTransfers.transfers[0]!;
+
+    const leaves: LeafKeyTweak[] = transfer.leaves.map((leaf) => ({
+      leaf: {
+        ...leaf.leaf!,
+        refundTx: leaf.intermediateRefundTx,
+        directRefundTx: leaf.intermediateDirectRefundTx,
+        directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+      },
+      keyDerivation: {
+        type: KeyDerivationType.ECIES,
+        path: leaf.secretCipher,
+      },
+      newKeyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leaf.leaf!.id,
+      },
+    }));
+
+    await receiverTransferService.claimTransferTweakKeys(transfer, leaves);
+
+    const claimTransferCoreSpy = jest.spyOn(sdk2 as any, "claimTransferCore");
+
+    const res = await (sdk2 as any).claimTransfer({ transfer });
+    expect(res.length).toBe(1);
+
+    expect(claimTransferCoreSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it(`${name} - transfer between two wallets that are using different coordinators`, async () => {
+    const faucet = BitcoinFaucet.getInstance();
+
+    const localOperators = Object.values(getLocalSigningOperators());
+    const { wallet: alice } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+        coordinatorIdentifier: localOperators[0]!.identifier,
+      },
+      signer: new Signer(),
+    });
+    const depositResp = await alice.getSingleUseDepositAddress();
+
+    if (!depositResp) {
+      throw new RPCError("Deposit address not found", {
+        method: "getDepositAddress",
+      });
+    }
+
+    const signedTx = await faucet.sendToAddress(depositResp, 1_000n);
+
+    await faucet.mineBlocks(1);
+
+    await alice.claimDeposit(signedTx.id);
+
+    const balance = await alice.getBalance();
+    expect(balance.balance).toBe(1_000n);
+
+    const options: ConfigOptions = {
+      network: "LOCAL",
+      coordinatorIdentifier: localOperators[1]!.identifier,
+    };
+    const { wallet: bob } = await SparkWalletTesting.initialize({
+      options,
+      signer: new Signer(),
+    });
+
+    const bobConfigService = new WalletConfigService(options, bob.getSigner());
+    const bobConnectionManager = new ConnectionManager(bobConfigService);
+    const bobSigningService = new SigningService(bobConfigService);
+
+    const bobTransferService = new TransferService(
+      bobConfigService,
+      bobConnectionManager,
+      bobSigningService,
+    );
+
+    const sparkAddress = await bob.getSparkAddress();
+
+    await alice.transfer({
+      amountSats: 1000,
+      receiverSparkAddress: sparkAddress,
+    });
+
+    const pendingTransfers = await bob.queryPendingTransfers();
+    expect(pendingTransfers.transfers.length).toBe(1);
+    const transfer = pendingTransfers.transfers[0]!;
+
+    const claimingNodes: LeafKeyTweak[] = transfer!.leaves.map((leaf) => ({
+      leaf: leaf.leaf!,
+      keyDerivation: {
+        type: KeyDerivationType.ECIES,
+        path: leaf.secretCipher,
+      },
+      newKeyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leaf.leaf!.id,
+      },
+    }));
+
+    await bobTransferService.claimTransfer(transfer!, claimingNodes);
+  });
 });

package/src/tests/integration/wallet.test.ts

@@ -3,6 +3,18 @@ import { ConfigOptions } from "../../services/wallet-config.js";
 import { NetworkType } from "../../utils/network.js";
 import { walletTypes } from "../test-utils.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
+import { secp256k1, schnorr } from "@noble/curves/secp256k1";
+import { bytesToHex } from "@noble/curves/abstract/utils";
+import type { SparkSigner } from "../../signer/signer.js";
+import type { Transaction } from "@scure/btc-signer";
+import type {
+  AggregateFrostParams,
+  KeyDerivation,
+  SigningCommitmentWithOptionalNonce,
+  SignFrostParams,
+  SplitSecretWithProofsParams,
+} from "../../signer/types.js";
+import type { VerifiableSecretShare } from "../../utils/secret-sharing.js";
 
 describe.each(walletTypes)("wallet", ({ name, Signer }) => {
   it(`${name} - should initialize a wallet`, async () => {
@@ -79,3 +91,151 @@ describe.each(walletTypes)("wallet", ({ name, Signer }) => {
     }
   });
 });
+
+class PreinitializedTestSigner implements SparkSigner {
+  private readonly identityPrivateKey: Uint8Array;
+  private readonly depositPrivateKey: Uint8Array;
+
+  constructor(params?: {
+    identityPrivateKey?: Uint8Array;
+    depositPrivateKey?: Uint8Array;
+  }) {
+    this.identityPrivateKey =
+      params?.identityPrivateKey ?? secp256k1.utils.randomPrivateKey();
+    this.depositPrivateKey =
+      params?.depositPrivateKey ?? secp256k1.utils.randomPrivateKey();
+  }
+
+  async getIdentityPublicKey(): Promise<Uint8Array> {
+    return secp256k1.getPublicKey(this.identityPrivateKey);
+  }
+  async getDepositSigningKey(): Promise<Uint8Array> {
+    return secp256k1.getPublicKey(this.depositPrivateKey);
+  }
+  async getStaticDepositSigningKey(_idx: number): Promise<Uint8Array> {
+    // Not used in this test; return a valid pubkey
+    return secp256k1.getPublicKey(secp256k1.utils.randomPrivateKey());
+  }
+  async getStaticDepositSecretKey(_idx: number): Promise<Uint8Array> {
+    // Not used in this test
+    return secp256k1.utils.randomPrivateKey();
+  }
+
+  async generateMnemonic(): Promise<string> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async mnemonicToSeed(_mnemonic: string): Promise<Uint8Array> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async createSparkWalletFromSeed(
+    _seed: Uint8Array | string,
+    _accountNumber?: number,
+  ): Promise<string> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async getPublicKeyFromDerivation(
+    _keyDerivation?: KeyDerivation,
+  ): Promise<Uint8Array> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+
+  async signSchnorrWithIdentityKey(message: Uint8Array): Promise<Uint8Array> {
+    return schnorr.sign(message, this.identityPrivateKey);
+  }
+
+  async subtractPrivateKeysGivenDerivationPaths(
+    _first: string,
+    _second: string,
+  ): Promise<Uint8Array> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async subtractAndSplitSecretWithProofsGivenDerivations(
+    _params: Omit<SplitSecretWithProofsParams, "secret"> & {
+      first: KeyDerivation;
+      second?: KeyDerivation | undefined;
+    },
+  ): Promise<VerifiableSecretShare[]> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async subtractSplitAndEncrypt(
+    _params: Omit<SplitSecretWithProofsParams, "secret"> & {
+      first: KeyDerivation;
+      second: KeyDerivation;
+      receiverPublicKey: Uint8Array;
+    },
+  ): Promise<{ shares: VerifiableSecretShare[]; secretCipher: Uint8Array }> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async splitSecretWithProofs(
+    _params: SplitSecretWithProofsParams,
+  ): Promise<VerifiableSecretShare[]> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async signFrost(_params: SignFrostParams): Promise<Uint8Array> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+  async aggregateFrost(_params: AggregateFrostParams): Promise<Uint8Array> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+
+  async signMessageWithIdentityKey(
+    message: Uint8Array,
+    compact?: boolean,
+  ): Promise<Uint8Array> {
+    const signature = secp256k1.sign(message, this.identityPrivateKey);
+    return compact ? signature.toCompactRawBytes() : signature.toDERRawBytes();
+  }
+  async validateMessageWithIdentityKey(
+    message: Uint8Array,
+    signature: Uint8Array,
+  ): Promise<boolean> {
+    return secp256k1.verify(
+      signature,
+      message,
+      secp256k1.getPublicKey(this.identityPrivateKey),
+    );
+  }
+
+  signTransactionIndex(
+    _tx: Transaction,
+    _index: number,
+    _publicKey: Uint8Array,
+  ): void {
+    // Not used in this test
+    return;
+  }
+
+  async decryptEcies(_ciphertext: Uint8Array): Promise<Uint8Array> {
+    throw new Error("Not implemented in PreinitializedTestSigner");
+  }
+
+  async getRandomSigningCommitment(): Promise<SigningCommitmentWithOptionalNonce> {
+    // Provide a structurally valid fake commitment
+    const binding = secp256k1.utils.randomPrivateKey();
+    const hiding = secp256k1.utils.randomPrivateKey();
+    return { commitment: { binding, hiding } };
+  }
+}
+
+it("PreinitializedTestSigner - should initialize a wallet without seed using pre-existing keys", async () => {
+  const identityPrivateKey = secp256k1.utils.randomPrivateKey();
+  const signer = new PreinitializedTestSigner({ identityPrivateKey });
+
+  const { wallet } = await SparkWalletTesting.initialize({
+    options: {
+      network: "LOCAL",
+      signerWithPreExistingKeys: true,
+    },
+    signer,
+  });
+
+  expect(wallet).toBeDefined();
+  const identityPubkeyHex = bytesToHex(
+    secp256k1.getPublicKey(identityPrivateKey),
+  );
+  const walletIdentityPubkey = await wallet.getIdentityPublicKey();
+  expect(walletIdentityPubkey).toEqual(identityPubkeyHex);
+
+  const sparkAddress = await wallet.getSparkAddress();
+  expect(sparkAddress).toBeDefined();
+});