@ledgerhq/coin-casper 1.4.0-next.0

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@ledgerhq/coin-casper",
+  "version": "1.4.0-next.0",
+  "description": "Ledger Casper integration",
+  "keywords": [
+    "Ledger",
+    "LedgerWallet",
+    "cspr",
+    "Casper",
+    "Hardware Wallet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/coin-modules/coin-casper",
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "specs": [
+        "lib/test/bot-specs"
+      ],
+      "*": [
+        "lib/*",
+        "lib/api/*",
+        "lib/bridge/*",
+        "lib/common-logic/*",
+        "lib/signer/*",
+        "lib/test/*",
+        "lib/types/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./api": {
+      "require": "./lib/api/index.js",
+      "default": "./lib-es/api/index.js"
+    },
+    "./deviceTransactionConfig": {
+      "require": "./lib/bridge/deviceTransactionConfig.js",
+      "default": "./lib-es/bridge/deviceTransactionConfig.js"
+    },
+    "./logic": {
+      "require": "./lib/common-logic/index.js",
+      "default": "./lib-es/common-logic/index.js"
+    },
+    "./signer": {
+      "require": "./lib/signer/index.js",
+      "default": "./lib-es/signer/index.js"
+    },
+    "./specs": {
+      "require": "./lib/test/bot-specs.js",
+      "default": "./lib-es/test/bot-specs.js"
+    },
+    "./transaction": {
+      "require": "./lib/bridge/transaction.js",
+      "default": "./lib-es/bridge/transaction.js"
+    },
+    "./types": {
+      "require": "./lib/types/index.js",
+      "default": "./lib-es/types/index.js"
+    },
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    ".": {
+      "require": "./lib/index.js",
+      "default": "./lib-es/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "bignumber.js": "^9.1.2",
+    "invariant": "^2.2.2",
+    "lodash": "^4.17.21",
+    "casper-js-sdk": "^2.15.4",
+    "blakejs": "^1.2.1",
+    "rxjs": "^7.8.1",
+    "@ledgerhq/coin-framework": "^2.1.1-next.0",
+    "@ledgerhq/cryptoassets": "^13.12.0",
+    "@ledgerhq/devices": "8.4.4",
+    "@ledgerhq/errors": "^6.19.1",
+    "@ledgerhq/live-env": "^2.5.0",
+    "@ledgerhq/live-network": "^2.0.4",
+    "@ledgerhq/logs": "^6.12.0",
+    "@ledgerhq/types-live": "^6.61.0-next.0"
+  },
+  "devDependencies": {
+    "@types/invariant": "^2.2.2",
+    "@types/jest": "^29.5.10",
+    "@types/lodash": "^4.14.191",
+    "@types/semver": "^7.5.8",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "expect": "^27.4.6",
+    "axios": "1.7.7",
+    "@ledgerhq/types-cryptoassets": "^7.19.0"
+  },
+  "scripts": {
+    "clean": "rimraf lib lib-es",
+    "build": "tsc --outDir lib --module commonjs --moduleResolution node10 && tsc -m ES6 --outDir lib-es",
+    "coverage": "jest --coverage --testPathIgnorePatterns='/bridge.integration.test.ts|node_modules|lib-es|lib/' --passWithNoTests && mv coverage/coverage-final.json coverage/coverage-casper.json",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "watch:es": "tsc --watch -m ES6 --outDir lib-es",
+    "doc": "documentation readme src/** --section=API --pe ts --re ts --re d.ts",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx --cache",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest",
+    "unimported": "unimported"
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,166 @@
+import { log } from "@ledgerhq/logs";
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+
+import {
+  NDeployMessagePutResponse,
+  IndexerResponseRoot,
+  ITxnHistoryData,
+  NAccountBalance,
+  NAccountInfo,
+  NNetworkStatusResponse,
+  NodeResponseRoot,
+  NodeRPCPayload,
+  NStateRootHashResponse,
+} from "./types";
+
+import network from "@ledgerhq/live-network/network";
+import { AccessRights, CLURef, DeployUtil } from "casper-js-sdk";
+import { getEnv } from "@ledgerhq/live-env";
+
+const getCasperIndexerURL = (path: string): string => {
+  const baseUrl = getEnv("API_CASPER_INDEXER_ENDPOINT");
+  if (!baseUrl) throw new Error("API base URL not available");
+
+  return `${baseUrl}${path}`;
+};
+
+const getCasperNodeURL = (): string => {
+  const baseUrl = getEnv("API_CASPER_NODE_ENDPOINT");
+  if (!baseUrl) throw new Error("API base URL not available");
+
+  return baseUrl;
+};
+
+const casperIndexerWrapper = async <T>(path: string) => {
+  const url = getCasperIndexerURL(path);
+  const getResponse = async (page: number) => {
+    // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+    const opts: AxiosRequestConfig = {
+      method: "GET",
+      url: `${url}?limit=100&page=${page}`,
+    };
+
+    const rawResponse = await network(opts);
+    // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+    const { data } = rawResponse as AxiosResponse<IndexerResponseRoot<T>>;
+
+    return data;
+  };
+
+  let page = 1;
+  const res: T[] = [];
+
+  const data = await getResponse(page);
+  const { pageCount } = data;
+  res.push(...data.data);
+
+  while (page <= pageCount) {
+    page++;
+    const data = await getResponse(page);
+    res.push(...data.data);
+  }
+
+  log("http", url);
+  return res;
+};
+
+const casperNodeWrapper = async <T>(payload: NodeRPCPayload) => {
+  const url = getCasperNodeURL();
+
+  // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+  const opts: AxiosRequestConfig = {
+    method: "POST",
+    url,
+    data: payload,
+  };
+  const rawResponse = await network(opts);
+
+  // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+  const { data } = rawResponse as AxiosResponse<NodeResponseRoot<T>>;
+
+  log("http", url);
+  return data.result;
+};
+
+export const fetchAccountStateInfo = async (
+  publicKey: string,
+): Promise<{
+  purseUref: CLURef | undefined;
+  accountHash: string | undefined;
+}> => {
+  const accountStateInfo = await casperNodeWrapper<NAccountInfo>({
+    jsonrpc: "2.0",
+    method: "state_get_account_info",
+    params: {
+      public_key: publicKey,
+    },
+    id: 1,
+  });
+
+  if (!accountStateInfo) {
+    return {
+      purseUref: undefined,
+      accountHash: undefined,
+    };
+  }
+
+  const accountHash = accountStateInfo.account.account_hash.split("-")[2];
+  const purseURefString = accountStateInfo.account.main_purse.split("-")[1];
+
+  const uRef = new CLURef(Buffer.from(purseURefString, "hex"), AccessRights.READ_ADD_WRITE);
+
+  return { purseUref: uRef, accountHash };
+};
+
+export const fetchBalance = async (purseUref: CLURef): Promise<NAccountBalance> => {
+  const stateRootInfo = await casperNodeWrapper<NStateRootHashResponse>({
+    jsonrpc: "2.0",
+    method: "chain_get_state_root_hash",
+    params: null,
+    id: 1,
+  });
+
+  const accountBalance = await casperNodeWrapper<NAccountBalance>({
+    jsonrpc: "2.0",
+    method: "state_get_balance",
+    params: {
+      purse_uref: purseUref.toFormattedStr(),
+      state_root_hash: stateRootInfo.state_root_hash,
+    },
+    id: 1,
+  });
+
+  return accountBalance;
+};
+
+export const fetchNetworkStatus = async (): Promise<NNetworkStatusResponse> => {
+  const payload: NodeRPCPayload = {
+    id: 1,
+    jsonrpc: "2.0",
+    method: "info_get_status",
+    params: null,
+  };
+  const data = await casperNodeWrapper<NNetworkStatusResponse>(payload);
+
+  return data;
+};
+
+export const fetchTxs = async (addr: string): Promise<ITxnHistoryData[]> => {
+  const response = await casperIndexerWrapper<ITxnHistoryData>(
+    `/accounts/${addr}/ledgerlive-deploys`,
+  );
+  return response;
+};
+
+export const broadcastTx = async (
+  deploy: DeployUtil.Deploy,
+): Promise<NDeployMessagePutResponse> => {
+  const response = await casperNodeWrapper<NDeployMessagePutResponse>({
+    id: 1,
+    jsonrpc: "2.0",
+    method: "account_put_deploy",
+    params: DeployUtil.deployToJson(deploy),
+  });
+
+  return response;
+};

package/src/api/types.ts

@@ -0,0 +1,113 @@
+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;
+          }
+        | string;
+    };
+  };
+  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/bridge/bridgeHelpers/accountShape.ts

