@ledgerhq/live-common 33.1.1 → 33.2.0-next.0

package/src/families/casper/api/types.ts

@@ -0,0 +1,111 @@
+export interface NodeRPCPayload {
+  jsonrpc: "2.0";
+  method:
+    | "info_get_status"
+    | "chain_get_state_root_hash"
+    | "state_get_account_info"
+    | "state_get_balance"
+    | "account_put_deploy";
+  params: any;
+  id: 1;
+}
+
+export interface IndexerResponseRoot<T> {
+  data: T[];
+  pageCount: number;
+  itemCount: number;
+  pages: { number: number; url: string }[];
+}
+
+export interface ITxnHistoryData {
+  deploy_hash: string;
+  block_hash: string;
+  caller_public_key: string;
+  execution_type_id: number;
+  contract_hash?: any;
+  contract_package_hash?: any;
+  cost: string;
+  payment_amount: string;
+  error_message?: string;
+  timestamp: string;
+  status: string;
+  args: {
+    id: {
+      parsed?: number;
+      cl_type: {
+        Option: string;
+      };
+    };
+    amount: {
+      parsed: string;
+      cl_type: string;
+    };
+    target: {
+      parsed: string;
+      cl_type: {
+        ByteArray: number;
+      };
+    };
+  };
+  amount: string;
+}
+
+export interface NodeResponseRoot<T> {
+  jsonrpc: string;
+  id: string;
+  result: T;
+}
+
+export interface NNetworkStatusResponse {
+  api_version: string;
+  chainspec_name: string;
+  starting_state_root_hash: string;
+  peers: { node_id: string; address: string }[];
+  last_added_block_info: {
+    hash: string;
+    timestamp: string;
+    era_id: number;
+    height: number;
+    state_root_hash: string;
+    creator: string;
+  };
+  our_public_signing_key: string;
+  round_length?: any;
+  next_upgrade?: any;
+  build_version: string;
+  uptime: string;
+}
+
+export interface NStateRootHashResponse {
+  api_version: string;
+  state_root_hash: string;
+}
+
+export interface NAccountBalance {
+  api_version: string;
+  balance_value: string;
+  merkle_proof: string;
+}
+
+export interface NAccountInfo {
+  api_version: string;
+  account: {
+    account_hash: string;
+    named_keys: any[];
+    main_purse: string;
+    associated_keys: {
+      account_hash: string;
+      weight: number;
+    }[];
+    action_thresholds: {
+      deployment: number;
+      key_management: number;
+    };
+  };
+  merkle_proof: string;
+}
+
+export interface NDeployMessagePutResponse {
+  api_version: string;
+  deploy_hash: string;
+}

package/src/families/casper/bridge/account.ts

@@ -0,0 +1,288 @@
+import type {
+  Account,
+  AccountBridge,
+  SignOperationEvent,
+  BroadcastFnSignature,
+  SignOperationFnSignature,
+  AccountLike,
+} from "@ledgerhq/types-live";
+import type { CasperOperation, Transaction, TransactionStatus } from "../types";
+import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+
+import { getPath, isError } from "../msc-utils";
+import { CLPublicKey, DeployUtil } from "casper-js-sdk";
+import BigNumber from "bignumber.js";
+import {
+  CASPER_MINIMUM_VALID_AMOUNT_MOTES,
+  CASPER_MAX_TRANSFER_ID,
+  MayBlockAccountError,
+  InvalidMinimumAmountError,
+} from "../consts";
+import {
+  getAddress,
+  getPubKeySignature,
+  getPublicKeyFromCasperAddress,
+  isAddressValid,
+} from "./bridgeHelpers/addresses";
+import { log } from "@ledgerhq/logs";
+import { Observable } from "rxjs";
+import { withDevice } from "../../../hw/deviceAccess";
+import { encodeOperationId, patchOperationWithHash } from "../../../operation";
+import CasperApp from "@zondax/ledger-casper";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { CasperInvalidTransferId } from "../errors";
+import { broadcastTx } from "../api";
+import { getMainAccount } from "../../../account/helpers";
+import { createNewDeploy, deployHashToString } from "./bridgeHelpers/txn";
+import { getAccountShape } from "./bridgeHelpers/accountShape";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { isTransferIdValid } from "./bridgeHelpers/transferId";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+
+const receive = makeAccountBridgeReceive();
+
+const createTransaction = (): Transaction => {
+  // log("debug", "[createTransaction] creating base tx");
+
+  return {
+    family: "casper",
+    amount: new BigNumber(0),
+    fees: new BigNumber(0),
+    recipient: "",
+    useAllAmount: false,
+  };
+};
+
+const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
+  // log("debug", "[prepareTransaction] start fn");
+  const fees = getEstimatedFees();
+
+  const amount = t.useAllAmount ? a.spendableBalance.minus(t.fees) : t.amount;
+
+  // log("debug", "[prepareTransaction] finish fn");
+  return defaultUpdateTransaction(t, { fees, amount });
+};
+
+const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+
+  const { balance, spendableBalance } = a;
+  const { address } = getAddress(a);
+  const { recipient, useAllAmount } = t;
+  let { amount } = t;
+
+  if (!recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!isAddressValid(recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
+  } else if (recipient.toLowerCase() === address.toLowerCase()) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (!isAddressValid(address)) {
+    errors.sender = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
+  } else if (!isTransferIdValid(t.transferId)) {
+    errors.sender = new CasperInvalidTransferId("", {
+      maxTransferId: CASPER_MAX_TRANSFER_ID,
+    });
+  }
+
+  const estimatedFees = t.fees;
+
+  let totalSpent = BigNumber(0);
+
+  if (useAllAmount) {
+    totalSpent = a.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (!useAllAmount) {
+    totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    }
+
+    if (totalSpent.gt(a.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (amount.lt(CASPER_MINIMUM_VALID_AMOUNT_MOTES) && !errors.amount) {
+    errors.amount = InvalidMinimumAmountError;
+  }
+
+  if (
+    spendableBalance.minus(totalSpent).minus(estimatedFees).lt(CASPER_MINIMUM_VALID_AMOUNT_MOTES)
+  ) {
+    warnings.amount = MayBlockAccountError;
+  }
+
+  // log("debug", "[getTransactionStatus] finish fn");
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};
+
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount?: Account | null | undefined;
+  transaction?: Transaction | null | undefined;
+}): Promise<BigNumber> => {
+  const a = getMainAccount(account, parentAccount);
+  let balance = a.spendableBalance;
+
+  if (balance.eq(0)) return balance;
+
+  const estimatedFees = transaction?.fees ?? getEstimatedFees();
+
+  if (balance.lte(estimatedFees)) return new BigNumber(0);
+
+  balance = balance.minus(estimatedFees);
+
+  // log("debug", "[estimateMaxSpendable] finish fn");
+
+  return balance;
+};
+
+const signOperation: SignOperationFnSignature<Transaction> = ({
+  account,
+  deviceId,
+  transaction,
+}): Observable<SignOperationEvent> =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          // log("debug", "[signOperation] start fn");
+
+          const { recipient, amount } = transaction;
+          const { id: accountId } = account;
+          const { address, derivationPath } = getAddress(account);
+
+          const casper = new CasperApp(transport);
+
+          const fee = transaction.fees;
+
+          const deploy = createNewDeploy(
+            address,
+            recipient,
+            transaction.amount,
+            transaction.fees,
+            transaction.transferId,
+          );
+          // Serialize tx
+          const deployBytes = DeployUtil.deployToBytes(deploy);
+
+          log("debug", `[signOperation] serialized deploy: [${deployBytes.toString()}]`);
+
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          // Sign by device
+          const result = await casper.sign(getPath(derivationPath), Buffer.from(deployBytes));
+          isError(result);
+
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          // signature verification
+          const deployHash = deployHashToString(deploy.hash, true);
+          const signature = result.signatureRS;
+
+          const pkBuffer = Buffer.from(getPublicKeyFromCasperAddress(address), "hex");
+          // sign deploy object
+          const signedDeploy = DeployUtil.setSignature(
+            deploy,
+            signature,
+            new CLPublicKey(pkBuffer, getPubKeySignature(address)),
+          );
+
+          const operation: CasperOperation = {
+            id: encodeOperationId(accountId, deployHash, "OUT"),
+            hash: deployHash,
+            type: "OUT",
+            senders: [address],
+            recipients: [recipient],
+            accountId,
+            value: amount.plus(fee),
+            fee,
+            blockHash: null,
+            blockHeight: null,
+            date: new Date(),
+            extra: {
+              transferId: transaction.transferId,
+            },
+          };
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: JSON.stringify(DeployUtil.deployToJson(signedDeploy)),
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );
+
+const broadcast: BroadcastFnSignature = async ({ signedOperation: { signature, operation } }) => {
+  // log("debug", "[broadcast] start fn");
+
+  const tx = DeployUtil.deployFromJson(JSON.parse(signature)).unwrap();
+
+  // log("debug", `[broadcast] isDeployOk ${DeployUtil.validateDeploy(tx).ok}`);
+  const resp = await broadcastTx(tx);
+  const { deploy_hash } = resp;
+
+  const result = patchOperationWithHash(operation, deploy_hash);
+
+  // log("debug", "[broadcast] finish fn");
+
+  return result;
+};
+
+const sync = makeSync({ getAccountShape });
+
+const accountBridge: AccountBridge<Transaction> = {
+  estimateMaxSpendable,
+  createTransaction,
+  updateTransaction: defaultUpdateTransaction,
+  getTransactionStatus,
+  prepareTransaction,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+};
+
+export { accountBridge };

