@ledgerhq/coin-solana 0.7.0-next.0

package/src/api/traced.ts

@@ -0,0 +1,89 @@
+import { log } from "@ledgerhq/logs";
+import { getEnv } from "@ledgerhq/live-env";
+import { ChainAPI } from "./chain";
+
+export function traced(api: ChainAPI): ChainAPI {
+  const state = {
+    reqId: 0,
+    reqStartTime: new Map<number, number>(),
+  };
+
+  const startReqTrace = () => {
+    state.reqId += 1;
+    state.reqStartTime.set(state.reqId, Date.now());
+    return state.reqId;
+  };
+
+  const stopReqTrace = (reqId: number) => {
+    const reqStartTime = state.reqStartTime.get(reqId);
+    if (reqStartTime === undefined) {
+      log("warn", `request start time not found for request id <${reqId}>`);
+      return {
+        duration: 0,
+      };
+    }
+    state.reqStartTime.delete(reqId);
+    return {
+      duration: Date.now() - reqStartTime,
+    };
+  };
+
+  const proxy: ChainAPI = new Proxy(api, {
+    get(target, propKey, receiver) {
+      if (typeof propKey === "symbol") {
+        throw new Error("symbols not supported");
+      }
+      const targetValue = Reflect.get(target, propKey, receiver);
+      if (typeof targetValue === "function") {
+        return function (...args: unknown[]) {
+          const reqId = startReqTrace();
+          log("network", formatMsg({ reqId, msg: `calling <${propKey}>` }), {
+            args,
+          });
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore: TS-2683
+          const result = targetValue.apply(this, args);
+          if (result instanceof Promise) {
+            return result
+              .then(answer => {
+                const { duration } = stopReqTrace(reqId);
+                log(
+                  "network-success",
+                  formatMsg({ reqId, msg: "success", duration }),
+                  getEnv("DEBUG_HTTP_RESPONSE") ? { answer } : undefined,
+                );
+                return answer;
+              })
+              .catch(error => {
+                const { duration } = stopReqTrace(reqId);
+                log("network-error", formatMsg({ reqId, msg: "error", duration }), { error });
+                throw error;
+              });
+          } else {
+            const { duration } = stopReqTrace(reqId);
+            log(
+              "info",
+              formatMsg({ reqId, msg: "sync result", duration }),
+              getEnv("DEBUG_HTTP_RESPONSE") ? { result } : undefined,
+            );
+            return result;
+          }
+        };
+      } else {
+        return targetValue;
+      }
+    },
+  });
+
+  return proxy;
+}
+
+function formatMsg({ reqId, msg, duration }: { reqId: number; msg?: string; duration?: number }) {
+  const parts = [
+    `solana req id: ${reqId}`,
+    msg ?? "",
+    duration === undefined ? "" : `took ${duration.toFixed(0)}ms`,
+  ];
+
+  return parts.join(", ");
+}

package/src/bridge/bridge.ts

