@ledgerhq/coin-kaspa 1.1.0-nightly.0

package/src/logic/kaspaAddresses.ts

@@ -0,0 +1,274 @@
+import base32 from "./base32";
+
+export enum ScriptTypeVersion {
+  SCHNORR = 0,
+  ECDSA = 1,
+  P2SH = 8,
+}
+
+type ParsedExtendedPublicKey = {
+  chainCode: Buffer;
+  compressedPublicKey: Buffer;
+  uncompressedPublicKey: Buffer;
+};
+
+export function addressToPublicKey(address: string): { version: number; publicKey: number[] } {
+  const addrPart = address.split(":")[1];
+  const payload = convertBits(base32.decode(addrPart), 5, 8);
+
+  switch (payload[0]) {
+    // for 0 and 8
+    case 0:
+    case 8:
+      return { version: payload[0], publicKey: payload.slice(1, 33) };
+    case 1:
+      // for ECDSA it's one byte more
+      return { version: payload[0], publicKey: payload.slice(1, 34) };
+    default:
+      throw new Error("Unable to translate address to ScriptPublicKey");
+  }
+}
+
+export function publicKeyToAddress(
+  hashBuffer: Buffer,
+  stripPrefix: boolean = false,
+  scriptTypeVersion: ScriptTypeVersion = ScriptTypeVersion.SCHNORR,
+): string {
+  const eight0: number[] = [0, 0, 0, 0, 0, 0, 0, 0];
+  const prefixData: number[] = prefixToArray("kaspa").concat([0]);
+  const versionByte: number = scriptTypeVersion;
+
+  const arr: number[] = Array.from(hashBuffer);
+  const payloadData: number[] = convertBits([versionByte, ...arr], 8, 5);
+  const checksumData: number[] = [...prefixData, ...payloadData, ...eight0];
+  const payload: number[] = [...payloadData, ...checksumToArray(polymod(checksumData))];
+
+  if (stripPrefix) {
+    return base32.encode(payload);
+  } else {
+    return `kaspa:${base32.encode(payload)}`;
+  }
+}
+
+export function addressToScriptPublicKey(address: string): string {
+  const { version, publicKey } = addressToPublicKey(address);
+
+  switch (version) {
+    case 0:
+      return "20" + numArrayToHexString(publicKey) + "ac";
+    case 1:
+      return "21" + numArrayToHexString(publicKey) + "ab";
+    case 8:
+      return "aa20" + numArrayToHexString(publicKey) + "87";
+    default:
+      throw new Error("Address could not be translated to script public key");
+  }
+}
+
+/**
+ * Converts a script public key to a corresponding address.
+ *
+ * @param {string} scriptPublicKey - The script public key to be converted.
+ * @param {boolean} [stripPrefix=false] - Optional flag to determine if the prefix should be stripped from the resulting address.
+ * @return {string} The address derived from the provided script public key.
+ */
+export function scriptPublicKeyToAddress(scriptPublicKey: string, stripPrefix?: boolean): string {
+  // determine version of script public key
+  const version = determineVersionFromScriptPublicKey(scriptPublicKey);
+  const publicKey = Buffer.from(
+    scriptPublicKey.slice(version == ScriptTypeVersion.P2SH ? 4 : 2, -2),
+    "hex",
+  ); // Remove the prefix and suffix
+  return publicKeyToAddress(publicKey, stripPrefix, version);
+}
+
+export function isValidKaspaAddress(address: string): boolean {
+  // Kaspa addresses typically start with 'kaspa:' and are followed by a hexadecimal string
+  const kaspaAddressRegex = new RegExp(`^kaspa:([${base32.CHARSET}]{61}|[${base32.CHARSET}]{63})$`);
+
+  // Check if the address matches the Kaspa format
+  if (!kaspaAddressRegex.test(address)) {
+    return false;
+  }
+
+  // do a round-trip to publickey and back - checks the checksum and all the functionality
+  try {
+    const extractedPublicKey = addressToPublicKey(address);
+    const roundtripAddress: string = publicKeyToAddress(
+      Buffer.from(extractedPublicKey.publicKey),
+      false,
+      extractedPublicKey.version,
+    );
+
+    if (address !== roundtripAddress) {
+      // checksum not valid
+      return false;
+    }
+  } catch (e) {
+    // Unable to translate address to ScriptPublicKey
+    return false;
+  }
+
+  return true;
+}
+
+export function parseExtendedPublicKey(extendedPublicKey: Buffer): ParsedExtendedPublicKey {
+  /**
+   * Converts a full public key to an xPublicKey.
+   *
+   * @param {Buffer} fullPublicKey - The complete public key buffer which includes the chain code.
+   * @returns {Buffer} The xPublicKey obtained by processing the full public key.
+   *
+   * The xPublicKey consists of a single byte y-coordinate parity followed by the first 32 bytes of the x coordinate.
+   */
+  // Validate the length of the extended public key
+  if (extendedPublicKey.length !== 99) {
+    throw new Error("Invalid extended public key length. Expected length is 99 bytes.");
+  }
+  // Index 0 is always 0x41 = (65) the length of the following full public key
+  // Index 66 is always 0x20 = (32) the length of the following chain code
+  const chainCode = Buffer.from(extendedPublicKey.subarray(67, 67 + 32));
+  // x-coord is index [2, 34),
+  // y-coord is index [34, 66)
+  const yCoordParity = extendedPublicKey[65] % 2;
+
+  return {
+    chainCode,
+    compressedPublicKey: Buffer.from([yCoordParity + 2, ...extendedPublicKey.subarray(2, 34)]),
+    uncompressedPublicKey: Buffer.from(extendedPublicKey.subarray(1, 1 + 65)),
+  };
+}
+
+function convertBits(data: number[], from: number, to: number, strict: boolean = false): number[] {
+  const result: number[] = [];
+  let accumulator = 0;
+  let bits = 0;
+  const mask = (1 << to) - 1;
+
+  for (let i = 0; i < data.length; i++) {
+    const value = data[i];
+    if (value < 0 || value >> from !== 0) {
+      throw new Error(`Invalid argument: value = ${value}`);
+    }
+
+    accumulator = (accumulator << from) | value;
+    bits += from;
+    while (bits >= to) {
+      bits -= to;
+      result.push((accumulator >> bits) & mask);
+    }
+  }
+
+  if (!strict) {
+    if (bits > 0) {
+      result.push((accumulator << (to - bits)) & mask);
+    }
+  } else {
+    if (bits > 0 && ((accumulator << (to - bits)) & mask) !== 0) {
+      throw new Error("Conversion requires padding but strict mode was used");
+    }
+  }
+
+  return result;
+}
+
+function prefixToArray(prefix: string): number[] {
+  const result: number[] = [];
+  for (let i = 0; i < prefix.length; i++) {
+    result.push(prefix.charCodeAt(i) & 31);
+  }
+  return result;
+}
+
+function polymod(data: number[]): number {
+  const GENERATOR1: number[] = [0x98, 0x79, 0xf3, 0xae, 0x1e];
+  const GENERATOR2: number[] = [0xf2bc8e61, 0xb76d99e2, 0x3e5fb3c4, 0x2eabe2a8, 0x4f43e470];
+
+  // Split c into two parts: 8 bits (c0) + 32 bits (c1)
+  let c0 = 0;
+  let c1 = 1;
+  let C: number = 0;
+
+  for (let j = 0; j < data.length; j++) {
+    // Set C to c shifted by 35 bits
+    C = c0 >>> 3;
+
+    // Mask the remaining bits of c0 (8 bits)
+    c0 &= 0x07;
+
+    // Shift c0 as a whole number
+    c0 <<= 5;
+    c0 |= c1 >>> 27;
+
+    // Mask the remaining bits of c1 (27 bits)
+    c1 &= 0x07ffffff;
+
+    // Shift c1 and add current data value
+    c1 <<= 5;
+    c1 ^= data[j];
+
+    // Perform XOR operations with GENERATOR arrays
+    for (let i = 0; i < GENERATOR1.length; ++i) {
+      if (C & (1 << i)) {
+        c0 ^= GENERATOR1[i];
+        c1 ^= GENERATOR2[i];
+      }
+    }
+  }
+
+  // Final XOR operation on c1
+  c1 ^= 1;
+
+  // Handle negative numbers to ensure it becomes a large positive number
+  if (c1 < 0) {
+    c1 ^= 1 << 31;
+    c1 += (1 << 30) * 2;
+  }
+
+  // Return the final result
+  return c0 * (1 << 30) * 4 + c1;
+}
+
+function checksumToArray(checksum: number): number[] {
+  const result: number[] = [];
+  for (let i = 0; i < 8; ++i) {
+    result.push(checksum & 31); // Extract the last 5 bits
+    checksum = Math.floor(checksum / 32); // Ensure integer division
+  }
+  return result.reverse();
+}
+
+// Function to determine the version based on the scriptPublicKey string
+function determineVersionFromScriptPublicKey(scriptPublicKey: string): ScriptTypeVersion {
+  if (
+    scriptPublicKey.startsWith("20") &&
+    scriptPublicKey.endsWith("ac") &&
+    scriptPublicKey.length == 68
+  ) {
+    return ScriptTypeVersion.SCHNORR;
+  } else if (
+    scriptPublicKey.startsWith("21") &&
+    scriptPublicKey.endsWith("ab") &&
+    scriptPublicKey.length === 70
+  ) {
+    return ScriptTypeVersion.ECDSA;
+  } else if (
+    scriptPublicKey.startsWith("aa20") &&
+    scriptPublicKey.endsWith("87") &&
+    scriptPublicKey.length === 70
+  ) {
+    return ScriptTypeVersion.P2SH;
+  }
+
+  throw new Error("Script public key version could not be determined.");
+}
+
+function numArrayToHexString(numArray: number[] = []): string {
+  const hexArr = [];
+
+  for (const num of numArray) {
+    hexArr.push(("00" + num.toString(16)).slice(-2));
+  }
+
+  return hexArr.join("");
+}

package/src/logic/massCalcluation.ts

@@ -0,0 +1,50 @@
+import { BigNumber } from "bignumber.js";
+import { sumBigNumber } from "./utxos/lib";
+
+const C: BigNumber = BigNumber(10 ** 12);
+
+// if one output is ECDSA, scriptPubKey is one byte longer
+// which ends up in 11g mass ( 1 byte + 10g MASS_PER_SCRIPT_PUB_KEY_BYTE )
+const ADDTIONAL_MASS_FOR_ECDSA_OUTPUT = 11;
+
+// note: this is an easy version of computeMass for Ledger only.
+// it has usual inputs with regular Script and one or two outputs
+export function calcComputeMass(
+  inputCount: number,
+  isChangeAddress: boolean,
+  recipientIsECDSA: boolean = false,
+): number {
+  // 506 for one output, 918 for two outputs
+  let mass: number = isChangeAddress ? 918 : 506;
+
+  // per used utxo mass increases by 1118
+  mass += inputCount * 1118;
+
+  // is output address is ECDSA, the mass is 11g higher
+  if (recipientIsECDSA) {
+    mass += ADDTIONAL_MASS_FOR_ECDSA_OUTPUT;
+  }
+
+  return mass;
+}
+
+function _negative_mass(inputs: BigNumber[], outputsNum: number): number {
+  const inputsNum = inputs.length;
+  if (outputsNum === 1 || inputsNum === 1 || (outputsNum === 2 && inputsNum === 2)) {
+    return sumBigNumber(inputs.map(v => C.div(v).integerValue(BigNumber.ROUND_FLOOR))).toNumber();
+  }
+  return (
+    inputsNum *
+    C.div(sumBigNumber(inputs).div(BigNumber(inputsNum)).integerValue(BigNumber.ROUND_FLOOR))
+      .integerValue(BigNumber.ROUND_FLOOR)
+      .toNumber()
+  );
+}
+
+export function calcStorageMass(inputs: BigNumber[], outputs: BigNumber[]): number {
+  const N: number = _negative_mass(inputs, outputs.length);
+  const P: number = sumBigNumber(
+    outputs.map(v => C.div(v).integerValue(BigNumber.ROUND_FLOOR)),
+  ).toNumber();
+  return Math.max(P - N, 0);
+}

package/src/logic/scanAddresses.ts

@@ -0,0 +1,173 @@
+import { BigNumber } from "bignumber.js";
+import { AccountAddress, AccountAddresses } from "../types";
+import KaspaBIP32 from "./bip32";
+import { getAddressesActive, getBalancesForAddresses } from "../network";
+
+// Constants to improve clarity
+const RECEIVE_ADDRESS_TYPE = 0;
+const CHANGE_ADDRESS_TYPE = 1;
+const INITIAL_BALANCE = BigNumber(0);
+const GAP_LIMIT = 20;
+const SCAN_BATCH_SIZE = 200;
+
+const MAX_TX_INPUTS = 88; // floor (( 100_000 - 918 (def_size with 2 outputs) ) / 1_118 (per_input))
+
+/**
+ * Scans the addresses for an account and retrieves information such as used addresses and the total balance.
+ *
+ * @param {Buffer} compressedPublicKey - The compressed public key used for address derivation.
+ * @param {Buffer} chainCode - The chain code used for address derivation.
+ * @param {number} [startIndex=0] - The starting index for address scanning.
+ * @return {Promise<AccountAddresses>} - A promise that resolves to an AccountAddresses object containing used addresses and balance information.
+ */
+export async function scanAddresses(
+  compressedPublicKey: Buffer,
+  chainCode: Buffer,
+  startIndex: number,
+): Promise<AccountAddresses> {
+  const kaspaBip32: KaspaBIP32 = new KaspaBIP32(compressedPublicKey, chainCode);
+
+  const accountAddresses: AccountAddresses = {
+    usedReceiveAddresses: [],
+    usedChangeAddresses: [],
+    nextChangeAddress: {
+      type: 0,
+      index: 0,
+      address: "",
+      balance: INITIAL_BALANCE,
+      active: false,
+      timestamp: null,
+    },
+    nextReceiveAddress: {
+      type: 0,
+      index: 0,
+      address: "",
+      balance: INITIAL_BALANCE,
+      active: false,
+      timestamp: null,
+    },
+    totalBalance: BigNumber(0),
+    spendableBalance: BigNumber(0),
+  };
+
+  // need to check UTXOs and TX history for the first account addresses
+
+  // go through receive address and change address
+  for (const type of [RECEIVE_ADDRESS_TYPE, CHANGE_ADDRESS_TYPE]) {
+    let keepScanning: boolean = true;
+
+    while (keepScanning) {
+      const addresses: AccountAddress[] = [];
+      for (let index = startIndex; index < startIndex + SCAN_BATCH_SIZE; index++) {
+        const derivedAddress: string = kaspaBip32.getAddress(type, index);
+        addresses.push({
+          type: type,
+          index,
+          address: derivedAddress,
+          balance: BigNumber(0),
+          active: false,
+        } as AccountAddress);
+      }
+
+      // fetch address information via API and update object
+      await updateAddressesActive(addresses);
+
+      // update balance
+      for (const addr of addresses) {
+        accountAddresses.totalBalance = accountAddresses.totalBalance.plus(addr.balance);
+      }
+
+      // Check the last GAP_LIMIT addresses for inactivity ( active = false )
+      const lastAddressesToCheck = addresses.slice(-GAP_LIMIT);
+
+      keepScanning = !lastAddressesToCheck.every(addr => !addr.active);
+      if (keepScanning) startIndex += SCAN_BATCH_SIZE;
+
+      updateAddressesData(addresses, accountAddresses, type, keepScanning);
+    }
+  }
+
+  const spendableBalance = [
+    ...accountAddresses.usedChangeAddresses,
+    ...accountAddresses.usedReceiveAddresses,
+  ]
+    .sort((a, b) => b.balance.minus(a.balance).toNumber())
+    .slice(0, MAX_TX_INPUTS)
+    .map(utxo => utxo.balance)
+    .reduce((acc, v) => acc.plus(v), BigNumber(0));
+
+  accountAddresses.spendableBalance = spendableBalance;
+
+  return accountAddresses;
+}
+
+/**
+ * Updates the addresses data based on the type and current scanning state.
+ * If the type is RECEIVE_ADDRESS_TYPE, it updates the used receive addresses and sets the next receive address.
+ * If the type is CHANGE_ADDRESS_TYPE, it updates the used change addresses and sets the next change address.
+ *
+ * @param {AccountAddress[]} addresses - List of account addresses.
+ * @param {AccountAddresses} accountAddresses - Object containing used receive and change addresses and the next addresses.
+ * @param {number} type - Type of the addresses being updated. It can be either RECEIVE_ADDRESS_TYPE or CHANGE_ADDRESS_TYPE.
+ * @param {boolean} keepScanning - Indicates whether to keep scanning for addresses or not.
+ * @return {void}
+ */
+function updateAddressesData(
+  addresses: AccountAddress[],
+  accountAddresses: AccountAddresses,
+  type: number,
+  keepScanning: boolean,
+): void {
+  if (type === RECEIVE_ADDRESS_TYPE) {
+    accountAddresses.usedReceiveAddresses.push(...addresses.filter(addr => addr.active));
+
+    if (!keepScanning) {
+      // last used address + 1
+      // + 1 has to be available, as there needs to be a GAP!
+      accountAddresses.nextReceiveAddress =
+        addresses[
+          addresses.indexOf(<AccountAddress>accountAddresses.usedReceiveAddresses.at(-1)) + 1
+        ];
+    }
+  }
+  // change address
+  if (type === CHANGE_ADDRESS_TYPE) {
+    accountAddresses.usedChangeAddresses.push(...addresses.filter(addr => addr.active));
+
+    if (!keepScanning) {
+      // last used address + 1
+      // + 1 has to be available, as there needs to be a GAP!
+      accountAddresses.nextChangeAddress =
+        addresses[
+          addresses.indexOf(<AccountAddress>accountAddresses.usedChangeAddresses.at(-1)) + 1
+        ];
+    }
+  }
+}
+
+/**
+ * Updates the provided array of addresses with their respective balances and active status.
+ *
+ * @param {AccountAddress[]} addresses - An array of account addresses to be updated.
+ * @return {Promise<void>} A promise that resolves when the update operation is complete.
+ */
+async function updateAddressesActive(addresses: AccountAddress[]) {
+  const balances = await getBalancesForAddresses(addresses.map(addr => addr.address));
+  const addressesActive = await getAddressesActive(addresses.map(addr => addr.address));
+
+  for (const addressBalance of balances) {
+    const addressIndex = addresses.findIndex(addr => addr.address === addressBalance.address);
+    if (addressBalance.balance > 0) {
+      addresses[addressIndex].balance = BigNumber(addressBalance.balance);
+      addresses[addressIndex].active = true;
+    }
+  }
+
+  for (const addressActive of addressesActive) {
+    const addressIndex = addresses.findIndex(addr => addr.address === addressActive.address);
+    if (addressActive.active) {
+      addresses[addressIndex].active = true;
+      addresses[addressIndex].timestamp = addressActive.lastTxBlockTime;
+    }
+  }
+}

