@ledgerhq/coin-casper 1.7.3 → 2.0.0-next.0

package/src/api/index.ts

@@ -1,35 +1,33 @@
 import { log } from "@ledgerhq/logs";
 
-import {
-  NDeployMessagePutResponse,
-  IndexerResponseRoot,
-  ITxnHistoryData,
-  NAccountBalance,
-  NAccountInfo,
-  NNetworkStatusResponse,
-  NodeResponseRoot,
-  NodeRPCPayload,
-  NStateRootHashResponse,
-} from "./types";
+import { IndexerResponseRoot, ITxnHistoryData, RpcError } from "./types";
 
 import network from "@ledgerhq/live-network";
-import { AccessRights, CLURef, DeployUtil } from "casper-js-sdk";
-import { getEnv } from "@ledgerhq/live-env";
+import { AccountIdentifier, HttpHandler, PublicKey, RpcClient, Transaction } from "casper-js-sdk";
+import { getCoinConfig } from "../config";
+import BigNumber from "bignumber.js";
+import { NodeErrorCodeAccountNotFound, NodeErrorCodeQueryFailed } from "../consts";
 
 const getCasperIndexerURL = (path: string): string => {
-  const baseUrl = getEnv("API_CASPER_INDEXER_ENDPOINT");
+  const baseUrl = getCoinConfig().infra.API_CASPER_INDEXER;
   if (!baseUrl) throw new Error("API base URL not available");
 
-  return `${baseUrl}${path}`;
+  return new URL(path, baseUrl).toString();
 };
 
 const getCasperNodeURL = (): string => {
-  const baseUrl = getEnv("API_CASPER_NODE_ENDPOINT");
+  const baseUrl = getCoinConfig().infra.API_CASPER_NODE_ENDPOINT;
   if (!baseUrl) throw new Error("API base URL not available");
 
   return baseUrl;
 };
 
+export const getCasperNodeRpcClient = (): RpcClient => {
+  const url = getCasperNodeURL();
+  const handler = new HttpHandler(url);
+  return new RpcClient(handler);
+};
+
 const casperIndexerWrapper = async <T>(path: string) => {
   const url = getCasperIndexerURL(path);
 
@@ -51,74 +49,30 @@ const casperIndexerWrapper = async <T>(path: string) => {
   }
 };
 
-const casperNodeWrapper = async <T>(payload: NodeRPCPayload) => {
-  const url = getCasperNodeURL();
-
-  try {
-    const rawResponse = await network<NodeResponseRoot<T>>({
-      method: "POST",
-      url,
-      data: payload,
-    });
-    log("http", `${url} - ${payload.method}`);
-
-    const { data, status } = rawResponse;
-
-    if (status >= 300) {
-      log("http", `${url} - Status: ${status}`, data);
-      throw new Error(`HTTP error: ${status}`);
-    }
-
-    if (data.error) {
-      const errorMessage = data.error.message + ". " + data.error.data || "Unknown error";
-      log("http", `${payload.method} - ${errorMessage}`);
-      throw new Error(`Casper node error: ${errorMessage}`);
-    }
-
-    if (!data.result) {
-      throw new Error(`Casper node returned no result for method: ${payload.method}`);
-    }
-
-    return data.result;
-  } catch (error) {
-    log("error", `Failed to execute ${payload.method}`, error);
-    throw error instanceof Error
-      ? error
-      : new Error(`Unknown error during Casper node request: ${String(error)}`);
-  }
-};
-
 export const fetchAccountStateInfo = async (
   publicKey: string,
 ): Promise<{
-  purseUref: CLURef | undefined;
+  purseUref: string | undefined;
   accountHash: string | undefined;
 }> => {
+  const client = getCasperNodeRpcClient();
   try {
-    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 { account } = await client.getAccountInfo(
+      null,
+      new AccountIdentifier(undefined, PublicKey.fromHex(publicKey)),
+    );
 
-    const uRef = new CLURef(Buffer.from(purseURefString, "hex"), AccessRights.READ_ADD_WRITE);
+    const accountHash = account.accountHash.toHex();
+    const purseURefString = account.mainPurse.toPrefixedString();
 
-    return { purseUref: uRef, accountHash };
+    return { purseUref: purseURefString, accountHash };
   } catch (error) {
-    if (error instanceof Error && error.message.includes("No such account")) {
+    if (
+      error instanceof Error &&
+      [NodeErrorCodeAccountNotFound, NodeErrorCodeQueryFailed].includes(
+        (error as RpcError).statusCode,
+      )
+    ) {
       return {
         purseUref: undefined,
         accountHash: undefined,
@@ -128,37 +82,27 @@ export const fetchAccountStateInfo = async (
   }
 };
 
-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 fetchBalance = async (purseUref: string): Promise<BigNumber> => {
+  const client = getCasperNodeRpcClient();
+  try {
+    const { stateRootHash } = await client.getStateRootHashLatest();
+    const balance = await client.getBalanceByStateRootHash(purseUref, stateRootHash.toHex());
+    return new BigNumber(balance.balanceValue.toString());
+  } catch (error) {
+    log("error", "Failed to fetch balance", error);
+    throw error;
+  }
 };
 
-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 fetchBlockHeight = async (): Promise<number> => {
+  const client = getCasperNodeRpcClient();
+  try {
+    const latestBlock = await client.getLatestBlock();
+    return latestBlock.block.height;
+  } catch (error) {
+    log("error", "Failed to fetch block height", error);
+    throw error;
+  }
 };
 
 export const fetchTxs = async (addr: string): Promise<ITxnHistoryData[]> => {
@@ -167,29 +111,27 @@ export const fetchTxs = async (addr: string): Promise<ITxnHistoryData[]> => {
   const limit = 100;
 
   let response = await casperIndexerWrapper<ITxnHistoryData>(
-    `/accounts/${addr}/ledgerlive-deploys?limit=${limit}&page=${page}`,
+    `accounts/${addr}/ledgerlive-deploys?limit=${limit}&page=${page}`,
   );
   res = res.concat(response.data);
 
   while (response.pageCount > page) {
     page++;
     response = await casperIndexerWrapper<ITxnHistoryData>(
-      `/accounts/${addr}/ledgerlive-deploys?limit=${limit}&page=${page}`,
+      `accounts/${addr}/ledgerlive-deploys?limit=${limit}&page=${page}`,
     );
     res = res.concat(response.data);
   }
   return res;
 };
 
-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;
+export const broadcastTx = async (transaction: Transaction): Promise<string> => {
+  const client = getCasperNodeRpcClient();
+  try {
+    const response = await client.putTransaction(transaction);
+    return response.transactionHash.toHex();
+  } catch (error) {
+    log("error", "Failed to broadcast transaction", error);
+    throw error;
+  }
 };

package/src/api/types.ts

@@ -1,15 +1,3 @@
-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;
@@ -52,67 +40,6 @@ export interface ITxnHistoryData {
   amount: string;
 }
 
-export interface NodeResponseRoot<T> {
-  jsonrpc: string;
-  id: string;
-  result?: T;
-  error?: {
-    code: number;
-    message: string;
-    data: string;
-  };
-}
-
-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;
+export interface RpcError extends Error {
+  statusCode: number;
 }

package/src/bridge/bridgeHelpers/accountShape.test.ts

@@ -0,0 +1,122 @@
+import BigNumber from "bignumber.js";
+import { fetchBalance, fetchBlockHeight, fetchAccountStateInfo, fetchTxs } from "../../api/index";
+import { mapTxToOps } from "./txn";
+import { getAccountShape } from "./accountShape";
+import { createMockAccountShapeData } from "../../test/fixtures";
+import { SyncConfig } from "@ledgerhq/types-live";
+
+// Mock dependencies
+jest.mock("../../api/index");
+jest.mock("./txn");
+
+describe("getAccountShape", () => {
+  const {
+    mockAddress,
+    mockAccountInfo,
+    mockAccountId,
+    mockBlockHeight,
+    mockPurseUref,
+    mockAccountHash,
+    mockBalance,
+    mockTxs,
+    mockOperations,
+  } = createMockAccountShapeData();
+
+  // Define a mock SyncConfig as required by the getAccountShape function
+  const mockSyncConfig: SyncConfig = {
+    paginationConfig: {},
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Default mock implementations
+    (fetchAccountStateInfo as jest.Mock).mockResolvedValue({
+      purseUref: mockPurseUref,
+      accountHash: mockAccountHash,
+    });
+
+    (fetchBlockHeight as jest.Mock).mockResolvedValue(mockBlockHeight);
+
+    (fetchBalance as jest.Mock).mockResolvedValue(mockBalance);
+
+    (fetchTxs as jest.Mock).mockResolvedValue(mockTxs);
+
+    (mapTxToOps as jest.Mock).mockImplementation(() => () => mockOperations);
+  });
+
+  test("should return the correct account shape for an account with balance", async () => {
+    const accountShape = await getAccountShape(mockAccountInfo, mockSyncConfig);
+
+    expect(fetchAccountStateInfo).toHaveBeenCalledWith(mockAddress);
+    expect(fetchBlockHeight).toHaveBeenCalled();
+    expect(fetchBalance).toHaveBeenCalledWith(mockPurseUref);
+    expect(fetchTxs).toHaveBeenCalledWith(mockAddress);
+    expect(mapTxToOps).toHaveBeenCalledWith(mockAccountId, mockAccountHash);
+
+    expect(accountShape).toEqual({
+      id: mockAccountId,
+      balance: mockBalance,
+      spendableBalance: mockBalance,
+      operations: mockOperations,
+      blockHeight: mockBlockHeight,
+    });
+  });
+
+  test("should return account with zero balance when purseUref is not found", async () => {
+    (fetchAccountStateInfo as jest.Mock).mockResolvedValue({
+      purseUref: undefined,
+      accountHash: mockAccountHash,
+    });
+
+    const accountShape = await getAccountShape(mockAccountInfo, mockSyncConfig);
+
+    expect(fetchAccountStateInfo).toHaveBeenCalledWith(mockAddress);
+    expect(fetchBlockHeight).toHaveBeenCalled();
+    expect(fetchBalance).not.toHaveBeenCalled();
+    expect(fetchTxs).not.toHaveBeenCalled();
+
+    expect(accountShape).toEqual({
+      id: mockAccountId,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      operations: [],
+      blockHeight: mockBlockHeight,
+    });
+  });
+
+  test("should return account with operations even when accountHash is not found", async () => {
+    (fetchAccountStateInfo as jest.Mock).mockResolvedValue({
+      purseUref: mockPurseUref,
+      accountHash: undefined,
+    });
+
+    const accountShape = await getAccountShape(mockAccountInfo, mockSyncConfig);
+
+    expect(fetchAccountStateInfo).toHaveBeenCalledWith(mockAddress);
+    expect(fetchBlockHeight).toHaveBeenCalled();
+    expect(fetchBalance).toHaveBeenCalledWith(mockPurseUref);
+    expect(fetchTxs).toHaveBeenCalledWith(mockAddress);
+    expect(mapTxToOps).toHaveBeenCalledWith(mockAccountId, "");
+
+    expect(accountShape).toEqual({
+      id: mockAccountId,
+      balance: mockBalance,
+      spendableBalance: mockBalance,
+      operations: mockOperations,
+      blockHeight: mockBlockHeight,
+    });
+  });
+
+  test("should handle API errors appropriately", async () => {
+    const errorMessage = "API Error";
+    (fetchAccountStateInfo as jest.Mock).mockRejectedValue(new Error(errorMessage));
+
+    await expect(getAccountShape(mockAccountInfo, mockSyncConfig)).rejects.toThrow(errorMessage);
+
+    expect(fetchAccountStateInfo).toHaveBeenCalledWith(mockAddress);
+    expect(fetchBlockHeight).not.toHaveBeenCalled();
+    expect(fetchBalance).not.toHaveBeenCalled();
+    expect(fetchTxs).not.toHaveBeenCalled();
+  });
+});

package/src/bridge/bridgeHelpers/accountShape.ts

@@ -3,9 +3,9 @@ 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 { fetchBalance, fetchBlockHeight, fetchAccountStateInfo, fetchTxs } from "../../api/index";
 import { mapTxToOps } from "./txn";
-import { NAccountBalance, ITxnHistoryData } from "../../api/types";
+import { ITxnHistoryData } from "../../api/types";
 
 export const getAccountShape: GetAccountShape = async info => {
   const { address, currency, derivationMode } = info;
@@ -22,18 +22,16 @@ export const getAccountShape: GetAccountShape = async info => {
 
   const { purseUref, accountHash } = await fetchAccountStateInfo(address);
 
-  const blockHeight = await fetchNetworkStatus();
+  const blockHeight = await fetchBlockHeight();
 
-  const balance: NAccountBalance = purseUref
-    ? await fetchBalance(purseUref)
-    : { balance_value: "0", api_version: "", merkle_proof: "" };
+  const balance = purseUref ? await fetchBalance(purseUref) : new BigNumber(0);
   const txs: ITxnHistoryData[] = purseUref ? await fetchTxs(address) : [];
 
   return {
     id: accountId,
-    balance: new BigNumber(balance.balance_value),
-    spendableBalance: new BigNumber(balance.balance_value),
+    balance,
+    spendableBalance: balance,
     operations: flatMap(txs, mapTxToOps(accountId, accountHash ?? "")),
-    blockHeight: blockHeight.last_added_block_info.height,
+    blockHeight,
   };
 };

package/src/bridge/bridgeHelpers/addresses.ts

@@ -1,7 +1,5 @@
 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";
+import { PublicKey, KeyAlgorithm } from "casper-js-sdk";
 
 export const getAddress = (
   a: Account,
@@ -11,84 +9,19 @@ export const getAddress = (
 } => ({ address: a.freshAddress, derivationPath: a.freshAddressPath });
 
 export function isAddressValid(pubKey: string): boolean {
+  const checksummed = pubKey.toLowerCase() !== pubKey && pubKey.toUpperCase() !== pubKey;
   try {
-    casperGetCLPublicKey(pubKey);
+    PublicKey.fromHex(pubKey, checksummed).accountHash().toHex();
     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 casperAccountHashFromPublicKey(pubKey: string): string {
+  return PublicKey.fromHex(pubKey).accountHash().toHex();
 }
 
-export function casperAddressFromPubKey(pubkey: Buffer, keySig: CLPublicKeyTag): string {
+export function casperAddressFromPubKey(pubkey: Buffer, keySig: KeyAlgorithm): 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("");
-}