@@ -0,0 +1,192 @@
+import {
+  defaultUpdateTransaction,
+  GetAccountShape,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { minutes, makeLRUCache } from "@ledgerhq/live-network/cache";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { AccountBridge, AccountLike, CurrencyBridge } from "@ledgerhq/types-live";
+import type { SolanaAccount, SolanaPreloadDataV1, Transaction, TransactionStatus } from "../types";
+import { prepareTransaction as prepareTransactionWithAPI } from "../prepareTransaction";
+import { estimateMaxSpendableWithAPI } from "../estimateMaxSpendable";
+import { PRELOAD_MAX_AGE, hydrate, preloadWithAPI } from "../preload";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { getAccountShapeWithAPI } from "../synchronization";
+import { createTransaction } from "../createTransaction";
+import { buildSignOperation } from "../signOperation";
+import { endpointByCurrencyId } from "../utils";
+import { broadcastWithAPI } from "../broadcast";
+import { ChainAPI, Config } from "../api";
+import { SolanaSigner } from "../signer";
+import resolver from "../hw-getAddress";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  fromOperationExtraRaw,
+  toOperationExtraRaw,
+} from "../serialization";
+
+function makePrepare(getChainAPI: (config: Config) => Promise<ChainAPI>) {
+  const prepareTransaction: AccountBridge<
+    Transaction,
+    SolanaAccount
+  >["prepareTransaction"] = async (mainAccount, transaction) => {
+    const config: Config = {
+      endpoint: endpointByCurrencyId(mainAccount.currency.id),
+    };
+
+    const chainAPI = await getChainAPI(config);
+    return prepareTransactionWithAPI(mainAccount, transaction, chainAPI);
+  };
+
+  return prepareTransaction;
+}
+
+function makeSyncAndScan(
+  getChainAPI: (config: Config) => Promise<ChainAPI>,
+  getAddress: GetAddressFn,
+) {
+  const getAccountShape: GetAccountShape<SolanaAccount> = async info => {
+    const config: Config = {
+      endpoint: endpointByCurrencyId(info.currency.id),
+    };
+
+    const chainAPI = await getChainAPI(config);
+    return getAccountShapeWithAPI(info, chainAPI);
+  };
+  return {
+    sync: makeSync({ getAccountShape }),
+    scan: makeScanAccounts({ getAccountShape, getAddressFn: getAddress }),
+  };
+}
+
+function makeEstimateMaxSpendable(getChainAPI: (config: Config) => Promise<ChainAPI>) {
+  const estimateMaxSpendable: AccountBridge<
+    Transaction,
+    SolanaAccount
+  >["estimateMaxSpendable"] = async arg => {
+    const { account, parentAccount } = arg;
+
+    const currencyId =
+      account.type === "Account" ? account.currency.id : parentAccount?.currency.id;
+
+    if (currencyId === undefined) {
+      throw new Error("currency not found");
+    }
+
+    const config: Config = {
+      endpoint: endpointByCurrencyId(currencyId),
+    };
+
+    const api = await getChainAPI(config);
+
+    return estimateMaxSpendableWithAPI(arg, api);
+  };
+
+  const cacheKeyByAccSpendableBalance = ({
+    account,
+    transaction,
+  }: {
+    account: AccountLike;
+    transaction?: Transaction | null | undefined;
+  }) => {
+    return `${account.id}:${account.spendableBalance.toString()}:tx:${
+      transaction?.model.kind ?? "<no transaction>"
+    }`;
+  };
+
+  return makeLRUCache(estimateMaxSpendable, cacheKeyByAccSpendableBalance, minutes(5));
+}
+
+function makeBroadcast(
+  getChainAPI: (config: Config) => Promise<ChainAPI>,
+): AccountBridge<Transaction, SolanaAccount>["broadcast"] {
+  return async info => {
+    const config: Config = {
+      endpoint: endpointByCurrencyId(info.account.currency.id),
+    };
+    const api = await getChainAPI(config);
+    return broadcastWithAPI(info, api);
+  };
+}
+
+function makeSign(
+  getChainAPI: (config: Config) => Promise<ChainAPI>,
+  signerContext: SignerContext<SolanaSigner>,
+): AccountBridge<Transaction, SolanaAccount>["signOperation"] {
+  return info => {
+    const config: Config = {
+      endpoint: endpointByCurrencyId(info.account.currency.id),
+    };
+    const api = () => getChainAPI(config);
+    return buildSignOperation(signerContext, api)(info);
+  };
+}
+
+function makePreload(
+  getChainAPI: (config: Config) => Promise<ChainAPI>,
+): CurrencyBridge["preload"] {
+  const preload: CurrencyBridge["preload"] = (currency): Promise<SolanaPreloadDataV1> => {
+    const config: Config = {
+      endpoint: endpointByCurrencyId(currency.id),
+    };
+    const api = () => getChainAPI(config);
+    return preloadWithAPI(currency, api);
+  };
+  return preload;
+}
+
+function getPreloadStrategy() {
+  return {
+    preloadMaxAge: PRELOAD_MAX_AGE,
+  };
+}
+
+export function makeBridges({
+  getAPI,
+  getQueuedAPI,
+  getQueuedAndCachedAPI,
+  signerContext,
+}: {
+  getAPI: (config: Config) => Promise<ChainAPI>;
+  getQueuedAPI: (config: Config) => Promise<ChainAPI>;
+  getQueuedAndCachedAPI: (config: Config) => Promise<ChainAPI>;
+  signerContext: SignerContext<SolanaSigner>;
+}): {
+  currencyBridge: CurrencyBridge;
+  accountBridge: AccountBridge<Transaction, SolanaAccount, TransactionStatus>;
+} {
+  const getAddress = resolver(signerContext);
+  const { sync, scan } = makeSyncAndScan(getQueuedAPI, getAddress);
+
+  const accountBridge: AccountBridge<Transaction, SolanaAccount, TransactionStatus> = {
+    createTransaction,
+    updateTransaction: defaultUpdateTransaction,
+    estimateMaxSpendable: makeEstimateMaxSpendable(getQueuedAndCachedAPI),
+    getTransactionStatus,
+    sync,
+    receive: makeAccountBridgeReceive(getAddress),
+    prepareTransaction: makePrepare(getQueuedAndCachedAPI),
+    broadcast: makeBroadcast(getAPI),
+    signOperation: makeSign(getAPI, signerContext),
+    assignFromAccountRaw,
+    assignToAccountRaw,
+    toOperationExtraRaw,
+    fromOperationExtraRaw,
+  };
+
+  const currencyBridge: CurrencyBridge = {
+    preload: makePreload(getQueuedAndCachedAPI),
+    hydrate,
+    scanAccounts: scan,
+    getPreloadStrategy,
+  };
+
+  return {
+    currencyBridge,
+    accountBridge,
+  };
+}

package/src/bridge/js.ts

@@ -0,0 +1,42 @@
+import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
+import { log } from "@ledgerhq/logs";
+import { cached, Config, getChainAPI, queued } from "../api";
+import { traced } from "../api/traced";
+import { makeBridges } from "./bridge";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { SolanaSigner } from "../signer";
+
+const httpRequestLogger = (url: string, options: any) => {
+  log("network", url, {
+    method: options?.method,
+    body: options?.body,
+    params: options?.params,
+  });
+};
+
+const getAPI = makeLRUCache(
+  (config: Config) => Promise.resolve(traced(getChainAPI(config, httpRequestLogger))),
+  config => config.endpoint,
+  minutes(1000),
+);
+
+const getQueuedAPI = makeLRUCache(
+  (config: Config) => getAPI(config).then(api => queued(api, 500)),
+  config => config.endpoint,
+  minutes(1000),
+);
+
+const getQueuedAndCachedAPI = makeLRUCache(
+  (config: Config) => getQueuedAPI(config).then(cached),
+  config => config.endpoint,
+  minutes(1000),
+);
+
+export function createBridges(signerContext: SignerContext<SolanaSigner>) {
+  return makeBridges({
+    getAPI,
+    getQueuedAPI,
+    getQueuedAndCachedAPI,
+    signerContext,
+  });
+}