@ledgerhq/coin-kaspa 1.1.0-nightly.0

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,47 @@
+import { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+
+const kaspa: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "kaspa seed 1",
+      apdus: `
+      => e00500000d038000002c8001b20780000000
+      <= 41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a55769000
+      => e00500000d038000002c8001b20780000001
+      <= 4104751b5ebd4a9d2a0a25d5c37cab4814a95335b8945cfcaa6a4138de418f581bb1d0d02f22081b3cda223a51e18a63ebdffd64803e0988b68a91802738a5a9f901206d4a2b989a82b5fb160f0151ea5d046451a291a0748f3038ecdc63d637cce00b9000
+      `,
+    },
+  ],
+  accounts: [
+    {
+      FIXME_tests: ["pendingOperations are cleaned up"],
+      raw: {
+        id: "js:2:kaspa:41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576:",
+        seedIdentifier:
+          "41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576",
+        derivationMode: "",
+        currencyId: "kaspa",
+        pendingOperations: [],
+        xpub: "41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576",
+        lastSyncDate: "",
+        index: 0,
+        blockHeight: 194187965,
+        balance: "13370000",
+        spendableBalance: "13370000",
+        operations: [],
+        operationsCount: 1,
+        freshAddress: "kaspa:qz49rpg0q6ywewxkwl76757ya79v6j556hcmrcy7mk9d36ewgp80cdrwlct2h",
+        freshAddressPath: "44'/111111'/0'/0/1",
+        used: true,
+      },
+    },
+  ],
+};
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    kaspa,
+  },
+};

package/src/test/cli.ts

@@ -0,0 +1,33 @@
+import flatMap from "lodash/flatMap";
+import type { AccountLike } from "@ledgerhq/types-live";
+import { Transaction } from "../types/bridge";
+
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send",
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{ account: AccountLike; transaction: Transaction }>,
+  opts: Record<string, any>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction }) => {
+    if (transaction.family !== "kaspa") {
+      throw new Error("transaction is not of type Kaspa");
+    }
+
+    return {
+      ...transaction,
+      family: "kaspa",
+      mode: opts.mode || "send",
+    };
+  });
+}
+
+export default {
+  options,
+  inferTransactions,
+};

package/src/test/index.ts

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

package/src/transaction.ts

@@ -0,0 +1,84 @@
+import { KaspaAccount, Transaction, TransactionRaw, TransactionStatus } from "./types";
+
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { Account } from "@ledgerhq/types-live";
+import { formatTransactionStatus as formatTransactionStatusCommon } from "@ledgerhq/coin-framework/formatters";
+import { BigNumber } from "bignumber.js";
+
+export const formatTransactionStatus = (
+  t: Transaction,
+  ts: TransactionStatus,
+  mainAccount: KaspaAccount,
+): string => {
+  let str = "";
+
+  str += formatTransactionStatusCommon(t, ts, mainAccount);
+
+  return str;
+};
+
+export const formatTransaction = (
+  { amount, recipient, useAllAmount, subAccountId }: Transaction,
+  mainAccount: Account,
+): string => {
+  const account =
+    (subAccountId && (mainAccount.subAccounts || []).find(a => a.id === subAccountId)) ||
+    mainAccount;
+  return `
+  ${
+    useAllAmount
+      ? "MAX"
+      : amount.isZero()
+        ? ""
+        : " " +
+          formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+            showCode: true,
+            disableRounding: true,
+          })
+  }${recipient ? `\nTO ${recipient}` : ""}`;
+};
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    networkInfo: tr.networkInfo.map(x => ({
+      ...x,
+      amount: BigNumber(x.amount),
+    })),
+    feesStrategy: tr.feesStrategy,
+    customFeeRate: tr.customFeeRate ? BigNumber(tr.customFeeRate) : undefined,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    networkInfo: t.networkInfo.map(x => ({
+      ...x,
+      amount: x.amount.toString(),
+    })),
+    feesStrategy: t.feesStrategy,
+    customFeeRate: t.customFeeRate?.toString(),
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/types/addresses.ts

@@ -0,0 +1,19 @@
+import { BigNumber } from "bignumber.js";
+
+export type AccountAddress = {
+  type: number;
+  index: number;
+  address: string;
+  balance: BigNumber;
+  active: boolean;
+  timestamp: number | null;
+};
+
+export type AccountAddresses = {
+  usedReceiveAddresses: AccountAddress[];
+  usedChangeAddresses: AccountAddress[];
+  nextChangeAddress: AccountAddress;
+  nextReceiveAddress: AccountAddress;
+  totalBalance: BigNumber;
+  spendableBalance: BigNumber;
+};