package/src/logic/scanOperations.ts

@@ -0,0 +1,59 @@
+import { Operation, OperationType } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { getAllTransactions } from "./getAllTransactions";
+
+export async function scanOperations(
+  addresses: string[],
+  accountId: string,
+  afterValue: number = 1,
+): Promise<Operation[]> {
+  const operations: Operation[] = [];
+
+  const fetchedTxs = await Promise.all(
+    addresses.map(addr => getAllTransactions(addr, afterValue)),
+  ).then(results => results.flat());
+
+  for (const tx of fetchedTxs) {
+    const myInputAmount: BigNumber = tx.inputs.reduce((acc: BigNumber, v): BigNumber => {
+      if (addresses.includes(v.previous_outpoint_address)) {
+        return acc.plus(BigNumber(v.previous_outpoint_amount));
+      }
+      return acc;
+    }, BigNumber(0));
+
+    const myOutputAmount: BigNumber = tx.outputs.reduce((acc: BigNumber, v) => {
+      if (addresses.includes(v.script_public_key_address)) {
+        return acc.plus(BigNumber(v.amount));
+      }
+      return acc;
+    }, BigNumber(0));
+
+    const totalOutputAmount: BigNumber = tx.outputs.reduce(
+      (acc: BigNumber, v) => acc.plus(BigNumber(v.amount)),
+      BigNumber(0),
+    );
+    const totalInputAmount: BigNumber = tx.inputs.reduce(
+      (acc: BigNumber, v) => acc.plus(BigNumber(v.previous_outpoint_amount)),
+      BigNumber(0),
+    );
+
+    const operationType: OperationType = myOutputAmount.gt(myInputAmount) ? "IN" : "OUT";
+
+    operations.push({
+      id: tx.transaction_id,
+      hash: tx.transaction_id,
+      type: operationType,
+      value: myOutputAmount.minus(myInputAmount).absoluteValue(),
+      fee: totalInputAmount.minus(totalOutputAmount),
+      senders: tx.inputs.map(inp => inp.previous_outpoint_address),
+      recipients: tx.outputs.map(output => output.script_public_key_address),
+      blockHeight: tx.accepting_block_blue_score,
+      blockHash: tx.block_hash[0],
+      accountId: accountId,
+      date: new Date(tx.block_time),
+      extra: {},
+    } as Operation);
+  }
+
+  return operations;
+}

