Release Adena Wallet 'v1.8.1'

package.json

@@ -1,6 +1,6 @@
 {
   "name": "adena-wallet",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Adena Wallet",
   "license": "Adena License",
   "private": true,

packages/adena-extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adena-extension",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "private": true,
   "description": "Adena is a friendly browser extension wallet for the Gnoland blockchain.",
   "scripts": {

packages/adena-extension/public/manifest.json

@@ -2,7 +2,7 @@
   "name": "Adena",
   "description": "Adena is a friendly browser extension wallet for the Gnoland blockchain.",
   "manifest_version": 3,
-  "version": "1.8.0",
+  "version": "1.8.1",
   "action": {
     "default_popup": "popup.html"
   },

packages/adena-extension/src/common/utils/client-utils.ts

@@ -82,6 +82,8 @@ export function parseTxsEachDate(txs: object[]) {
       txDesc = `pkg: ${cur.pkg_path}`;
     } else if (cur.type === '/vm.m_addpkg') {
       txFunc = 'AddPkg';
+    } else if (cur.type === '/vm.m_run') {
+      txDesc = `Run`;
     } else {
       txDesc = '';
     }

packages/adena-extension/src/common/utils/encoding-util.ts

@@ -0,0 +1,3 @@
+export function bytesToBase64(bytes: number[]) {
+  return Buffer.from(bytes).toString('base64');
+}

packages/adena-extension/src/common/validation/validation-message.ts

@@ -99,3 +99,36 @@ export const validateTrasactionMessageOfAddPkg = (message: { [key in string]: an
   }
   return true;
 };
+
+export const validateTrasactionMessageOfRun = (message: { [key in string]: any }) => {
+  if (!message.type || !message.value) {
+    return false;
+  }
+  if (message.type !== '/vm.m_run') {
+    return false;
+  }
+  if (typeof message.value !== 'object') {
+    return false;
+  }
+  if (typeof message.value.caller !== 'string') {
+    return false;
+  }
+  if (typeof message.value.send !== 'string') {
+    return false;
+  }
+  if (typeof message.value.package !== 'object') {
+    return false;
+  }
+
+  const packageValue = message.value.package;
+  if (typeof packageValue?.Name !== 'string') {
+    return false;
+  }
+  if (typeof packageValue?.Path !== 'string') {
+    return false;
+  }
+  if (!Array.isArray(packageValue?.Files)) {
+    return false;
+  }
+  return true;
+};

packages/adena-extension/src/containers/approve-sign-transaction-container/approve-sign-transaction-container.tsx

@@ -0,0 +1,229 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import ApproveTransaction from '@components/approve/approve-transaction/approve-transaction';
+import { useLocation, useNavigate } from 'react-router-dom';
+import { useCurrentAccount } from '@hooks/use-current-account';
+import { InjectionMessage, InjectionMessageInstance } from '@inject/message';
+import { createFaviconByHostname, decodeParameter, parseParmeters } from '@common/utils/client-utils';
+import { useAdenaContext, useWalletContext } from '@hooks/use-context';
+import { StdSignDoc, Account, isLedgerAccount } from 'adena-module';
+import { RoutePath } from '@router/path';
+import { validateInjectionData } from '@inject/message/methods';
+import BigNumber from 'bignumber.js';
+import { useNetwork } from '@hooks/use-network';
+import { bytesToBase64 } from '@common/utils/encoding-util';
+
+function mappedTransactionData(document: StdSignDoc) {
+  return {
+    messages: document.msgs,
+    contracts: document.msgs.map((message) => {
+      return {
+        type: message?.type || '',
+        function: message?.type === '/bank.MsgSend' ? 'Transfer' : message?.value?.func || '',
+        value: message?.value || '',
+      };
+    }),
+    gasWanted: document.fee.gas,
+    gasFee: `${document.fee.amount[0].amount}${document.fee.amount[0].denom}`,
+    document,
+  }
+}
+
+const DEFAULT_DENOM = 'GNOT';
+
+const ApproveSignTransactionContainer: React.FC = () => {
+  const navigate = useNavigate();
+  const { gnoProvider } = useWalletContext();
+  const { walletService, transactionService } = useAdenaContext();
+  const { currentAccount } = useCurrentAccount();
+  const [transactionData, setTrasactionData] = useState<{ [key in string]: any } | undefined>(
+    undefined,
+  );
+  const { currentNetwork } = useNetwork();
+  const [hostname, setHostname] = useState('');
+  const location = useLocation();
+  const [requestData, setReqeustData] = useState<InjectionMessage>();
+  const [favicon, setFavicon] = useState<any>(null);
+  const [visibleTransactionInfo, setVisibleTransactionInfo] = useState(false);
+  const [document, setDocument] = useState<StdSignDoc>();
+
+  const networkFee = useMemo(() => {
+    if (!document || document.fee.amount.length === 0) {
+      return {
+        amount: '1',
+        denom: DEFAULT_DENOM
+      };
+    }
+    const networkFeeAmount = document.fee.amount[0].amount;
+    const networkFeeAmountOfGnot =
+      BigNumber(networkFeeAmount)
+        .shiftedBy(-6)
+        .toString();
+    return {
+      amount: networkFeeAmountOfGnot,
+      denom: DEFAULT_DENOM
+    };
+  }, [document]);
+
+  useEffect(() => {
+    checkLockWallet();
+  }, [walletService]);
+
+  const checkLockWallet = () => {
+    walletService.isLocked().then(locked => locked && navigate(RoutePath.ApproveLogin + location.search));
+  }
+
+  useEffect(() => {
+    if (location.search) {
+      initRequestData();
+    }
+  }, [location]);
+
+  const initRequestData = () => {
+    const data = parseParmeters(location.search);
+    const parsedData = decodeParameter(data['data']);
+    setReqeustData({ ...parsedData, hostname: data['hostname'] });
+  };
+
+  useEffect(() => {
+    if (currentAccount && requestData && gnoProvider) {
+      if (validate(currentAccount, requestData)) {
+        initFavicon();
+        initTransactionData();
+      }
+    }
+  }, [currentAccount, requestData, gnoProvider]);
+
+  const validate = (currentAccount: Account, requestData: InjectionMessage) => {
+    const validationMessage = validateInjectionData(currentAccount.getAddress('g'), requestData);
+    if (validationMessage) {
+      chrome.runtime.sendMessage(validationMessage);
+      return false;
+    }
+    return true;
+  }
+
+  const initFavicon = async () => {
+    const faviconData = await createFaviconByHostname(requestData?.hostname ?? '');
+    setFavicon(faviconData);
+  };
+
+  const initTransactionData = async () => {
+    if (!currentAccount || !requestData || !currentNetwork) {
+      return false;
+    }
+    try {
+      const document = await transactionService.createDocument(
+        currentAccount,
+        currentNetwork.networkId,
+        requestData?.data?.messages,
+        requestData?.data?.gasWanted,
+        requestData?.data?.gasFee,
+        requestData?.data?.memo,
+      );
+      setDocument(document);
+      setTrasactionData(mappedTransactionData(document));
+      setHostname(requestData?.hostname ?? '');
+      return true;
+    } catch (e) {
+      console.error(e);
+      const error: any = e;
+      if (error?.message === 'Transaction signing request was rejected by the user') {
+        chrome.runtime.sendMessage(
+          InjectionMessageInstance.failure(
+            'SIGN_REJECTED',
+            requestData?.data,
+            requestData?.key,
+          ),
+        );
+      }
+    }
+    return false;
+  };
+
+  const sendTransaction = async () => {
+    if (!document || !currentAccount) {
+      chrome.runtime.sendMessage(
+        InjectionMessageInstance.failure('UNEXPECTED_ERROR', {}, requestData?.key),
+      );
+      return false;
+    }
+
+    try {
+      const signature = await transactionService.createSignature(
+        currentAccount,
+        document
+      );
+      const transactionBytes = await transactionService.createTransaction(document, signature);
+      const encodedTransaction = bytesToBase64(transactionBytes);
+      chrome.runtime.sendMessage(
+        InjectionMessageInstance.success('SIGN_TX', { encodedTransaction }, requestData?.key),
+      );
+    } catch (e) {
+      if (e instanceof Error) {
+        const message = e.message;
+        if (message.includes('Ledger')) {
+          return false;
+        }
+        chrome.runtime.sendMessage(
+          InjectionMessageInstance.failure(
+            'SIGN_FAILED',
+            { error: { message } },
+            requestData?.key,
+          ),
+        );
+      }
+      chrome.runtime.sendMessage(
+        InjectionMessageInstance.failure(
+          'SIGN_FAILED',
+          {},
+          requestData?.key,
+        ),
+      );
+    }
+    return false;
+  };
+
+  const onToggleTransactionData = (visibleTransactionInfo: boolean) => {
+    setVisibleTransactionInfo(visibleTransactionInfo);
+  };
+
+  const onClickConfirm = () => {
+    if (!currentAccount) {
+      return;
+    }
+    if (isLedgerAccount(currentAccount)) {
+      navigate(RoutePath.ApproveSignLoading, {
+        state: {
+          document,
+          requestData
+        }
+      });
+      return;
+    }
+    sendTransaction();
+  };
+
+  const onClickCancel = () => {
+    chrome.runtime.sendMessage(
+      InjectionMessageInstance.failure('SIGN_REJECTED', {}, requestData?.key),
+    );
+  };
+
+  return (
+    <ApproveTransaction
+      title='Sign Transaction'
+      domain={hostname}
+      contracts={transactionData?.contracts}
+      loading={transactionData === undefined}
+      logo={favicon}
+      networkFee={networkFee}
+      onClickConfirm={onClickConfirm}
+      onClickCancel={onClickCancel}
+      onToggleTransactionData={onToggleTransactionData}
+      opened={visibleTransactionInfo}
+      transactionData={JSON.stringify(document, null, 2)}
+    />
+  );
+};
+
+export default ApproveSignTransactionContainer;

packages/adena-extension/src/containers/approve-sign-transaction-ledger-loading-container/approve-sign-transaction-ledger-loading-container.tsx

@@ -0,0 +1,85 @@
+import React, { useEffect, useState } from 'react';
+import { useLocation } from 'react-router-dom';
+import { StdSignDoc, isLedgerAccount } from 'adena-module';
+import ApproveLedgerLoading from '@components/approve/approve-ledger-loading/approve-ledger-loading';
+import { InjectionMessage, InjectionMessageInstance } from '@inject/message';
+import { useCurrentAccount } from '@hooks/use-current-account';
+import { useAdenaContext } from '@hooks/use-context';
+import { bytesToBase64 } from '@common/utils/encoding-util';
+
+interface ApproveSignTransactionLedgerLoadingState {
+  requestData?: InjectionMessage;
+  document?: StdSignDoc;
+}
+
+const ApproveSignTransactionLedgerLoadingContainer: React.FC = () => {
+  const location = useLocation();
+  const { transactionService } = useAdenaContext();
+  const { document, requestData } = location.state as ApproveSignTransactionLedgerLoadingState;
+  const { currentAccount } = useCurrentAccount();
+  const [completed, setCompleted] = useState(false);
+
+  useEffect(() => {
+    if (currentAccount) {
+      requestTransaction();
+    }
+  }, [currentAccount]);
+
+  const requestTransaction = async () => {
+    if (completed) {
+      return;
+    }
+    const result = await createLedgerTransaction();
+    setCompleted(result);
+    setTimeout(() => !result && requestTransaction(), 1000);
+  };
+
+  const createLedgerTransaction = async () => {
+    if (!currentAccount || !document) {
+      return false;
+    }
+
+    if (!isLedgerAccount(currentAccount)) {
+      return false;
+    }
+
+    const result = await transactionService.createSignatureWithLedger(currentAccount, document).then(async (signature) => {
+      const transactionBytes = await transactionService.createTransaction(document, signature);
+      const encodedTransaction = bytesToBase64(transactionBytes);
+      chrome.runtime.sendMessage(
+        InjectionMessageInstance.success('SIGN_TX', { encodedTransaction }, requestData?.key),
+      );
+      return true;
+    }).catch((error: Error) => {
+      if (error.message === 'Transaction signing request was rejected by the user') {
+        chrome.runtime.sendMessage(
+          InjectionMessageInstance.failure('SIGN_REJECTED', {}, requestData?.key),
+        );
+        return true;
+      }
+      if (error.message.includes('Ledger')) {
+        return false;
+      }
+      return false;
+    });
+    return result;
+  };
+
+  const onClickCancel = () => {
+    if (!requestData) {
+      window.close();
+      return;
+    }
+    chrome.runtime.sendMessage(
+      InjectionMessageInstance.failure('SIGN_REJECTED', requestData.data, requestData.key),
+    );
+  }
+
+  return (
+    <ApproveLedgerLoading
+      onClickCancel={onClickCancel}
+    />
+  );
+};
+
+export default ApproveSignTransactionLedgerLoadingContainer;