@ledgerhq/coin-kaspa 1.1.0-nightly.0

package/src/bridge/index.ts

@@ -0,0 +1,106 @@
+import {
+  getSerializedAddressParameters,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { AccountBridge, CurrencyBridge, DerivationMode } from "@ledgerhq/types-live";
+import getAddressWrapper, { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+
+import type { KaspaAccount, Transaction, TransactionStatus } from "../types";
+import { KaspaSigner } from "../types";
+
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import getTransactionStatus from "./getTransactionStatus";
+import { getAccountShape } from "./synchronization";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import { updateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { broadcast } from "./broadcast";
+import { initAccount } from "./initAccount";
+import resolver from "../hw-getAddress";
+import { buildSignOperation } from "./signOperation";
+import { Result, runDerivationScheme } from "@ledgerhq/coin-framework/derivation";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+function buildCurrencyBridge(signerContext: SignerContext<KaspaSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+    buildIterateResult: kaspaIterateResultBuilder(getAddress),
+  });
+
+  return {
+    preload: async () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+const kaspaIterateResultBuilder = (getAddressFn: GetAddressFn) => () =>
+  Promise.resolve(
+    async ({
+      index,
+      derivationsCache,
+      derivationScheme,
+      derivationMode,
+      currency,
+      deviceId,
+    }: {
+      index: number | string;
+      derivationsCache: Record<string, Result>;
+      derivationScheme: string;
+      derivationMode: DerivationMode;
+      currency: CryptoCurrency;
+      deviceId: string;
+    }): Promise<Result | null> => {
+      const accountPath = derivationScheme.split("/").slice(0, 3).join("/");
+      const freshAddressPath = runDerivationScheme(accountPath, currency, {
+        account: index,
+      });
+      let res = derivationsCache[freshAddressPath];
+      if (!res) {
+        res = await getAddressWrapper(getAddressFn)(deviceId, {
+          currency,
+          path: freshAddressPath,
+          derivationMode,
+        });
+        derivationsCache[freshAddressPath] = res;
+      }
+      return res as Result;
+    },
+  );
+
+function buildAccountBridge(
+  signerContext: SignerContext<KaspaSigner>,
+): AccountBridge<Transaction, KaspaAccount, TransactionStatus> {
+  const getAddress = resolver(signerContext);
+
+  const sync = makeSync({ getAccountShape });
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    getSerializedAddressParameters,
+    createTransaction,
+    updateTransaction,
+    prepareTransaction,
+    getTransactionStatus,
+    sync,
+    receive,
+    initAccount,
+    signOperation,
+    broadcast,
+    estimateMaxSpendable,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<KaspaSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/initAccount.ts

@@ -0,0 +1 @@
+export function initAccount(): void {}

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,48 @@
+import { ApiResponseFeeEstimate, KaspaAccount, Transaction } from "../types";
+import { getFeeEstimate } from "../network";
+import BigNumber from "bignumber.js";
+
+/**
+ * Prepares a transaction by calculating and setting its fee based on the specified fee strategy.
+ *
+ * @param {KaspaAccount} account - The account for which the transaction is being prepared.
+ * @param {Transaction} transaction - The transaction object that needs to be prepared.
+ *
+ * @returns {Promise<Transaction>} The prepared transaction with the appropriate fees set.
+ *
+ * @throws Will throw an error if the fee strategy type is unknown.
+ */
+export const prepareTransaction = async (account: KaspaAccount, transaction: Transaction) => {
+  const fees: ApiResponseFeeEstimate = await getFeeEstimate();
+
+  transaction.networkInfo = [
+    {
+      label: "slow",
+      amount: BigNumber(fees.lowBuckets[0]?.feerate || 1),
+      estimatedSeconds: fees.lowBuckets[0]?.estimatedSeconds,
+    },
+    {
+      label: "medium",
+      amount: BigNumber(fees.normalBuckets[0]?.feerate || 1),
+      estimatedSeconds: fees.normalBuckets[0]?.estimatedSeconds,
+    },
+    {
+      label: "fast",
+      amount: BigNumber(fees.priorityBucket.feerate),
+      estimatedSeconds: fees.priorityBucket.estimatedSeconds,
+    },
+  ];
+
+  if (
+    transaction.networkInfo.every(
+      info => info.estimatedSeconds === transaction.networkInfo[0].estimatedSeconds,
+    ) &&
+    transaction.feesStrategy !== "custom"
+  ) {
+    transaction.feesStrategy = "fast";
+  }
+
+  return transaction;
+};
+
+export default prepareTransaction;

package/src/bridge/signOperation.ts

@@ -0,0 +1,43 @@
+import { Observable } from "rxjs";
+import type { AccountBridge, SignOperationEvent } from "@ledgerhq/types-live";
+
+import { buildTransaction } from "./buildTransaction";
+import { KaspaAccount, KaspaSigner, Transaction } from "../types";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import buildInitialOperation from "./buildInitialOperation";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<KaspaSigner>,
+  ): AccountBridge<Transaction, KaspaAccount>["signOperation"] =>
+  ({ account, deviceId, transaction }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      async function main() {
+        o.next({
+          type: "device-signature-requested",
+        });
+
+        const tx = await buildTransaction(account, transaction);
+
+        // Sign by device
+        await signerContext(deviceId, signer => signer.signTransaction(tx));
+
+        o.next({ type: "device-signature-granted" });
+        const operation = buildInitialOperation(account, tx);
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: JSON.stringify(tx.toApiJSON()),
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/synchronization.ts

@@ -0,0 +1,80 @@
+import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { AccountAddresses, KaspaAccount } from "../types";
+import { Operation } from "@ledgerhq/types-live";
+import { parseExtendedPublicKey, scanAddresses, scanOperations } from "../logic";
+import { getBlockDagInfo, getVirtualChainBlueScore } from "../network";
+
+export const getAccountShape: GetAccountShape<KaspaAccount> = async info => {
+  const { initialAccount, index, rest } = info;
+
+  const xpub =
+    rest?.publicKey || (initialAccount && decodeAccountId(initialAccount.id).xpubOrAddress);
+
+  // // Needed for incremental synchronisation
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: "kaspa",
+    xpubOrAddress: xpub,
+    derivationMode: "",
+  });
+
+  const { compressedPublicKey, chainCode } = parseExtendedPublicKey(Buffer.from(xpub, "hex"));
+
+  const accountAddresses: AccountAddresses = await scanAddresses(compressedPublicKey, chainCode, 0);
+
+  const oldOperations = initialAccount?.operations || [];
+
+  // Fetch new operations
+  // Timestamp with 60s buffer to make sure there's no gap
+  let scanOperationsAfter: number = 1; // begin with after=1 for correct TX fetching
+  if (initialAccount?.lastSyncTimestamp) {
+    // as older blocks with valid transactions can be added into the BlockDAG up to an hour later,
+    // we have to set the rescan timestamp to around 2 hours earlier than the last tip's timestamp.
+    scanOperationsAfter = initialAccount.lastSyncTimestamp - 60 * 60 * 2 * 1000; // milliseconds timestamp
+    scanOperationsAfter = Math.max(scanOperationsAfter, 1); // actually it can't really be lower than 1.
+  }
+
+  const usedAddresses: string[] = [
+    ...accountAddresses.usedReceiveAddresses
+      .filter(addr => addr.timestamp! > scanOperationsAfter)
+      .map(addr => addr.address),
+    ...accountAddresses.usedChangeAddresses
+      .filter(addr => addr.timestamp! > scanOperationsAfter)
+      .map(addr => addr.address),
+  ];
+
+  const allOperations: Operation[] = await scanOperations(
+    usedAddresses,
+    accountId,
+    scanOperationsAfter,
+  );
+  const operations = mergeOps(oldOperations, allOperations);
+
+  const activeAddressCount: number =
+    accountAddresses.usedReceiveAddresses.filter(address => address.balance.gt(0)).length +
+    accountAddresses.usedChangeAddresses.filter(address => address.balance.gt(0)).length;
+
+  return {
+    id: accountId,
+    xpub: xpub,
+    lastSyncTimestamp: Number.parseInt((await getBlockDagInfo()).pastMedianTime || "1"),
+    index,
+    blockHeight: await getVirtualChainBlueScore(),
+    balance: accountAddresses.totalBalance,
+    spendableBalance: accountAddresses.spendableBalance,
+    operations,
+    operationsCount: operations.length,
+    nextChangeAddressIndex: accountAddresses.nextChangeAddress.index,
+    nextChangeAddressType: accountAddresses.nextChangeAddress.type,
+    nextChangeAddress: accountAddresses.nextChangeAddress.address,
+    nextReceiveAddressIndex: accountAddresses.nextReceiveAddress.index,
+    nextReceiveAddressType: accountAddresses.nextReceiveAddress.type,
+    nextReceiveAddress: accountAddresses.nextReceiveAddress.address,
+    activeAddressCount: activeAddressCount,
+    freshAddress: accountAddresses.nextReceiveAddress.address,
+    freshAddressPath: `44'/111111'/${index}'/${accountAddresses.nextReceiveAddress.type}/${accountAddresses.nextReceiveAddress.index}`,
+    used: operations.length > 0,
+  };
+};

package/src/config.ts

@@ -0,0 +1,7 @@
+import buildConConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type KaspaCoinConfig = CurrencyConfig;
+
+const coinConfig = buildConConfig<KaspaCoinConfig>();
+
+export default coinConfig;

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,44 @@
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "./types";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+
+function getDeviceTransactionConfig({
+  transaction,
+  status: { estimatedFees },
+}: {
+  account: AccountLike;
+  parentAccount?: Account;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+
+  if (transaction.useAllAmount) {
+    fields.push({
+      type: "text",
+      label: "Method",
+      value: "Transfer All",
+    });
+  } else {
+    fields.push({
+      type: "text",
+      label: "Method",
+      value: "Transfer",
+    });
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  if (!estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fees",
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/errors.ts

@@ -0,0 +1,6 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const UnsupportedDerivation = createCustomErrorClass("UnsupportedDerivation");
+
+/** When a coin-module has no CoinConfig setted */
+export const MissingCoinConfig = createCustomErrorClass("MissingCoinConfig");

package/src/hw-getAddress.ts

@@ -0,0 +1,17 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { KaspaSigner } from "./types";
+
+const resolver = (signerContext: SignerContext<KaspaSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const r = await signerContext(deviceId, signer => signer.getAddress(path, verify || false));
+    return {
+      address: r.address,
+      publicKey: r.publicKey,
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./types";

package/src/logic/base32.ts

@@ -0,0 +1,100 @@
+"use strict";
+/***
+ * https://github.com/bitcoincashjs/cashaddr
+ * Copyright (c) 2018 Matias Alejo Garcia
+ * Copyright (c) 2017 Emilio Almansi
+ * Distributed under the MIT software license, see the accompanying
+ * file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+ */
+
+/***
+ * Charset containing the 32 symbols used in the base32 encoding.
+ */
+export const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+
+/***
+ * Inverted index mapping each symbol into its index within the charset.
+ */
+const CHARSET_INVERSE_INDEX = {
+  q: 0,
+  p: 1,
+  z: 2,
+  r: 3,
+  y: 4,
+  9: 5,
+  x: 6,
+  8: 7,
+  g: 8,
+  f: 9,
+  2: 10,
+  t: 11,
+  v: 12,
+  d: 13,
+  w: 14,
+  0: 15,
+  s: 16,
+  3: 17,
+  j: 18,
+  n: 19,
+  5: 20,
+  4: 21,
+  k: 22,
+  h: 23,
+  c: 24,
+  e: 25,
+  6: 26,
+  m: 27,
+  u: 28,
+  a: 29,
+  7: 30,
+  l: 31,
+};
+
+/***
+ * Encodes the given array of 5-bit integers as a base32-encoded string.
+ *
+ * @param {Array} data Array of integers between 0 and 31 inclusive.
+ */
+export function encode(data: number[]) {
+  if (!(data instanceof Array)) {
+    throw new Error("Must be Array");
+  }
+  let base32 = "";
+  for (let i = 0; i < data.length; i++) {
+    const value = data[i];
+    if (!(0 <= value && value < 32)) {
+      throw new Error("value " + value);
+    }
+    base32 += CHARSET[value];
+  }
+  return base32;
+}
+
+/***
+ * Decodes the given base32-encoded string into an array of 5-bit integers.
+ *
+ * @param {string} base32
+ */
+export function decode(base32: string) {
+  if (typeof base32 !== "string") {
+    throw new Error("Must be base32-encoded string");
+  }
+  const data = [];
+  for (let i = 0; i < base32.length; i++) {
+    const value = base32[i];
+    if (!(value in CHARSET_INVERSE_INDEX)) {
+      throw new Error("value " + value);
+    }
+    // @ts-expect-error: ignore array of any
+    data.push(CHARSET_INVERSE_INDEX[value]);
+  }
+  return data;
+}
+
+const base32 = {
+  encode,
+  decode,
+  CHARSET,
+};
+
+export default base32;

package/src/logic/bip32.ts

@@ -0,0 +1,21 @@
+import ecc from "@bitcoinerlab/secp256k1";
+import BIP32Factory, { BIP32API, BIP32Interface } from "bip32";
+import { publicKeyToAddress } from "./kaspaAddresses";
+
+const bip32: BIP32API = BIP32Factory(ecc);
+
+export default class KaspaBIP32 {
+  rootNode: BIP32Interface;
+
+  constructor(compressedPublicKey: Buffer, chainCode: Buffer) {
+    this.rootNode = bip32.fromPublicKey(compressedPublicKey, chainCode);
+  }
+
+  getAddress(type: number = 0, index: number = 0) {
+    const child = this.rootNode.derivePath(`${type}/${index}`);
+
+    // child.publicKey is a compressed public key
+    const publicKeyBuffer: Buffer = Buffer.from(child.publicKey.subarray(1, 33));
+    return publicKeyToAddress(publicKeyBuffer, false);
+  }
+}

package/src/logic/getAllTransactions.ts

@@ -0,0 +1,22 @@
+import { getTransactions } from "../network";
+import { ApiResponseTransaction } from "../types";
+
+export const getAllTransactions = async (
+  addr: string,
+  afterValue: number,
+): Promise<ApiResponseTransaction[]> => {
+  if (afterValue === 0) {
+    afterValue = 1;
+  }
+
+  let allTransactions: ApiResponseTransaction[] = [];
+
+  let nextPageAfter: string | null = afterValue.toString();
+  while (nextPageAfter) {
+    const response = await getTransactions(addr, parseInt(nextPageAfter));
+    allTransactions = allTransactions.concat(response.transactions);
+    nextPageAfter = response.nextPageAfter;
+  }
+
+  return allTransactions;
+};

package/src/logic/getFeeRate.ts

@@ -0,0 +1,20 @@
+import { Transaction } from "../types";
+import { BigNumber } from "bignumber.js";
+
+export const getFeeRate = (transaction: Transaction | null | undefined): BigNumber => {
+  if (!transaction) {
+    return BigNumber(0);
+  }
+  if (transaction.feesStrategy === "custom") {
+    return transaction.customFeeRate || BigNumber(0);
+  }
+  const filteredNetworkInfo = transaction.networkInfo.filter(
+    ni => ni.label === transaction.feesStrategy,
+  );
+
+  if (filteredNetworkInfo.length === 0) {
+    throw new Error("Invalid fee strategy provided");
+  }
+
+  return filteredNetworkInfo[0].amount;
+};

package/src/logic/index.ts

@@ -0,0 +1,10 @@
+export * from "./scanAddresses";
+export * from "./scanUtxos";
+export * from "./scanOperations";
+export * from "./kaspaAddresses";
+export * from "./massCalcluation";
+export * from "./base32";
+export * from "./bip32";
+export * from "./utxos/lib";
+export * from "./utxos/selection";
+export * from "./getFeeRate";