package/src/logic/scanUtxos.ts

@@ -0,0 +1,44 @@
+import { BigNumber } from "bignumber.js";
+import { AccountAddress, AccountAddresses, KaspaUtxo } from "../types";
+import { getUtxosForAddresses } from "../network";
+import { scanAddresses } from "./scanAddresses";
+
+export async function scanUtxos(
+  compressedPublicKey: Buffer,
+  chainCode: Buffer,
+): Promise<{ utxos: KaspaUtxo[]; accountAddresses: AccountAddresses }> {
+  const accountAddresses: AccountAddresses = await scanAddresses(compressedPublicKey, chainCode, 0);
+
+  const allUsedAddresses = [
+    ...accountAddresses.usedReceiveAddresses,
+    ...accountAddresses.usedChangeAddresses,
+  ];
+
+  const utxoResponse = await getUtxosForAddresses(allUsedAddresses.map(addrObj => addrObj.address));
+
+  const kaspaUtxos = utxoResponse.map(utxo => {
+    return {
+      ...utxo,
+      ...getTypeAndIndexFromAccountAddresses(allUsedAddresses, utxo.address),
+    };
+  });
+
+  // Convert utxoEntry.amount to BigNumber
+  kaspaUtxos.forEach(utxo => {
+    utxo.utxoEntry.amount = BigNumber(utxo.utxoEntry.amount);
+  });
+
+  return {
+    utxos: kaspaUtxos as KaspaUtxo[],
+    accountAddresses: accountAddresses,
+  };
+}
+
+function getTypeAndIndexFromAccountAddresses(accountAddreses: AccountAddress[], address: string) {
+  const foundAddress = accountAddreses.find(addr => addr.address === address);
+  if (foundAddress) {
+    return { accountType: foundAddress.type, accountIndex: foundAddress.index };
+  } else {
+    throw new Error(`Address ${address} not found in addresses set.`);
+  }
+}

