@ledgerhq/live-common 34.51.0-nightly.1 → 34.51.0-nightly.2

package/src/hw/actions/rawTransaction.ts

@@ -0,0 +1,190 @@
+import { of, Observable } from "rxjs";
+import { scan, catchError, tap } from "rxjs/operators";
+import { useEffect, useState } from "react";
+import { log } from "@ledgerhq/logs";
+import { TransportStatusError } from "@ledgerhq/errors";
+import { TransactionRefusedOnDevice } from "../../errors";
+import { getMainAccount } from "../../account";
+import { getAccountBridge } from "../../bridge";
+import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
+import type { Action, Device } from "./types";
+import type { AppRequest, AppState } from "./app";
+import { createAction as createAppAction } from "./app";
+import type {
+  Account,
+  AccountLike,
+  SignedOperation,
+  SignOperationEvent,
+} from "@ledgerhq/types-live";
+
+type State = {
+  signedOperation: SignedOperation | null | undefined;
+  deviceSignatureRequested: boolean;
+  deviceStreamingProgress: number | null | undefined;
+  transactionSignError: Error | null | undefined;
+  transactionChecksOptInTriggered: boolean;
+  transactionChecksOptIn: boolean | null;
+  manifestId?: string;
+  manifestName?: string;
+};
+type RawTransactionState = AppState & State;
+type RawTransactionRequest = {
+  parentAccount: Account | null | undefined;
+  account: AccountLike;
+  transaction: string;
+  appName?: string;
+  dependencies?: AppRequest[];
+  requireLatestFirmware?: boolean;
+  manifestId?: string;
+  manifestName?: string;
+};
+export type RawTransactionResult =
+  | {
+      signedOperation: SignedOperation;
+      device: Device;
+      swapId?: string;
+    }
+  | {
+      transactionSignError: Error;
+    };
+type TransactionAction = Action<RawTransactionRequest, RawTransactionState, RawTransactionResult>;
+
+const mapResult = ({
+  device,
+  signedOperation,
+  transactionSignError,
+}: RawTransactionState): RawTransactionResult | null | undefined =>
+  signedOperation && device
+    ? {
+        signedOperation,
+        device,
+      }
+    : transactionSignError
+      ? {
+          transactionSignError,
+        }
+      : null;
+
+type Event =
+  | SignOperationEvent
+  | {
+      type: "error";
+      error: Error;
+    };
+const initialState = {
+  signedOperation: null,
+  deviceSignatureRequested: false,
+  deviceStreamingProgress: null,
+  transactionSignError: null,
+  transactionChecksOptInTriggered: false,
+  transactionChecksOptIn: null,
+};
+
+const reducer = (state: State, e: Event): State => {
+  switch (e.type) {
+    case "error": {
+      const { error } = e;
+      const transactionSignError =
+        error instanceof TransportStatusError && error.statusCode === 0x6985
+          ? new TransactionRefusedOnDevice()
+          : error;
+      return { ...initialState, transactionSignError };
+    }
+
+    case "signed":
+      return { ...state, signedOperation: e.signedOperation };
+
+    case "device-signature-requested":
+      return { ...state, deviceSignatureRequested: true };
+
+    case "device-signature-granted":
+      return { ...state, deviceSignatureRequested: false };
+
+    case "device-streaming":
+      return { ...state, deviceStreamingProgress: e.progress };
+
+    case "transaction-checks-opt-in-triggered":
+      return { ...state, transactionChecksOptInTriggered: true };
+
+    case "transaction-checks-opt-in":
+      return { ...state, transactionChecksOptIn: true };
+
+    case "transaction-checks-opt-out":
+      return { ...state, transactionChecksOptIn: false };
+
+    default:
+      return state;
+  }
+};
+
+export const createAction = (
+  connectAppExec: (arg0: ConnectAppInput) => Observable<ConnectAppEvent>,
+): TransactionAction => {
+  const useHook = (
+    reduxDevice: Device | null | undefined,
+    {
+      account,
+      parentAccount,
+      transaction,
+      appName,
+      dependencies,
+      requireLatestFirmware,
+      manifestId,
+      manifestName,
+    }: RawTransactionRequest,
+  ): RawTransactionState => {
+    const mainAccount = getMainAccount(account, parentAccount);
+    const appState = createAppAction(connectAppExec).useHook(reduxDevice, {
+      account: mainAccount,
+      appName,
+      dependencies,
+      requireLatestFirmware,
+    });
+    const { device, opened, inWrongDeviceForAccount, error } = appState;
+    const [state, setState] = useState(initialState);
+    useEffect(() => {
+      if (!device || !opened || inWrongDeviceForAccount || error) {
+        setState(initialState);
+        return;
+      }
+
+      const bridge = getAccountBridge(mainAccount);
+      const sub = bridge
+        .signRawOperation({
+          account: mainAccount,
+          transaction,
+          deviceId: device.deviceId,
+          deviceModelId: device.modelId,
+        })
+        .pipe(
+          catchError(error =>
+            of<{ type: "error"; error: Error }>({
+              type: "error",
+              error,
+            }),
+          ),
+          tap((e: Event) => log("actions-transaction-event", e.type, e)),
+          scan(reducer, initialState),
+        )
+        .subscribe((x: any) => setState(x));
+      return () => {
+        sub.unsubscribe();
+      };
+    }, [device, mainAccount, transaction, opened, inWrongDeviceForAccount, error]);
+    return {
+      ...appState,
+      ...state,
+      manifestId,
+      manifestName,
+      deviceStreamingProgress:
+        state.signedOperation || state.transactionSignError
+          ? null // when good app is opened, we start the progress so it doesn't "blink"
+          : state.deviceStreamingProgress || (appState.opened ? 0 : null),
+    };
+  };
+
+  return {
+    useHook,
+    mapResult,
+  };
+};

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -73,6 +73,9 @@ export function useCurrenciesUnderFeatureFlag() {
   const kaspa = useFeature("currencyKaspa");
   const core = useFeature("currencyCore");
   const ethereumHoodi = useFeature("currencyEthereumHoodi");
+  const westend = useFeature("currencyWestend");
+  const assetHubWestend = useFeature("currencyAssetHubWestend");
+  const assetHubPolkadot = useFeature("currencyAssetHubPolkadot");
 
   const featureFlaggedCurrencies = useMemo(
     (): Partial<Record<CryptoCurrencyId, Feature<unknown> | null>> => ({
@@ -142,6 +145,9 @@ export function useCurrenciesUnderFeatureFlag() {
       kaspa,
       core,
       ethereum_hoodi: ethereumHoodi,
+      westend,
+      assethub_westend: assetHubWestend,
+      assethub_polkadot: assetHubPolkadot,
     }),
     [
       aptos,
@@ -210,6 +216,9 @@ export function useCurrenciesUnderFeatureFlag() {
       kaspa,
       core,
       ethereumHoodi,
+      westend,
+      assetHubWestend,
+      assetHubPolkadot,
     ],
   );
 

package/src/wallet-api/logic.ts

@@ -139,6 +139,41 @@ export function signTransactionLogic(
   });
 }
 
+export function signRawTransactionLogic(
+  { manifest, accounts, tracking }: WalletAPIContext,
+  walletAccountId: string,
+  transaction: string,
+  uiNavigation: (
+    account: AccountLike,
+    parentAccount: Account | undefined,
+    transaction: string,
+  ) => Promise<SignedOperation>,
+): Promise<SignedOperation> {
+  tracking.signRawTransactionRequested(manifest);
+
+  if (!transaction) {
+    tracking.signRawTransactionFail(manifest);
+    return Promise.reject(new Error("Transaction required"));
+  }
+
+  const accountId = getAccountIdFromWalletAccountId(walletAccountId);
+  if (!accountId) {
+    tracking.signRawTransactionFail(manifest);
+    return Promise.reject(new Error(`accountId ${walletAccountId} unknown`));
+  }
+
+  const account = accounts.find(account => account.id === accountId);
+
+  if (!account) {
+    tracking.signRawTransactionFail(manifest);
+    return Promise.reject(new Error("Account required"));
+  }
+
+  const parentAccount = getParentAccount(account, accounts);
+
+  return uiNavigation(account, parentAccount, transaction);
+}
+
 export function broadcastTransactionLogic(
   { manifest, accounts, tracking }: WalletAPIContext,
   walletAccountId: string,

package/src/wallet-api/react.ts

@@ -37,6 +37,7 @@ import {
   signTransactionLogic,
   bitcoinFamilyAccountGetAddressLogic,
   bitcoinFamilyAccountGetPublicKeyLogic,
+  signRawTransactionLogic,
 } from "./logic";
 import { getAccountBridge } from "../bridge";
 import { getEnv } from "@ledgerhq/live-env";
@@ -154,6 +155,14 @@ export interface UiHook {
   }) => void;
   "storage.get": WalletHandlers["storage.get"];
   "storage.set": WalletHandlers["storage.set"];
+  "transaction.signRaw": (params: {
+    account: AccountLike;
+    parentAccount: Account | undefined;
+    transaction: string;
+    options: Parameters<WalletHandlers["transaction.sign"]>[0]["options"];
+    onSuccess: (signedOperation: SignedOperation) => void;
+    onError: (error: Error) => void;
+  }) => void;
   "transaction.sign": (params: {
     account: AccountLike;
     parentAccount: Account | undefined;
@@ -320,6 +329,7 @@ export function useWalletAPIServer({
     "storage.get": uiStorageGet,
     "storage.set": uiStorageSet,
     "transaction.sign": uiTxSign,
+    "transaction.signRaw": uiTxSignRaw,
     "transaction.broadcast": uiTxBroadcast,
     "device.transport": uiDeviceTransport,
     "device.select": uiDeviceSelect,
@@ -536,6 +546,82 @@ export function useWalletAPIServer({
     );
   }, [accounts, manifest, server, tracking, uiTxSign]);
 
+  useEffect(() => {
+    if (!uiTxSignRaw) return;
+
+    server.setHandler(
+      "transaction.signRaw",
+      async ({ account, transaction, broadcast, options }) => {
+        const signedOperation = await signRawTransactionLogic(
+          { manifest, accounts, tracking },
+          account.id,
+          transaction,
+          (account, parentAccount, tx) =>
+            new Promise((resolve, reject) => {
+              let done = false;
+              return uiTxSignRaw({
+                account,
+                parentAccount,
+                transaction: tx,
+                options,
+                onSuccess: signedOperation => {
+                  if (done) return;
+                  done = true;
+                  tracking.signRawTransactionSuccess(manifest);
+                  resolve(signedOperation);
+                },
+                onError: error => {
+                  if (done) return;
+                  done = true;
+                  tracking.signRawTransactionFail(manifest);
+                  reject(error);
+                },
+              });
+            }),
+        );
+
+        let hash: string | undefined;
+        if (broadcast) {
+          hash = await broadcastTransactionLogic(
+            { manifest, accounts, tracking },
+            account.id,
+            signedOperation,
+            async (account, parentAccount, signedOperation) => {
+              const bridge = getAccountBridge(account, parentAccount);
+              const mainAccount = getMainAccount(account, parentAccount);
+
+              let optimisticOperation: Operation = signedOperation.operation;
+
+              if (!getEnv("DISABLE_TRANSACTION_BROADCAST")) {
+                try {
+                  optimisticOperation = await bridge.broadcast({
+                    account: mainAccount,
+                    signedOperation,
+                    broadcastConfig: { mevProtected: !!config.mevProtected },
+                  });
+                  tracking.broadcastSuccess(manifest);
+                } catch (error) {
+                  tracking.broadcastFail(manifest);
+                  throw error;
+                }
+              }
+
+              uiTxBroadcast &&
+                uiTxBroadcast(account, parentAccount, mainAccount, optimisticOperation);
+
+              return optimisticOperation.hash;
+            },
+          );
+        }
+
+        return {
+          signedTransactionHex: signedOperation.signature,
+          transactionHash: hash,
+        };
+      },
+    );
+  }, [accounts, config.mevProtected, manifest, server, tracking, uiTxBroadcast, uiTxSignRaw]);
+
   useEffect(() => {
     if (!uiTxSign) return;
 
@@ -604,7 +690,7 @@ export function useWalletAPIServer({
         );
       },
     );
-  }, [accounts, manifest, server, tracking, uiTxBroadcast, uiTxSign]);
+  }, [accounts, config.mevProtected, manifest, server, tracking, uiTxBroadcast, uiTxSign]);
 
   const onLoad = useCallback(() => {
     tracking.loadSuccess(manifest);

package/src/wallet-api/tracking.ts

@@ -70,6 +70,21 @@ export default function trackingWrapper(trackCall: TrackWalletAPI) {
       track("WalletAPI SignTransaction Success", getEventData(manifest));
     },
 
+    // Sign Raw transaction modal open
+    signRawTransactionRequested: (manifest: AppManifest) => {
+      track("WalletAPI SignRawTransaction", getEventData(manifest));
+    },
+
+    // Failed to sign raw transaction (cancel or error)
+    signRawTransactionFail: (manifest: AppManifest) => {
+      track("WalletAPI SignRawTransaction Fail", getEventData(manifest));
+    },
+
+    // Successfully signed raw transaction
+    signRawTransactionSuccess: (manifest: AppManifest) => {
+      track("WalletAPI SignRawTransaction Success", getEventData(manifest));
+    },
+
     // Select account modal open
     requestAccountRequested: (manifest: AppManifest) => {
       track("WalletAPI RequestAccount", getEventData(manifest));