package/src/types/bridge.ts

@@ -0,0 +1,43 @@
+import type {
+  Account,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+
+export type KaspaAccount = Account & {
+  xpub: string;
+  lastSyncTimestamp: number;
+  activeAddressCount: number; // good to approximate the fee
+  nextChangeAddress: string;
+  nextChangeAddressType: number;
+  nextChangeAddressIndex: number;
+  nextReceiveAddress: string;
+  nextReceiveAddressType: number;
+  nextReceiveAddressIndex: number;
+};
+
+export type Transaction = TransactionCommon & {
+  family: "kaspa";
+  networkInfo: {
+    label: string;
+    amount: BigNumber;
+    estimatedSeconds: number;
+  }[];
+  customFeeRate?: BigNumber | undefined;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "kaspa";
+  networkInfo: {
+    label: string;
+    amount: string;
+    estimatedSeconds: number;
+  }[];
+  customFeeRate?: string | undefined;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+export type TransactionStatusRaw = TransactionStatusCommonRaw;

package/src/types/errors.ts

@@ -0,0 +1,7 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const NotEnoughFeeError = createCustomErrorClass("NotEnoughFeeError");
+
+export const TransactionMassExceededError = createCustomErrorClass("TransactionMassExceededError");
+
+export const EmptyRecipientError = createCustomErrorClass("EmptyRecipientError");

package/src/types/index.ts

@@ -0,0 +1,7 @@
+export type * from "./bridge";
+export type * from "./errors";
+export type * from "./kaspaNetwork";
+export type * from "./network";
+export type * from "./addresses";
+export * from "./kaspaHwTransaction";
+export type * from "./signer";

package/src/types/kaspaHwTransaction.ts

@@ -0,0 +1,234 @@
+type TransactionApiJSON = {
+  transaction: {
+    version: number;
+    inputs: TransactionInputApiJSON[];
+    outputs: TransactionOutputApiJSON[];
+    lockTime: number;
+    subnetworkId: string;
+  };
+};
+
+export class KaspaHwTransaction {
+  inputs: KaspaHwTransactionInput[];
+  outputs: KaspaHwTransactionOutput[];
+  version: number;
+  changeAddressType: number;
+  changeAddressIndex: number;
+  account: number;
+  fee: number;
+
+  constructor(txData: {
+    inputs: KaspaHwTransactionInput[];
+    outputs: KaspaHwTransactionOutput[];
+    version: number;
+    fee?: number;
+    changeAddressType?: number;
+    changeAddressIndex?: number;
+    account?: number;
+  }) {
+    /**
+     * @type {TransactionInput[]}
+     */
+    this.inputs = txData.inputs;
+    /**
+     * @type {TransactionOutput[]}
+     */
+    this.outputs = txData.outputs;
+    /**
+     * @type {int}
+     */
+    this.version = txData.version;
+
+    this.changeAddressType = txData.changeAddressType ?? 0;
+    this.changeAddressIndex = txData.changeAddressIndex ?? 0;
+    this.account = txData.account ?? 0x80000000;
+    this.fee = txData.fee || 0;
+
+    if (!(this.changeAddressType === 0 || this.changeAddressType === 1)) {
+      throw new Error(`changeAddressType must be 0 or 1 if set`);
+    }
+
+    if (this.account < 0x80000000 || this.account > 0xffffffff) {
+      throw new Error("account must be between 0x80000000 and 0xFFFFFFFF");
+    }
+
+    if (this.changeAddressIndex < 0x00000000 || this.changeAddressIndex > 0xffffffff) {
+      throw new Error(`changeAddressIndex must be between 0x00000000 and 0xFFFFFFFF`);
+    }
+  }
+
+  serialize(): Buffer {
+    const versionBuf = Buffer.alloc(2);
+    versionBuf.writeUInt16BE(this.version);
+
+    const outputLenBuf = Buffer.alloc(1);
+    outputLenBuf.writeUInt8(this.outputs.length);
+
+    const inputLenBuf = Buffer.alloc(1);
+    inputLenBuf.writeUInt8(this.inputs.length);
+
+    const changeAddressTypeBuf = Buffer.alloc(1);
+    changeAddressTypeBuf.writeUInt8(this.changeAddressType);
+
+    const changeAddressIndexBuf = Buffer.alloc(4);
+    changeAddressIndexBuf.writeUInt32BE(this.changeAddressIndex);
+
+    const accountBuf = Buffer.alloc(4);
+    accountBuf.writeUInt32BE(this.account);
+
+    return Buffer.concat([
+      versionBuf,
+      outputLenBuf,
+      inputLenBuf,
+      changeAddressTypeBuf,
+      changeAddressIndexBuf,
+      accountBuf,
+    ]);
+  }
+
+  /**
+   * Convert this transaction to a JSON object that api.kaspa.org will accept
+   */
+  toApiJSON(): TransactionApiJSON {
+    return {
+      transaction: {
+        version: this.version,
+        inputs: this.inputs.map(i => i.toApiJSON()),
+        outputs: this.outputs.map(o => o.toApiJSON()),
+        lockTime: 0,
+        subnetworkId: "0000000000000000000000000000000000000000",
+      },
+    };
+  }
+}
+
+type TransactionInputApiJSON = {
+  previousOutpoint: {
+    transactionId: string;
+    index: number;
+  };
+  signatureScript: string | null;
+  sequence: number;
+  sigOpCount: number;
+};
+
+export class KaspaHwTransactionInput {
+  signature?: string | null;
+  sighash?: string | null;
+  value: number;
+  prevTxId: string;
+  outpointIndex: number;
+  addressType: number;
+  addressIndex: number;
+  address: string;
+
+  constructor(inputData: {
+    value: number;
+    prevTxId: string;
+    outpointIndex: number;
+    addressType: number;
+    addressIndex: number;
+    address: string;
+  }) {
+    this.value = inputData.value;
+    this.prevTxId = inputData.prevTxId;
+    this.outpointIndex = inputData.outpointIndex;
+    this.addressType = inputData.addressType;
+    this.addressIndex = inputData.addressIndex;
+    this.signature = null;
+    this.sighash = null;
+    this.address = inputData.address;
+  }
+
+  serialize(): Buffer {
+    const valueBuf = Buffer.from(toBigEndianHex(this.value), "hex");
+
+    const addressTypeBuf = Buffer.alloc(1);
+    addressTypeBuf.writeUInt8(this.addressType);
+
+    const addressIndexBuf = Buffer.alloc(4);
+    addressIndexBuf.writeUInt32BE(this.addressIndex);
+
+    const outpointIndexBuf = Buffer.alloc(1);
+    outpointIndexBuf.writeUInt8(this.outpointIndex);
+
+    return Buffer.concat([
+      valueBuf,
+      Buffer.from(this.prevTxId, "hex"),
+      addressTypeBuf,
+      addressIndexBuf,
+      outpointIndexBuf,
+    ]);
+  }
+
+  /**
+   *
+   * @param {string} signature
+   */
+  setSignature(signature: string): void {
+    this.signature = signature;
+  }
+
+  setSighash(sighash: string): void {
+    this.sighash = sighash;
+  }
+
+  toApiJSON(): TransactionInputApiJSON {
+    return {
+      previousOutpoint: {
+        transactionId: this.prevTxId,
+        index: this.outpointIndex,
+      },
+      signatureScript: this.signature ? `41${this.signature}01` : null,
+      sequence: 0,
+      sigOpCount: 1,
+    };
+  }
+}
+
+type TransactionOutputApiJSON = {
+  amount: number;
+  scriptPublicKey: {
+    version: number;
+    scriptPublicKey: string;
+  };
+};
+
+export class KaspaHwTransactionOutput {
+  value: number;
+  scriptPublicKey: string;
+
+  constructor(outputData: { value: number; scriptPublicKey: string }) {
+    if (!outputData.value || outputData.value < 0 || outputData.value > 0xffffffffffffffffn) {
+      throw new Error(
+        "value must be set to a value greater than 0 and less than 0xFFFFFFFFFFFFFFFF",
+      );
+    }
+    this.value = outputData.value;
+
+    // Only then do we care about the script public key
+    this.scriptPublicKey = outputData.scriptPublicKey;
+  }
+
+  serialize(): Buffer {
+    const valueBuf: Buffer = Buffer.from(toBigEndianHex(this.value), "hex");
+    return Buffer.concat([valueBuf, Buffer.from(this.scriptPublicKey, "hex")]);
+  }
+
+  toApiJSON(): TransactionOutputApiJSON {
+    return {
+      amount: this.value,
+      scriptPublicKey: {
+        version: 0,
+        scriptPublicKey: this.scriptPublicKey,
+      },
+    };
+  }
+}
+
+export function toBigEndianHex(numberToConvert: number) {
+  let baseStr = "0000000000000000";
+  baseStr += numberToConvert.toString(16);
+
+  return baseStr.substring(baseStr.length - 16, baseStr.length);
+}

package/src/types/kaspaNetwork.ts

@@ -0,0 +1,21 @@
+import type { BigNumber } from "bignumber.js";
+
+type KaspaOutpoint = {
+  transactionId: string;
+  index: number;
+};
+export type KaspaUtxo = {
+  address: string;
+  accountType: number;
+  accountIndex: number;
+  outpoint: KaspaOutpoint;
+  utxoEntry: {
+    amount: BigNumber;
+    scriptPublicKey: {
+      version: number;
+      scriptPublicKey: string;
+    };
+    blockDaaScore: string;
+    isCoinbase: boolean;
+  };
+};

package/src/types/network.ts

@@ -0,0 +1,101 @@
+import { BigNumber } from "bignumber.js";
+
+export type ApiResponseSubmitTransaction = {
+  txId: string;
+};
+
+export type ApiResponseBlockDagInfo = {
+  networkName: string;
+  blockCount: string;
+  headerCount: string;
+  tipHashes: string[];
+  difficulty: number;
+  pastMedianTime: string;
+  virtualParentHashes: string[];
+  pruningPointHash: string;
+  virtualDaaScore: string;
+};
+
+export type ApiResponseAddressActive = {
+  address: string;
+  active: boolean;
+  lastTxBlockTime: number;
+};
+
+export type ApiResponseBalance = {
+  address: string;
+  balance: number;
+};
+
+export type ApiResponseFeeEstimate = {
+  priorityBucket: {
+    feerate: number;
+    estimatedSeconds: number;
+  };
+  normalBuckets: Array<{
+    feerate: number;
+    estimatedSeconds: number;
+  }>;
+  lowBuckets: Array<{
+    feerate: number;
+    estimatedSeconds: number;
+  }>;
+};
+
+type Outpoint = {
+  transactionId: string;
+  index: number;
+};
+
+type ScriptPublicKey = {
+  scriptPublicKey: string;
+};
+
+type UtxoEntry = {
+  amount: BigNumber;
+  scriptPublicKey: ScriptPublicKey;
+  blockDaaScore: string;
+  isCoinbase: boolean;
+};
+
+export type ApiResponseUtxo = {
+  address: string;
+  outpoint: Outpoint;
+  utxoEntry: UtxoEntry;
+};
+
+export type ApiResponseTransaction = {
+  subnetwork_id: string;
+  transaction_id: string;
+  hash: string;
+  mass: string;
+  block_hash: string[];
+  block_time: number;
+  is_accepted: boolean;
+  accepting_block_hash: string;
+  accepting_block_blue_score: number;
+  inputs: Input[];
+  outputs: Output[];
+};
+
+type Input = {
+  transaction_id: string;
+  index: number;
+  previous_outpoint_hash: string;
+  previous_outpoint_index: string;
+  previous_outpoint_resolved: Output;
+  previous_outpoint_address: string;
+  previous_outpoint_amount: number;
+  signature_script: string;
+  sig_op_count: string;
+};
+
+type Output = {
+  transaction_id: string;
+  index: number;
+  amount: number;
+  script_public_key: string;
+  script_public_key_address: string;
+  script_public_key_type: string;
+  accepting_block_hash: string;
+};

package/src/types/signer.ts

@@ -0,0 +1,22 @@
+import { KaspaHwTransaction } from "./index";
+
+export type KaspaAddress = {
+  address: string;
+  publicKey: string;
+};
+export type KaspaSignature = {
+  signature: string;
+};
+
+export interface KaspaSigner {
+  getAddress(path: string, display?: boolean): Promise<KaspaAddress>;
+
+  signMessage(
+    message: string,
+    addressType?: 0 | 1,
+    addressIndex?: number,
+    account?: number,
+  ): Promise<KaspaSignature>;
+
+  signTransaction(transaction: KaspaHwTransaction): Promise<void>;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "outDir": "lib",
+    "rootDir": "src",
+    "module": "NodeNext"
+  },
+  "include": ["src/**/*"]
+}