support legacy seed key import

src/auth/modules/create/CreateWalletForm.tsx

@@ -20,6 +20,7 @@ import {
 } from "@terra-money/station-ui"
 import styles from "./CreateWalletForm.module.scss"
 import { decrypt } from "auth/scripts/aes"
+import legacyDecrypt from "auth/scripts/decrypt"
 
 interface Values extends DefaultValues {
   confirm: string
@@ -58,7 +59,7 @@ const CreateWalletForm = () => {
   } = form
   const { errors, isValid } = formState
   const formValues = watch()
-  const { mnemonic, index, checked } = formValues
+  const { mnemonic, index, checked, name } = formValues
 
   useEffect(() => {
     return () => reset()
@@ -71,16 +72,17 @@ const CreateWalletForm = () => {
         return
       }
 
-      const { seed, index, legacy } = JSON.parse(
+      const { seed, index, legacy, encrypted_key } = JSON.parse(
         Buffer.from(mnemonic, "base64").toString("ascii")
       )
 
       setValues({
         name,
-        mnemonic: seed,
+        mnemonic: seed || encrypted_key,
         index,
         coinType: legacy ? 118 : 330,
         seedPassword,
+        legacySeedKey: !seed,
       })
       setStep(2)
     } else {
@@ -92,14 +94,12 @@ const CreateWalletForm = () => {
   function validateSeed(value?: string) {
     if (!value) return t("Invalid seed key")
     try {
-      const { name, seed } = JSON.parse(
+      const { seed, encrypted_key } = JSON.parse(
         Buffer.from(value, "base64").toString("ascii")
       )
 
-      if (typeof seed !== "string") {
-        return typeof name === "string"
-          ? t("this key has been exported from an old version of Station")
-          : t("Invalid seed key")
+      if (typeof seed !== "string" && typeof encrypted_key !== "string") {
+        return t("Invalid seed key")
       }
 
       return true
@@ -110,13 +110,21 @@ const CreateWalletForm = () => {
 
   function validateSeedPassword(value: string, password: string) {
     try {
-      const { seed } = JSON.parse(
-        Buffer.from(value, "base64").toString("ascii")
-      )
+      const {
+        seed,
+        encrypted_key,
+        name: keyName,
+      } = JSON.parse(Buffer.from(value, "base64").toString("ascii"))
 
-      decrypt(seed, password)
+      if (seed) {
+        decrypt(seed, password)
 
-      return true
+        return true
+      } else {
+        legacyDecrypt(encrypted_key, password)
+
+        return true
+      }
     } catch {
       return false
     }
@@ -270,15 +278,19 @@ const CreateWalletForm = () => {
                   key: ImportOptions.MNEMONIC,
                   label: t("Recovery Phrase"),
                   onClick: () => {
-                    setValues({ ...formValues, mnemonic: "" })
+                    importOption !== ImportOptions.MNEMONIC &&
+                      setError("mnemonic", {})
+                    setValue("mnemonic", "")
                     setImportOption(ImportOptions.MNEMONIC)
                   },
                 },
                 {
                   key: ImportOptions.SEED_KEY,
                   label: t("Seed Key"),
                   onClick: () => {
-                    setValues({ ...formValues, mnemonic: "" })
+                    importOption !== ImportOptions.SEED_KEY &&
+                      setError("mnemonic", {})
+                    setValue("mnemonic", "")
                     setImportOption(ImportOptions.SEED_KEY)
                   },
                 },

src/auth/modules/create/CreateWalletWizard.tsx

@@ -1,20 +1,22 @@
 import { ReactNode, useEffect, useState } from "react"
 import { useLocation, useNavigate } from "react-router-dom"
-import { SeedKey } from "@terra-money/feather.js"
+import { RawKey, SeedKey } from "@terra-money/feather.js"
 import createContext from "utils/createContext"
 import { addWallet } from "../../scripts/keystore"
 import CreateWalletForm from "./CreateWalletForm"
 import CreatedWallet from "./CreatedWallet"
 import { wordsFromAddress } from "utils/bech32"
 import PasswordForm from "./PasswordForm"
 import { decrypt } from "auth/scripts/aes"
+import legacyDecrypt from "auth/scripts/decrypt"
 
 export interface Values {
   name: string
   mnemonic: string
   index: number
   coinType?: Bip
   seedPassword?: string
+  legacySeedKey?: boolean
 }
 
 /* context */
@@ -56,45 +58,74 @@ const CreateWalletWizard = ({ defaultMnemonic = "", beforeCreate }: Props) => {
   /* create wallet */
   const [createdWallet, setCreatedWallet] = useState<SingleWallet>()
   const createWallet = (password: string) => {
-    const { name, mnemonic, coinType, index, seedPassword } = values
+    const { name, mnemonic, coinType, index, seedPassword, legacySeedKey } =
+      values
 
+    console.log(seedPassword && legacyDecrypt(mnemonic, seedPassword ?? ""))
     const seed = seedPassword
-      ? Buffer.from(decrypt(mnemonic, seedPassword), "base64")
+      ? legacySeedKey
+        ? Buffer.from(legacyDecrypt(mnemonic, seedPassword), "hex")
+        : Buffer.from(decrypt(mnemonic, seedPassword), "base64")
       : SeedKey.seedFromMnemonic(mnemonic)
-    const key330 = new SeedKey({ seed, coinType: coinType ?? 330, index })
-    const key118 = new SeedKey({ seed, coinType: 118, index })
-    const key60 = new SeedKey({ seed, coinType: 60, index })
-    const words = {
-      "330": wordsFromAddress(key330.accAddress("terra")),
-      "118": wordsFromAddress(key118.accAddress("terra")),
-      "60": wordsFromAddress(key60.accAddress("inj")),
-    }
 
-    const pubkey = {
-      // @ts-expect-error
-      "330": key330.publicKey.key,
-      // @ts-expect-error
-      "118": key118.publicKey.key,
-      // @ts-expect-error
-      "60": key60.publicKey.key,
+    if (!legacySeedKey) {
+      const key330 = new SeedKey({ seed, coinType: coinType ?? 330, index })
+      const key118 = new SeedKey({ seed, coinType: 118, index })
+      const key60 = new SeedKey({ seed, coinType: 60, index })
+      const words = {
+        "330": wordsFromAddress(key330.accAddress("terra")),
+        "118": wordsFromAddress(key118.accAddress("terra")),
+        "60": wordsFromAddress(key60.accAddress("inj")),
+      }
+
+      const pubkey = {
+        // @ts-expect-error
+        "330": key330.publicKey.key,
+        // @ts-expect-error
+        "118": key118.publicKey.key,
+        // @ts-expect-error
+        "60": key60.publicKey.key,
+      }
+
+      try {
+        addWallet(
+          {
+            name,
+            words,
+            mnemonic: seedPassword ? undefined : mnemonic,
+            seed,
+            pubkey,
+            index,
+            legacy: coinType === 118,
+          },
+          password
+        )
+      } catch (e) {}
+      setCreatedWallet({ name, words, pubkey })
+    } else {
+      const key330 = new RawKey(seed)
+      const words = {
+        "330": wordsFromAddress(key330.accAddress("terra")),
+      }
+
+      const pubkey = {
+        // @ts-expect-error
+        "330": key330.publicKey.key,
+      }
+      try {
+        addWallet(
+          {
+            name,
+            words,
+            key: { "330": seed },
+            pubkey,
+          },
+          password
+        )
+      } catch (e) {}
+      setCreatedWallet({ name, words, pubkey })
     }
 
-    try {
-      addWallet(
-        {
-          name,
-          words,
-          mnemonic,
-          seed,
-          pubkey,
-          index,
-          legacy: coinType === 118,
-        },
-        password
-      )
-    } catch (e) {}
-
-    setCreatedWallet({ name, words, pubkey })
     setStep(4)
   }
 
@@ -114,6 +145,7 @@ const CreateWalletWizard = ({ defaultMnemonic = "", beforeCreate }: Props) => {
 
       case 2:
         if (!values.mnemonic) setStep(1)
+        if (values.legacySeedKey) setStep(3)
         return beforeCreate
 
       case 3: