Merge branch 'main' into feat/unbonding-period

apps/extension/src/App/App.tsx

@@ -9,36 +9,42 @@ import routes from "./routes";
 export const App: React.FC = () => {
   const location = useLocation();
 
-  const { isLocked, unlock, passwordInitialized } = useVaultContext();
+  const { lockStatus, unlock, passwordInitialized } = useVaultContext();
 
   const displayReturnButton = (): boolean => {
     const setupRoute = routes.setup();
     const indexRoute = routes.viewAccountList();
     return Boolean(
-      !isLocked &&
-        isLocked !== undefined &&
+      lockStatus === "unlocked" &&
         !matchPath(setupRoute, location.pathname) &&
         !matchPath(indexRoute, location.pathname)
     );
   };
 
-  const shouldLock = passwordInitialized && isLocked;
-  if (passwordInitialized === undefined) return null;
+  if (passwordInitialized === undefined || lockStatus === "pending") {
+    return null;
+  }
+
+  const shouldLock = passwordInitialized && lockStatus === "locked";
 
   return (
     <Container
       size="popup"
       header={
         <AppHeader
-          settingsButton={!isLocked && passwordInitialized}
+          settingsButton={lockStatus === "unlocked" && passwordInitialized}
           lockButton={
-            !isLocked && passwordInitialized && !displayReturnButton()
+            lockStatus === "unlocked" &&
+            passwordInitialized &&
+            !displayReturnButton()
           }
           returnButton={displayReturnButton()}
         />
       }
     >
-      {shouldLock ? <Login onLogin={unlock} /> : <AppContent />}
+      {shouldLock ?
+        <Login onLogin={unlock} />
+      : <AppContent />}
     </Container>
   );
 };

apps/extension/src/Setup/Ledger/LedgerConfirmation.tsx

