@ledgerhq/hw-app-kaspa 1.3.0-nightly.0

package/src/base32.ts

@@ -0,0 +1,36 @@
+"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.
+ */
+const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+
+/***
+ * 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: Array<number>) {
+  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;
+}
+
+const base32 = {
+  encode,
+};
+
+export default base32;

package/src/index.ts

@@ -0,0 +1,9 @@
+import Kaspa from "./Kaspa";
+
+export {
+  TransactionInput,
+  TransactionOutput,
+  KaspaHwTransaction,
+} from "./kaspaHwTransaction";
+
+export default Kaspa;

package/src/kaspa-util.ts

@@ -0,0 +1,107 @@
+import base32 from "./base32";
+
+function convertBits(
+  data: number[],
+  from: number,
+  to: number,
+  strict: boolean = false,
+): number[] {
+  strict = strict || false;
+  let accumulator = 0;
+  let bits = 0;
+  const result: number[] = [];
+  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 >= from || (accumulator << (to - bits)) & mask)) {
+      throw new Error("Conversion requires padding but strict mode was used");
+    }
+  }
+  return result;
+}
+
+function prefixToArray(prefix): number[] {
+  const result: number[] = [];
+  for (let i = 0; i < prefix.length; i++) {
+    const char = prefix.charCodeAt(i);
+    result.push(char & 31);
+  }
+  return result;
+}
+
+const GENERATOR1 = [0x98, 0x79, 0xf3, 0xae, 0x1e];
+const GENERATOR2 = [0xf2bc8e61, 0xb76d99e2, 0x3e5fb3c4, 0x2eabe2a8, 0x4f43e470];
+
+function polymod(data) {
+  // Treat c as 8 bits + 32 bits
+  let c0 = 0,
+    c1 = 1,
+    C = 0;
+  for (let j = 0; j < data.length; j++) {
+    // Set C to c shifted by 35
+    C = c0 >>> 3;
+    // 0x[07]ffffffff
+    c0 &= 0x07;
+    // Shift as a whole number
+    c0 <<= 5;
+    c0 |= c1 >>> 27;
+    // 0xffffffff >>> 5
+    c1 &= 0x07ffffff;
+    c1 <<= 5;
+    // xor the last 5 bits
+    c1 ^= data[j];
+    for (let i = 0; i < GENERATOR1.length; ++i) {
+      if (C & (1 << i)) {
+        c0 ^= GENERATOR1[i];
+        c1 ^= GENERATOR2[i];
+      }
+    }
+  }
+  c1 ^= 1;
+  // Negative numbers -> large positive numbers
+  if (c1 < 0) {
+    c1 ^= 1 << 31;
+    c1 += (1 << 30) * 2;
+  }
+  // Unless bitwise operations are used,
+  // numbers are consisting of 52 bits, except
+  // the sign bit. The result is max 40 bits,
+  // so it fits perfectly in one number!
+  return c0 * (1 << 30) * 4 + c1;
+}
+
+function checksumToArray(checksum) {
+  const result: number[] = [];
+  for (let i = 0; i < 8; ++i) {
+    result.push(checksum & 31);
+    checksum /= 32;
+  }
+  return result.reverse();
+}
+
+export function publicKeyToAddress(hashBuffer: Buffer): string {
+  const eight0: number[] = [0, 0, 0, 0, 0, 0, 0, 0];
+  const prefixData: number[] = prefixToArray("kaspa").concat([0]);
+  const versionByte: number = 0;
+  const arr: number[] = Array.prototype.slice.call(hashBuffer, 0);
+  const payloadData: number[] = convertBits([versionByte].concat(arr), 8, 5);
+  const checksumData: number[] = prefixData.concat(payloadData).concat(eight0);
+  const payload = payloadData.concat(checksumToArray(polymod(checksumData)));
+  return "kaspa:" + base32.encode(payload);
+}

package/src/kaspaHwTransaction.ts

@@ -0,0 +1,244 @@
+type TransactionApiJSON = {
+  transaction: {
+    version: number;
+    inputs: TransactionInputApiJSON[];
+    outputs: TransactionOutputApiJSON[];
+    lockTime: number;
+    subnetworkId: string;
+  };
+};
+
+export class KaspaHwTransaction {
+  inputs: TransactionInput[];
+  outputs: TransactionOutput[];
+  version: number;
+  changeAddressType: number;
+  changeAddressIndex: number;
+  account: number;
+
+  constructor(txData: {
+    inputs: TransactionInput[];
+    outputs: TransactionOutput[];
+    version: 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;
+
+    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 TransactionInput {
+  signature?: string | null;
+  sighash?: string | null;
+  value: number;
+  prevTxId: string;
+  outpointIndex: number;
+  addressType: number;
+  addressIndex: number;
+
+  constructor(inputData: {
+    value: number;
+    prevTxId: string;
+    outpointIndex: number;
+    addressType: number;
+    addressIndex: number;
+  }) {
+    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;
+  }
+
+  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 TransactionOutput {
+  value: number;
+  scriptPublicKey: string;
+
+  constructor(outputData: { value: number; scriptPublicKey: string }) {
+    if (
+      !outputData.value ||
+      outputData.value < 0 ||
+      outputData.value > Number.MAX_SAFE_INTEGER
+    ) {
+      throw new Error(
+        `value must be set to a value greater than 0 and less than ${Number.MAX_SAFE_INTEGER.toString()}`,
+      );
+    }
+    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);
+}
+
+export default {
+  Transaction: KaspaHwTransaction,
+  TransactionInput,
+  TransactionOutput,
+};