package/src/families/casper/bridge/bridgeHelpers/accountShape.ts

@@ -0,0 +1,40 @@
+import { flatMap } from "lodash";
+import { log } from "@ledgerhq/logs";
+import BigNumber from "bignumber.js";
+import { encodeAccountId } from "../../../../account";
+
+import { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { fetchBalance, fetchNetworkStatus, fetchTxs, fetchAccountStateInfo } from "../../api/index";
+import { mapTxToOps } from "./txn";
+import { NAccountBalance, ITxnHistoryData } from "../../api/types";
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, currency, derivationMode } = info;
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  log("debug", `Generation account shape for ${address}`);
+
+  const { purseUref, accountHash } = await fetchAccountStateInfo(address);
+
+  const blockHeight = await fetchNetworkStatus();
+
+  const balance: NAccountBalance = purseUref
+    ? await fetchBalance(purseUref)
+    : { balance_value: "0", api_version: "", merkle_proof: "" };
+  const txs: ITxnHistoryData[] = purseUref ? await fetchTxs(address) : [];
+
+  return {
+    id: accountId,
+    balance: new BigNumber(balance.balance_value),
+    spendableBalance: new BigNumber(balance.balance_value),
+    operations: flatMap(txs, mapTxToOps(accountId, accountHash ?? "")),
+    blockHeight: blockHeight.last_added_block_info.height,
+  };
+};

package/src/families/casper/bridge/bridgeHelpers/addresses.ts