@@ -22,6 +22,7 @@ export const LedgerConfirmation = (): JSX.Element => {
       <ViewKeys
         publicKeyAddress={account.publicKey}
         transparentAccountAddress={account.address}
+        trimCharacters={35}
       />
       <ActionButton size="lg" onClick={closeCurrentTab}>
         Finish Setup

apps/extension/src/background/approvals/handler.test.ts

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { WrapperTxMsgValue } from "@namada/types";
+import BigNumber from "bignumber.js";
 import createMockInstance from "jest-create-mock-instance";
 import {
   ApproveConnectInterfaceMsg,
@@ -46,7 +48,19 @@ describe("approvals handler", () => {
     };
 
     const approveTxMsg = new ApproveSignTxMsg(
-      [{ txBytes: "", signingDataBytes: [""] }],
+      [
+        {
+          args: new WrapperTxMsgValue({
+            token: "",
+            feeAmount: BigNumber(0),
+            gasLimit: BigNumber(0),
+            chainId: "",
+          }),
+          hash: "",
+          bytes: "",
+          signingData: [],
+        },
+      ],
       "signer"
     );
 

apps/extension/src/background/approvals/service.test.ts

@@ -1,9 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { WrapperTxMsgValue } from "@namada/types";
 import { paramsToUrl } from "@namada/utils";
 import { ChainsService } from "background/chains";
 import { KeyRingService } from "background/keyring";
 import { SdkService } from "background/sdk";
 import { VaultService } from "background/vault";
+import BigNumber from "bignumber.js";
 import { ExtensionBroadcaster } from "extension";
 import createMockInstance from "jest-create-mock-instance";
 import { LocalStorage } from "storage";
@@ -210,16 +212,22 @@ describe("approvals service", () => {
     it("should reject resolver", async () => {
       const tabId = 1;
       const signer = "signer";
-      // data expected to be base64-encoded
-      const txBytes = "dHhEYXRh"; // "txData"
-      const signingDataBytes = "c2lnbmluZ0RhdGE="; // "signingData"
+      // tx bytes expected to be base64-encoded
+      const bytes = "dHhEYXRh"; // "txData"
 
       (keyRingService.queryAccountDetails as any).mockResolvedValue(() => ({}));
 
       const signaturePromise = service.approveSignTx(signer, [
         {
-          txBytes,
-          signingDataBytes: [signingDataBytes],
+          args: new WrapperTxMsgValue({
+            token: "",
+            feeAmount: BigNumber(0),
+            gasLimit: BigNumber(0),
+            chainId: "",
+          }),
+          hash: "",
+          bytes,
+          signingData: [],
         },
       ]);
 

apps/extension/src/background/approvals/service.ts

@@ -1,8 +1,7 @@
-import { fromBase64, toBase64 } from "@cosmjs/encoding";
+import { toBase64 } from "@cosmjs/encoding";
 import { v4 as uuid } from "uuid";
 import browser, { Windows } from "webextension-polyfill";
 
-import { BuiltTx } from "@heliax/namada-sdk/web";
 import { KVStore } from "@namada/storage";
 import { SignArbitraryResponse, TxDetails } from "@namada/types";
 import { paramsToUrl } from "@namada/utils";
@@ -14,6 +13,7 @@ import { SdkService } from "background/sdk";
 import { VaultService } from "background/vault";
 import { ExtensionBroadcaster } from "extension";
 import { LocalStorage } from "storage";
+import { fromEncodedTx } from "utils";
 import { EncodedTxData, PendingTx } from "./types";
 
 export class ApprovalsService {
@@ -50,12 +50,10 @@ export class ApprovalsService {
 
     const pendingTx: PendingTx = {
       signer,
-      txs: txs.map(({ txBytes, signingDataBytes }) => ({
-        txBytes: fromBase64(txBytes),
-        signingDataBytes: signingDataBytes.map((bytes) => fromBase64(bytes)),
-      })),
+      txs: txs.map((encodedTx) => fromEncodedTx(encodedTx)),
       checksums,
     };
+
     await this.txStore.set(msgId, pendingTx);
 
     const url = `${browser.runtime.getURL(
@@ -122,16 +120,9 @@ export class ApprovalsService {
       throw new Error(`Signing data for ${msgId} not found!`);
     }
 
-    const txs = pendingTx.txs.map(({ txBytes, signingDataBytes }) => {
-      return new BuiltTx(
-        txBytes,
-        signingDataBytes.map((sdBytes) => [...sdBytes])
-      );
-    });
-
     try {
       const signedBytes: Uint8Array[] = [];
-      for await (const tx of txs) {
+      for await (const tx of pendingTx.txs) {
         signedBytes.push(await this.keyRingService.sign(tx, signer));
       }
       resolvers.resolve(signedBytes);
@@ -165,8 +156,8 @@ export class ApprovalsService {
     const { tx } = this.sdkService.getSdk();
 
     try {
-      const signedTxs = pendingTx.txs.map(({ txBytes }, i) => {
-        return tx.appendSignature(txBytes, responseSign[i]);
+      const signedTxs = pendingTx.txs.map(({ bytes }, i) => {
+        return tx.appendSignature(bytes, responseSign[i]);
       });
       resolvers.resolve(signedTxs);
     } catch (e) {
@@ -303,8 +294,8 @@ export class ApprovalsService {
     }
 
     const { tx } = this.sdkService.getSdk();
-    return pendingTx.txs.map(({ txBytes }) =>
-      tx.deserialize(txBytes, pendingTx.checksums || {})
+    return pendingTx.txs.map(({ bytes }) =>
+      tx.deserialize(bytes, pendingTx.checksums || {})
     );
   }
 
@@ -316,7 +307,7 @@ export class ApprovalsService {
     }
 
     if (pendingTx.txs) {
-      return pendingTx.txs.map(({ txBytes }) => toBase64(txBytes));
+      return pendingTx.txs.map(({ bytes }) => toBase64(bytes));
     }
   }
 

apps/extension/src/background/approvals/types.ts

@@ -1,17 +1,24 @@
-import { TxData } from "@namada/types";
+import { SigningDataProps, TxProps } from "@namada/types";
 
 export type ApprovedOriginsStore = string[];
 
 export type PendingTx = {
-  txs: TxData[];
+  txs: TxProps[];
   signer: string;
   checksums?: Record<string, string>;
 };
 
 export type PendingSignArbitrary = string;
 
-// base64 encoded Tx data for use with postMessage
-export type EncodedTxData = {
-  txBytes: string;
-  signingDataBytes: string[];
+// base64 encoded Uint8Arrays for use with postMessage
+export type EncodedSigningData = Pick<
+  SigningDataProps,
+  "publicKeys" | "threshold" | "feePayer" | "owner"
+> & {
+  accountPublicKeysMap?: string;
+};
+
+export type EncodedTxData = Pick<TxProps, "args" | "hash"> & {
+  bytes: string;
+  signingData: EncodedSigningData[];
 };

apps/extension/src/background/keyring/keyring.ts

@@ -5,6 +5,7 @@ import {
   Bip44Path,
   DerivedAccount,
   SignArbitraryResponse,
+  TxProps,
 } from "@namada/types";
 import { Result, assertNever, truncateInMiddle } from "@namada/utils";
 
@@ -19,7 +20,6 @@ import {
   UtilityStore,
 } from "./types";
 
-import { BuiltTx } from "@namada/shared";
 import { SdkService } from "background/sdk";
 import { VaultService } from "background/vault";
 import { KeyStore, KeyStoreType, SensitiveType, VaultStorage } from "storage";
@@ -544,14 +544,14 @@ export class KeyRing {
   }
 
   async sign(
-    builtTx: BuiltTx,
+    txProps: TxProps,
     signer: string,
     chainId: string
   ): Promise<Uint8Array> {
     await this.vaultService.assertIsUnlocked();
     const key = await this.getSigningKey(signer);
     const { signing } = this.sdkService.getSdk();
-    return await signing.sign(builtTx, key, chainId);
+    return await signing.sign(txProps, key, chainId);
   }
 
   async signArbitrary(

apps/extension/src/background/keyring/service.ts

@@ -5,10 +5,10 @@ import {
   Bip44Path,
   DerivedAccount,
   SignArbitraryResponse,
+  TxProps,
 } from "@namada/types";
 import { Result, truncateInMiddle } from "@namada/utils";
 
-import { BuiltTx } from "@namada/shared";
 import { ChainsService } from "background/chains";
 import { SdkService } from "background/sdk/service";
 import { VaultService } from "background/vault";
@@ -167,9 +167,9 @@ export class KeyRingService {
     return await IndexedDBKVStore.durabilityCheck();
   }
 
-  async sign(builtTx: BuiltTx, signer: string): Promise<Uint8Array> {
+  async sign(txProps: TxProps, signer: string): Promise<Uint8Array> {
     const { chainId } = await this.chainsService.getChain();
-    return await this._keyRing.sign(builtTx, signer, chainId);
+    return await this._keyRing.sign(txProps, signer, chainId);
   }
 
   async signArbitrary(

apps/extension/src/context/AccountContext.tsx

@@ -64,7 +64,7 @@ export const AccountContextWrapper = ({
   children,
 }: AccountContextProps): JSX.Element => {
   const requester = useRequester();
-  const { isLocked, logout } = useVaultContext();
+  const { lockStatus, logout } = useVaultContext();
 
   const [accounts, setAccounts] = useState<DerivedAccount[]>([]);
   const [parentAccounts, setParentAccounts] = useState<DerivedAccount[]>([]);
@@ -166,11 +166,11 @@ export const AccountContextWrapper = ({
   };
 
   useEffect(() => {
-    if (!isLocked) {
+    if (lockStatus === "unlocked") {
       void fetchAll();
       void fetchActiveAccountId();
     }
-  }, [isLocked]);
+  }, [lockStatus]);
 
   useEffect(() => {
     setParentAccounts(accounts.filter((account) => !account.parentId));