package/src/logic/tests/bip32.test.ts

@@ -0,0 +1,78 @@
+import KaspaBIP32 from "../bip32";
+
+describe("KaspaBIP32", () => {
+  it("should generate the expected addresses", () => {
+    // These addresses were generated from the ledger device, whose public key and chain code
+    // for 44'/111111'/0' are:
+    // public key (compressed): 035a19ab1842af431d3b4fa88a15b1fe7d7c3f6e26e808124a10dc0523352d462d
+    // chain code: 0ba599a9c5bad1106065eab47b48efa070f4b31e9639c9d096f7756b248a6ff4
+    const testCases = [
+      {
+        derivationPath: "44'/111111'/0'/0/0",
+        address: "kaspa:qzese5lc37m2a9np8k5gect4l2jj8svyqq392p7aa7mxsqarjg9sjgxr4wvru",
+      },
+      {
+        derivationPath: "44'/111111'/0'/0/1",
+        address: "kaspa:qqdpnpjcqmzntn4z4y082t5jjvn7rv2wejfy38ljnjvreyg3d7jwv4uj86vlt",
+      },
+      {
+        derivationPath: "44'/111111'/0'/1/0",
+        address: "kaspa:qzvqsl48dyhu7wy8jxklwa9n9gwyprq44xsmylnhzxlmhzarfd6vwrrjuekuw",
+      },
+      {
+        derivationPath: "44'/111111'/0'/1/1",
+        address: "kaspa:qza444ye2lt384jl4u9jf8kd2pe4m2yr44nq9u5g5ush8qzlskaauh2mk4ezp",
+      },
+    ];
+
+    const compressedPublicKey = Buffer.from(
+      "035a19ab1842af431d3b4fa88a15b1fe7d7c3f6e26e808124a10dc0523352d462d",
+      "hex",
+    );
+    const chainCode = Buffer.from(
+      "0ba599a9c5bad1106065eab47b48efa070f4b31e9639c9d096f7756b248a6ff4",
+      "hex",
+    );
+    const bip32 = new KaspaBIP32(compressedPublicKey, chainCode);
+
+    for (const testCase of testCases) {
+      const path = testCase.derivationPath.split("/");
+      expect(bip32.getAddress(Number(path[3]), Number(path[4]))).toBe(testCase.address);
+    }
+
+    expect(bip32.getAddress()).toBe(
+      "kaspa:qzese5lc37m2a9np8k5gect4l2jj8svyqq392p7aa7mxsqarjg9sjgxr4wvru",
+    );
+  });
+  it("result from ledger hw device", () => {
+    const testCases = [
+      {
+        derivationPath: "44'/111111'/1'/0/0",
+        address: "kaspa:qzcluxxl05wgr8f3aw2rnwy9jt8cfdv0kucyv4hye7g4eswk5ws7y532cnfua",
+      },
+      {
+        derivationPath: "44'/111111'/1'/0/1",
+        address: "kaspa:qp6xh8tsgsd7yhkkk3m37rfqcdmmj4k0ca9ewtfm48p9g5uxdjexgq9h0xrjc",
+      },
+      {
+        derivationPath: "44'/111111'/1'/1/1",
+        address: "kaspa:qrzw7k2sxahz67kzs2vdmktvmgjc6tx6j8xas7ltx7utg4uyz83ucpf9mv0xz",
+      },
+    ];
+
+    const compressedPublicKey = Buffer.from(
+      "02bb257a3f0b6bc2104539be649e6f7fe0b42e38c660500598fb1dc833b7ecbb1a",
+      "hex",
+    );
+    const chainCode = Buffer.from(
+      "27a38ef4c76455946be71692ee422b1fc40dc30952a8bf1ce961a534476035c8",
+      "hex",
+    );
+    const bip32 = new KaspaBIP32(compressedPublicKey, chainCode);
+
+    for (const testCase of testCases) {
+      const path = testCase.derivationPath.split("/");
+      expect(bip32.getAddress(Number(path[3]), Number(path[4]))).toBe(testCase.address);
+    }
+  });
+});