@@ -0,0 +1,39 @@
+import flatMap from "lodash/flatMap";
+import { log } from "@ledgerhq/logs";
+import BigNumber from "bignumber.js";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+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/bridge/bridgeHelpers/addresses.ts

@@ -0,0 +1,94 @@
+import { Account } from "@ledgerhq/types-live";
+import { blake2bFinal, blake2bInit, blake2bUpdate } from "blakejs";
+import { CLPublicKey, CLPublicKeyTag } from "casper-js-sdk";
+import { CASPER_CHECKSUM_HEX_LEN } from "../../consts";
+
+export const getAddress = (
+  a: Account,
+): {
+  address: string;
+  derivationPath: string;
+} => ({ address: a.freshAddress, derivationPath: a.freshAddressPath });
+
+export function isAddressValid(pubKey: string): boolean {
+  try {
+    casperGetCLPublicKey(pubKey);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+export function casperGetCLPublicKey(pubkey: string): CLPublicKey {
+  let checksummed = true;
+
+  if (pubkey.toLowerCase() === pubkey) checksummed = false;
+  if (pubkey.toUpperCase() === pubkey) checksummed = false;
+
+  return CLPublicKey.fromHex(pubkey, checksummed);
+}
+
+export function casperAccountHashFromPublicKey(
+  pubKey: string,
+  checksummed: boolean = false,
+): string {
+  const accountHashBuff = casperGetCLPublicKey(pubKey).toAccountHash();
+
+  if (checksummed === false) return Buffer.from(accountHashBuff).toString("hex");
+
+  return casperAddressEncode(Buffer.from(accountHashBuff));
+}
+
+export function casperAddressFromPubKey(pubkey: Buffer, keySig: CLPublicKeyTag): string {
+  return `${keySig.toString().padStart(2, "0")}${Buffer.from(pubkey).toString("hex")}`;
+}
+
+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("");
+}

package/src/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/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/bridge/bridgeHelpers/txn.ts

@@ -0,0 +1,121 @@
+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 { DeployUtil } from "casper-js-sdk";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { CASPER_NETWORK } from "../../consts";
+import { casperAccountHashFromPublicKey, casperGetCLPublicKey, isAddressValid } from "./addresses";
+import { ITxnHistoryData } from "../../api/types";
+import { getEstimatedFees } from "./fee";
+import { CasperOperation } from "../../types";
+import invariant from "invariant";
+
+export const getUnit = (): Unit => getCryptoCurrencyById("casper").units[0];
+
+export function mapTxToOps(
+  accountId: string,
+  addressHash: string,
+  fees = getEstimatedFees(),
+): (tx: ITxnHistoryData) => CasperOperation[] {
+  return (tx: ITxnHistoryData): CasperOperation[] => {
+    try {
+      const ops: CasperOperation[] = [];
+      const { timestamp, caller_public_key, args: txArgs, deploy_hash, error_message } = tx;
+      const fromAccount = casperAccountHashFromPublicKey(caller_public_key);
+      let toAccount;
+
+      if (txArgs.target.cl_type === "PublicKey") {
+        toAccount = casperAccountHashFromPublicKey(txArgs.target.parsed);
+      } else {
+        toAccount = txArgs.target.parsed;
+      }
+      invariant(toAccount, "toAccount is required");
+      invariant(fromAccount, "fromAccount is required");
+
+      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;
+    } catch (err) {
+      log("warn", `mapTxToOps failed for casper, skipping operation`, err);
+      return [];
+    }
+  };
+}
+
+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(casperGetCLPublicKey(sender), network);
+
+  const session = DeployUtil.ExecutableDeployItem.newTransferWithOptionalTransferId(
+    amount?.toNumber() ?? 0,
+    casperGetCLPublicKey(recipient),
+    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;
+};

package/src/bridge/broadcast.ts

@@ -0,0 +1,18 @@
+import { DeployUtil } from "casper-js-sdk";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { Transaction } from "../types";
+import { broadcastTx } from "../api";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation },
+}) => {
+  const tx = DeployUtil.deployFromJson(JSON.parse(signature)).unwrap();
+
+  const resp = await broadcastTx(tx);
+  const { deploy_hash } = resp;
+
+  const result = patchOperationWithHash(operation, deploy_hash);
+
+  return result;
+};