@@ -0,0 +1,120 @@
+import { CASPER_CHECKSUM_HEX_LEN, CASPER_SMALL_BYTES_COUNT } from "../../consts";
+
+import { Account, Address } from "@ledgerhq/types-live";
+import { CLPublicKey, CLPublicKeyTag } from "casper-js-sdk";
+import { blake2bFinal, blake2bInit, blake2bUpdate } from "blakejs";
+import { InvalidAddress } from "@ledgerhq/errors";
+
+export const getAddress = (a: Account): Address =>
+  a.freshAddresses.length > 0
+    ? a.freshAddresses[0]
+    : { address: a.freshAddress, derivationPath: a.freshAddressPath };
+
+export const getPubKeySignature = (pubKey: string): CLPublicKeyTag => {
+  const signature = pubKey.substring(0, 2);
+
+  if (signature === "01") return CLPublicKeyTag.ED25519;
+
+  if (signature === "02") return CLPublicKeyTag.SECP256K1;
+
+  throw new Error("casper pubkey signature not know");
+};
+
+function numberToBin(num: number) {
+  let binStr = (num >>> 0).toString(2);
+  while (binStr.length < 8) {
+    binStr = "0" + binStr;
+  }
+  return binStr.split("").reverse().join("");
+}
+
+function bytesToBitsString(buf: Buffer | Uint8Array) {
+  const bitsArray: string[] = [];
+
+  for (const num of buf) {
+    const bin = numberToBin(num);
+    bitsArray.push(bin);
+  }
+
+  return bitsArray.join("");
+}
+
+/**
+ * Returns the bytes encoded as hexadecimal with mixed-case based checksums following a scheme
+ * similar to [EIP-55](https://eips.ethereum.org/EIPS/eip-55).
+ */
+export function casperAddressEncode(inputBytes: Buffer): string {
+  const context = blake2bInit(CASPER_CHECKSUM_HEX_LEN);
+  blake2bUpdate(context, inputBytes);
+  const blakeHash = blake2bFinal(context);
+
+  const nibbles = inputBytes
+    .toString("hex")
+    .split("")
+    .map(v => parseInt(v, 16));
+
+  const bitsArray = bytesToBitsString(blakeHash);
+
+  const res: Array<number | string> = [];
+
+  let steamIndex = -1;
+  for (const num of nibbles) {
+    if (num < 10) res.push(num);
+    else {
+      steamIndex += 1;
+      if (parseInt(bitsArray[steamIndex], 10)) res.push(num.toString(16).toUpperCase());
+      else res.push(num.toString(16).toLowerCase());
+    }
+  }
+
+  return res.join("");
+}
+
+// Decodes a mixed-case hexadecimal string
+// Checksum hex encoding for casper docs: https://docs.casperlabs.io/design/checksummed-hex/
+function casperAddressDecode(inputString: string): string {
+  if (Buffer.from(inputString, "hex").length > CASPER_SMALL_BYTES_COUNT) return inputString;
+
+  if (inputString.toLowerCase() === inputString) return inputString;
+  if (inputString.toUpperCase() === inputString) return inputString;
+
+  const encoded = casperAddressEncode(Buffer.from(inputString, "hex"));
+
+  for (let i = 0; i < encoded.length; i++) {
+    if (encoded.charAt(i) !== inputString.charAt(i))
+      throw Error("Checksum invalid, decoding failed.");
+  }
+
+  return inputString;
+}
+
+export function isAddressValid(address: string): boolean {
+  try {
+    const pubKey = getPublicKeyFromCasperAddress(address);
+    new CLPublicKey(Buffer.from(pubKey, "hex"), getPubKeySignature(address));
+    casperAddressDecode(pubKey);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+export function getPublicKeyFromCasperAddress(address: string): string {
+  if (address.length !== 68) throw new InvalidAddress("Invalid address size, expected 34 bytes");
+  return address.substring(2);
+}
+
+export function casperAddressFromPubKey(pubkey: Buffer): string {
+  const checksumed = casperAddressEncode(pubkey);
+
+  return `02${checksumed}`;
+}
+
+export function casperPubKeyToAccountHash(pubKey: string): string {
+  const clPubKey = new CLPublicKey(
+    Buffer.from(pubKey.substring(2), "hex"),
+    getPubKeySignature(pubKey),
+  );
+
+  return casperAddressEncode(Buffer.from(clPubKey.toAccountRawHashStr(), "hex"));
+}

package/src/families/casper/bridge/bridgeHelpers/fee.ts

@@ -0,0 +1,6 @@
+import BigNumber from "bignumber.js";
+import { CASPER_FEES_MOTES } from "../../consts";
+
+export function getEstimatedFees(): BigNumber {
+  return new BigNumber(CASPER_FEES_MOTES);
+}

package/src/families/casper/bridge/bridgeHelpers/transferId.ts

@@ -0,0 +1,9 @@
+import { BigNumber } from "bignumber.js";
+import { CASPER_MAX_TRANSFER_ID } from "../../consts";
+
+export function isTransferIdValid(id?: string): boolean {
+  if (!id || !id.length) return true;
+  if (/^\d+$/.test(id) && new BigNumber(id).lt(new BigNumber(CASPER_MAX_TRANSFER_ID))) return true;
+
+  return false;
+}

package/src/families/casper/bridge/bridgeHelpers/txn.ts

@@ -0,0 +1,124 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { InvalidAddress } from "@ledgerhq/errors";
+import { log } from "@ledgerhq/logs";
+import { Unit } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import { CLPublicKey, DeployUtil } from "casper-js-sdk";
+import { encodeOperationId } from "../../../../operation";
+import { CASPER_NETWORK } from "../../consts";
+import {
+  casperAddressEncode,
+  casperPubKeyToAccountHash,
+  getPubKeySignature,
+  getPublicKeyFromCasperAddress,
+  isAddressValid,
+} from "./addresses";
+import { ITxnHistoryData } from "../../api/types";
+import { getEstimatedFees } from "./fee";
+import { CasperOperation } from "../../types";
+
+export const getUnit = (): Unit => getCryptoCurrencyById("casper").units[0];
+
+export function mapTxToOps(
+  accountId: string,
+  addressHash: string,
+  fees = getEstimatedFees(),
+): (tx: ITxnHistoryData) => CasperOperation[] {
+  return (tx: ITxnHistoryData): CasperOperation[] => {
+    const ops: CasperOperation[] = [];
+    const { timestamp, caller_public_key, args: txArgs, deploy_hash, error_message } = tx;
+    const fromAccount = casperPubKeyToAccountHash(caller_public_key);
+    const toAccount = txArgs.target.parsed;
+
+    const date = new Date(timestamp);
+    const value = new BigNumber(txArgs.amount.parsed);
+    const feeToUse = fees;
+
+    const isSending = addressHash.toLowerCase() === fromAccount.toLowerCase();
+    const isReceiving = addressHash.toLowerCase() === toAccount.toLowerCase();
+
+    if (isSending) {
+      ops.push({
+        id: encodeOperationId(accountId, deploy_hash, "OUT"),
+        hash: deploy_hash,
+        type: "OUT",
+        value: value.plus(feeToUse),
+        fee: feeToUse,
+        blockHeight: 1,
+        hasFailed: error_message ? true : false,
+        blockHash: null,
+        accountId,
+        senders: [fromAccount],
+        recipients: [toAccount],
+        date,
+        extra: {
+          transferId: txArgs.id.parsed?.toString(),
+        },
+      });
+    }
+
+    if (isReceiving) {
+      ops.push({
+        id: encodeOperationId(accountId, deploy_hash, "IN"),
+        hash: deploy_hash,
+        type: "IN",
+        value,
+        fee: feeToUse,
+        blockHeight: 1,
+        blockHash: null,
+        hasFailed: error_message ? true : false,
+        accountId,
+        senders: [fromAccount],
+        recipients: [toAccount],
+        date,
+        extra: {
+          transferId: txArgs.id.parsed?.toString(),
+        },
+      });
+    }
+
+    return ops;
+  };
+}
+
+export const createNewDeploy = (
+  sender: string,
+  recipient: string,
+  amount: BigNumber,
+  fees: BigNumber,
+  transferId?: string,
+  network = CASPER_NETWORK,
+): DeployUtil.Deploy => {
+  log("debug", `Creating new Deploy: ${sender}, ${recipient}, ${network}`);
+
+  if (recipient && !isAddressValid(recipient)) {
+    throw InvalidAddress(`Invalid recipient Address ${recipient}`);
+  }
+
+  const deployParams = new DeployUtil.DeployParams(
+    new CLPublicKey(Buffer.from(getPublicKeyFromCasperAddress(sender), "hex"), 2),
+    network,
+  );
+  const recipientBuff = Buffer.from(getPublicKeyFromCasperAddress(recipient), "hex");
+
+  const session = DeployUtil.ExecutableDeployItem.newTransferWithOptionalTransferId(
+    amount?.toNumber() ?? 0,
+    new CLPublicKey(recipientBuff, getPubKeySignature(recipient ?? sender)),
+    undefined,
+    transferId,
+  );
+
+  const payment = DeployUtil.standardPayment(fees.toString());
+  const deploy = DeployUtil.makeDeploy(deployParams, session, payment);
+  const txnRaw = DeployUtil.deployToJson(deploy);
+  const txnFromRaw = DeployUtil.deployFromJson(txnRaw).unwrap();
+
+  return txnFromRaw;
+};
+
+export function deployHashToString(hash: Uint8Array, toLowerCase?: boolean): string {
+  const str = casperAddressEncode(Buffer.from(hash));
+
+  if (toLowerCase) return str.toLowerCase();
+  return str;
+}