diff --git a/.eslintignore b/.eslintignore
new file mode 100644
index 000000000..efd718508
--- /dev/null
+++ b/.eslintignore
@@ -0,0 +1 @@
+src/lib/core
diff --git a/package.json b/package.json
index 3012e8e7e..252b2768b 100644
--- a/package.json
+++ b/package.json
@@ -20,7 +20,8 @@
     "@react-navigation/native": "^6.0.4",
     "@react-navigation/stack": "^6.0.9",
     "@rsksmart/rif-id-ethr-did": "^0.1.0",
-    "@rsksmart/rif-id-mnemonic": "^0.1.0",
+    "@rsksmart/rif-id-mnemonic": "^0.1.1",
+    "@rsksmart/rlogin-dpath": "^1.0.1",
     "@rsksmart/rsk-contract-metadata": "^1.0.15",
     "@rsksmart/rsk-testnet-contract-metadata": "^1.0.11",
     "buffer": "^4.9.2",
diff --git a/src/App.tsx b/src/App.tsx
index 23db58544..2e30a7c7a 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -4,7 +4,7 @@ import { NavigationProp, ParamListBase } from '@react-navigation/native'
 
 import Button from './components/button'
 import { Header1, Header2, Paragraph } from './components/typography'
-import { Account, Wallet } from './lib/core'
+import { RIFWallet } from './lib/core/RIFWallet'
 
 import { WalletProviderContext } from './state/AppContext'
 import { removeStorage, StorageKeys } from './storage'
@@ -19,17 +19,23 @@ const WalletApp: React.FC<Interface> = ({ navigation }) => {
   // Temporary component state:
   interface componentStateI {
     confirmResponse?: string
-    wallet?: Wallet
+    wallet?: RIFWallet
   }
 
-  const [wallet, setWallet] = useState<Wallet | undefined>(undefined)
-  const [accounts, setAccounts] = useState<Account[]>([])
+  const [wallet, setWallet] = useState<RIFWallet[]>([])
+  const [mnemonic, setMnemonic] = useState<string>('')
 
   const context = useContext(WalletProviderContext)
   useEffect(() => {
-    setWallet(context.wallet)
-  }, [context.wallet, wallet])
+    context.wallets && setWallet(context.wallets)
+  }, [context.wallets])
 
+  useEffect(() => {
+    console.log('setting Mnemonic', context.getMnemonic())
+    setMnemonic(context.getMnemonic())
+  }, [context.wallets])
+
+  /*
   const addAccount = () => {
     if (wallet) {
       wallet
@@ -37,24 +43,26 @@ const WalletApp: React.FC<Interface> = ({ navigation }) => {
         .then(account => setAccounts(accounts.concat(account)))
     }
   }
+  */
 
-  const seeSmartWallet = (account: Account) =>
+  const seeSmartWallet = (account: RIFWallet) =>
     navigation.navigate('SmartWallet', { account })
 
   return (
     <ScrollView>
       <Header1>sWallet</Header1>
       <View style={styles.section}>
-        <Header2>Wallet:</Header2>
-        {wallet && <CopyComponent value={wallet.getMnemonic} />}
+        <Header2>KMS:</Header2>
+        <CopyComponent value={mnemonic} />
       </View>
 
       <View style={styles.section}>
-        <Header2>Accounts:</Header2>
-        {accounts.map((account: Account, index: number) => {
+        <Header2>RIF Wallets:</Header2>
+        {wallet.map((account: RIFWallet, index: number) => {
           return (
             <View key={index}>
-              <CopyComponent value={account.address} />
+              <Paragraph>EOA Address</Paragraph>
+              <CopyComponent value={account.smartWallet.wallet.address} />
               <Button
                 title="See smart wallet"
                 onPress={() => seeSmartWallet(account)}
@@ -65,7 +73,6 @@ const WalletApp: React.FC<Interface> = ({ navigation }) => {
               />
               <Button
                 onPress={() => {
-                  // @ts-ignore
                   navigation.navigate('SendTransaction', { account })
                 }}
                 title="Send Transaction"
@@ -73,13 +80,13 @@ const WalletApp: React.FC<Interface> = ({ navigation }) => {
             </View>
           )
         })}
-        <Button onPress={addAccount} title="Add account" />
+        {/*<Button onPress={addAccount} title="Add account" />*/}
       </View>
 
       <View style={styles.section}>
         <Header2>Settings</Header2>
         <Button
-          onPress={() => removeStorage(StorageKeys.MNEMONIC)}
+          onPress={() => removeStorage(StorageKeys.KMS)}
           title="Clear RN Storage"
         />
         <Paragraph>
diff --git a/src/RootNavigation.tsx b/src/RootNavigation.tsx
index 8d41b8af0..ca9f05e02 100644
--- a/src/RootNavigation.tsx
+++ b/src/RootNavigation.tsx
@@ -58,10 +58,10 @@ const RootNavigation: React.FC<Interface> = () => {
       </NavigationContainer>
 
       {/* Modals: */}
-      {context.userInteractionQue.length !== 0 && (
+      {context.walletRequests[0] && (
         <ReviewTransactionModal
           closeModal={closeReviewTransactionModal}
-          queuedTransactionRequest={context.userInteractionQue[0]}
+          queuedTransactionRequest={context.walletRequests[0]}
         />
       )}
     </View>
diff --git a/src/lib/core/Account.ts b/src/lib/core/Account.ts
deleted file mode 100644
index 56fddd315..000000000
--- a/src/lib/core/Account.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { Wallet, Signer } from 'ethers'
-import {
-  TransactionRequest,
-  TransactionResponse,
-} from '@ethersproject/abstract-provider'
-import { jsonRpcProvider } from '../jsonRpcProvider'
-import { SmartWalletFactory } from './smartWallet/smart-wallet-factory'
-import { SmartWallet } from './smartWallet/smart-wallet'
-
-export type { TransactionRequest }
-
-export type QueuedTransaction = {
-  id: number
-  transactionRequest: TransactionRequest
-  confirm: (userApprovedTransaction: TransactionRequest) => void
-  cancel: () => void
-}
-
-class Account extends Wallet {
-  idCount: number = 0
-  queuedTransactions: QueuedTransaction[]
-  eoaWallet: Signer
-  smartWallet: SmartWallet
-  smartWalletFactory: SmartWalletFactory
-  handleUxInteraction?: (qt: QueuedTransaction) => Promise<TransactionRequest>
-
-  constructor({
-    privateKey,
-    wallet,
-    smartAddress,
-    smartWalletFactory,
-    handleUxInteraction,
-  }: {
-    privateKey: string
-    wallet: Signer
-    smartAddress: string
-    smartWalletFactory: SmartWalletFactory
-    handleUxInteraction?: (qt: QueuedTransaction) => Promise<TransactionRequest>
-  }) {
-    super(privateKey, jsonRpcProvider)
-    this.eoaWallet = wallet
-    this.queuedTransactions = []
-    this.smartWallet = new SmartWallet(smartAddress, wallet)
-    this.smartWalletFactory = smartWalletFactory
-    this.handleUxInteraction = handleUxInteraction
-  }
-
-  static async create({
-    privateKey,
-    handleUxInteraction,
-  }: {
-    privateKey: string
-    handleUxInteraction?: (qt: QueuedTransaction) => Promise<TransactionRequest>
-  }) {
-    const wallet = new Wallet(privateKey, jsonRpcProvider)
-    const smartWalletFactory = new SmartWalletFactory(wallet)
-    const smartAddress = await smartWalletFactory.getSmartAddress()
-    return new Account({
-      privateKey,
-      wallet,
-      smartAddress,
-      smartWalletFactory,
-      handleUxInteraction,
-    })
-  }
-
-  nextTransaction(): QueuedTransaction {
-    if (this.queuedTransactions.length === 0) {
-      throw new Error()
-    }
-    return this.queuedTransactions[0]
-  }
-
-  getSmartAddress(): Promise<string> {
-    return Promise.resolve(this.smartWallet.smartWalletContract.address)
-  }
-
-  deploy = () => this.smartWalletFactory.createSmartWallet()
-
-  async sendTransaction(
-    transactionRequest: TransactionRequest,
-  ): Promise<TransactionResponse> {
-    // here we queue the transaction
-    const id = this.idCount++
-
-    console.log('sendTransaction: transactionRequest', transactionRequest)
-    // get transaction details
-
-    const gasLimit =
-      transactionRequest.gasLimit ||
-      (await this.estimateGas(transactionRequest))
-    const gasPrice = transactionRequest.gasPrice || (await this.getGasPrice())
-
-    return await new Promise(
-      (
-        resolve: (t: TransactionRequest) => void,
-        reject: (error: Error) => void,
-      ) => {
-        const queuedTransaction = {
-          id,
-          transactionRequest: {
-            ...transactionRequest,
-            gasLimit,
-            gasPrice,
-          },
-          confirm: (userConfirmedTransaction: TransactionRequest) =>
-            resolve(userConfirmedTransaction),
-          cancel: () => reject(Error('User rejected the transaction')),
-        }
-
-        this.queuedTransactions.push(queuedTransaction)
-
-        // Pass transaction to the UI for the user's confirm or cancel:
-        if (this.handleUxInteraction) {
-          this.handleUxInteraction(queuedTransaction)
-        }
-      },
-    )
-      // transaction with user modified gasPrice/gasLimit:
-      .then((userConfirmedTransaction: TransactionRequest) => {
-        console.log('userConfirmedTransaction', userConfirmedTransaction)
-        // assumes the transactions are confirmed in order
-        // because the confirm() is only found using nextTransaction()
-        this.queuedTransactions.shift()
-
-        const filteredTx = Object.keys(userConfirmedTransaction)
-          .filter(key => !['to', 'data'].includes(key))
-          .reduce((obj: any, key: any) => {
-            obj[key] = (userConfirmedTransaction as any)[key]
-            return obj
-          }, {})
-
-        const signedTransaction = this.smartWallet.directExecute(
-          userConfirmedTransaction.to,
-          userConfirmedTransaction.data,
-          filteredTx,
-        )
-
-        console.log('directExecute tx:', userConfirmedTransaction)
-
-        return signedTransaction
-      })
-      // user has rejected the transaction:
-      .catch((err: Error) => {
-        this.queuedTransactions.shift()
-        // Return error to the _thing_ that is calling this
-        throw err
-      })
-  }
-}
-
-export default Account
diff --git a/src/lib/core/KeyManagementSystem.ts b/src/lib/core/KeyManagementSystem.ts
new file mode 100644
index 000000000..d105af4e1
--- /dev/null
+++ b/src/lib/core/KeyManagementSystem.ts
@@ -0,0 +1,182 @@
+import { Wallet } from 'ethers'
+import { generateMnemonic, mnemonicToSeedSync, fromSeed } from '@rsksmart/rif-id-mnemonic'
+import { getDPathByChainId } from '@rsksmart/rlogin-dpath'
+
+type Mnemonic = string
+
+type DerivedPaths = { [derivatoinPath: string]: boolean }
+
+type LastDerivedAccountIndex = {
+  [chainId: number]: number
+}
+
+type KeyManagementSystemState = {
+  lastDerivedAccountIndex: LastDerivedAccountIndex
+  derivedPaths: DerivedPaths
+}
+
+const createInitialState = (): KeyManagementSystemState => ({
+  lastDerivedAccountIndex: {},
+  derivedPaths: {}
+})
+
+type KeyManagementSystemSerialization = {
+  mnemonic: Mnemonic
+  state: KeyManagementSystemState
+}
+
+export type SaveableWallet = {
+  derivationPath: string
+  wallet: Wallet
+  save(): void
+}
+
+interface IKeyManagementSystem {
+  nextWallet (chainId: number): SaveableWallet
+  addWallet (derivationPath: string): SaveableWallet
+  removeWallet (derivationPath: string): void
+}
+
+/**
+ * The Key Management System will derive accounts for a given mnemonic. It allows
+ * two type of derivations:
+ * - By chain id (nextWallet): it will use an incremental account_index based on BIP-44
+ * - Arbitrary derivation paths (addWallet): it will derive the account for the given
+ *   path, affecting the accounts by chain id. If an account of a chain is
+ *   added, it will be skiped when adding by chain id
+ * Both methods will return a { derivationPath, wallet, save } object that can be used
+ * to deffer saving the account in the KMS. This can be used to show the user the account
+ * before storing it.
+ * Use removeWallet to remove it from the KMS. It can be added back by adding as and
+ * arbitrary accounts
+ * Use serialize/fromSerialized to store the KMS
+ */
+export class KeyManagementSystem implements IKeyManagementSystem {
+  state: KeyManagementSystemState
+  mnemonic: Mnemonic
+
+  private constructor (mnemonic: Mnemonic, initialState: KeyManagementSystemState) {
+    this.mnemonic = mnemonic
+    this.state = initialState
+  }
+
+  /**
+   * Factory method: generates a mnemonic and initializes the
+   * Key Management System
+   * @returns a new Key Management System with a new mnemonic
+   */
+  static create (): KeyManagementSystem {
+    const mnemonic = generateMnemonic(24)
+    return new KeyManagementSystem(mnemonic, createInitialState())
+  }
+
+  /**
+   * Factory method: use this method to import a wallet and the
+   * used derivation paths
+   * @param mnemonic a mnemonic phrase
+   * @param state the state of the Key Management System
+   * @returns A Key Management System with the given mnemonic and state
+   */
+  static import (mnemonic: Mnemonic) {
+    return new KeyManagementSystem(mnemonic, createInitialState())
+  }
+
+  /**
+   * Use this method to recover a stored serialized wallet
+   * @param serialized the serialized string
+   * @returns the KeyManagementSystem that was serialized
+   */
+  static fromSerialized (serialized: string): { kms: KeyManagementSystem, wallets: Wallet[] } {
+    const { mnemonic, state }: KeyManagementSystemSerialization = JSON.parse(serialized)
+
+    const kms = new KeyManagementSystem(mnemonic, state)
+    const wallets = Object.keys(state.derivedPaths)
+      .filter(derivedPath => state.derivedPaths[derivedPath])
+      .map(derivedPath => kms.deriveWallet(derivedPath))
+
+    return {
+      kms,
+      wallets
+    }
+  }
+
+  /**
+   * Use this method to get a string to be stored and recovered
+   * @returns a serialized wallet
+   */
+  serialize (): string {
+    const serialization: KeyManagementSystemSerialization = {
+      mnemonic: this.mnemonic,
+      state: this.state
+    }
+
+    return JSON.stringify(serialization)
+  }
+
+  private deriveWallet (derivationPath: string) {
+    // Create the seed - ref: BIP-39
+    const seed = mnemonicToSeedSync(this.mnemonic)
+    const hdKey = fromSeed(seed).derivePath(derivationPath)
+    const privateKey = hdKey.privateKey!.toString('hex')
+    return new Wallet(privateKey)
+  }
+
+  /**
+   * Get the next wallet for the given chainId
+   * @param chainId EIP-155 chain Id
+   * @returns a savable account
+   */
+  nextWallet (chainId: number): SaveableWallet {
+    // Get the next derivation path for the address - ref: BIP-44
+    if (!this.state.lastDerivedAccountIndex[chainId]) {
+      this.state.lastDerivedAccountIndex[chainId] = 0
+    }
+
+    let derivationPath = getDPathByChainId(chainId, this.state.lastDerivedAccountIndex[chainId])
+
+    while (this.state.derivedPaths[derivationPath]) {
+      this.state.lastDerivedAccountIndex[chainId]++
+      derivationPath = getDPathByChainId(chainId, this.state.lastDerivedAccountIndex[chainId])
+    }
+
+    const wallet = this.deriveWallet(derivationPath)
+
+    return {
+      derivationPath,
+      wallet,
+      save: () => {
+        this.state.derivedPaths[derivationPath] = true
+        this.state.lastDerivedAccountIndex[chainId] = this.state.lastDerivedAccountIndex[chainId] + 1
+      }
+    }
+  }
+
+  /**
+   * Get tehe account for an arbitrary derivation path
+   * @param derivationPath an arbitrary derivation path
+   * @returns a savable wallet
+   */
+  addWallet (derivationPath: string): SaveableWallet {
+    if (this.state.derivedPaths[derivationPath]) throw new Error('Existent wallet')
+
+    const wallet = this.deriveWallet(derivationPath)
+
+    return {
+      derivationPath,
+      wallet,
+      save: () => {
+        this.state.derivedPaths[derivationPath] = true
+      }
+    }
+  }
+
+  /**
+   * Remove a wallet from the Key Management System
+   * @param derivationPath the derivation path of the wallet to be removed
+   */
+  removeWallet (derivationPath: string): void {
+    if (!this.state.derivedPaths[derivationPath]) throw new Error('Inexistent wallet')
+
+    delete this.state.derivedPaths[derivationPath]
+  }
+}
diff --git a/src/lib/core/RIFWallet.ts b/src/lib/core/RIFWallet.ts
new file mode 100644
index 000000000..22ed3b31a
--- /dev/null
+++ b/src/lib/core/RIFWallet.ts
@@ -0,0 +1,97 @@
+import { Bytes, Signer, Wallet, BigNumberish } from 'ethers'
+import { TransactionRequest, Provider, TransactionResponse, BlockTag } from '@ethersproject/abstract-provider'
+import { defineReadOnly } from '@ethersproject/properties'
+import { SmartWalletFactory } from './SmartWalletFactory'
+import { SmartWallet } from './SmartWallet'
+import { filterTxOptions } from './filterTxOptions'
+
+export type OverriddableTransactionOptions = {
+  gasLimit: BigNumberish,
+  gasPrice: BigNumberish,
+}
+
+export type Request = {
+  type: 'sendTransaction'
+  payload: {
+    // needs refactor: payload can be transactionRequest, not an object of transactionRequest
+    transactionRequest: TransactionRequest
+  }
+  confirm: (value?: Partial<OverriddableTransactionOptions>) => void
+  reject: (reason?: any) => void
+}
+
+export type OnRequest = (request: Request) => void
+
+export class RIFWallet extends Signer {
+  smartWallet: SmartWallet
+  smartWalletFactory: SmartWalletFactory
+  onRequest: OnRequest
+
+  private constructor (smartWalletFactory: SmartWalletFactory, smartWallet: SmartWallet, onRequest: OnRequest) {
+    super()
+    this.smartWalletFactory = smartWalletFactory
+    this.smartWallet = smartWallet
+    this.onRequest = onRequest
+
+    defineReadOnly(this, 'provider', this.smartWallet.wallet.provider) // ref: https://github.com/ethers-io/ethers.js/blob/b1458989761c11bf626591706aa4ce98dae2d6a9/packages/abstract-signer/src.ts/index.ts#L130
+  }
+
+  get address (): string {
+    return this.smartWallet.smartWalletAddress
+  }
+
+  get smartWalletAddress (): string {
+    return this.smartWallet.smartWalletAddress
+  }
+
+  get wallet (): Wallet {
+    return this.smartWallet.wallet
+  }
+
+  static async create (wallet: Wallet, smartWalletFactoryAddress: string, onRequest: OnRequest) {
+    const smartWalletFactory = await SmartWalletFactory.create(wallet, smartWalletFactoryAddress)
+    const smartWalletAddress = await smartWalletFactory.getSmartWalletAddress()
+    const smartWallet = SmartWallet.create(wallet, smartWalletAddress)
+    return new RIFWallet(smartWalletFactory, smartWallet, onRequest)
+  }
+
+  getAddress = (): Promise<string> => Promise.resolve(this.smartWallet.smartWalletAddress)
+
+  signMessage = (message: string | Bytes): Promise<string> => this.smartWallet.wallet.signMessage(message)
+  signTransaction = (transaction: TransactionRequest): Promise<string> => this.smartWallet.wallet.signTransaction(transaction)
+
+  // calls via smart wallet
+  call (transactionRequest: TransactionRequest, blockTag?: BlockTag): Promise<any> {
+    return this.smartWallet.callStaticDirectExecute(transactionRequest.to!, transactionRequest.data!, { ...filterTxOptions(transactionRequest), blockTag })
+  }
+
+  async sendTransaction (transactionRequest: TransactionRequest): Promise<TransactionResponse> {
+    // waits for confirm()
+    return await new Promise((resolve, reject) => {
+      const nextRequest = Object.freeze<Request>({
+        type: 'sendTransaction',
+        payload: {
+          transactionRequest
+        },
+        confirm: async (overriddenOptions?: Partial<OverriddableTransactionOptions>) => {
+          const txOptions = {
+            ...filterTxOptions(transactionRequest),
+            ...overriddenOptions || {}
+          }
+
+          resolve(await this.smartWallet.directExecute(transactionRequest.to!, transactionRequest.data!, txOptions))
+        },
+        reject: (reason?: any) => {
+          reject(new Error(reason))
+        }
+      })
+
+      // emits onRequest with reference to the transactionRequest
+      this.onRequest(nextRequest)
+    })
+  }
+
+  connect = (provider: Provider): Signer => {
+    throw new Error('Method not implemented')
+  }
+}
diff --git a/src/lib/core/SmartWallet.ts b/src/lib/core/SmartWallet.ts
new file mode 100644
index 000000000..60f103cab
--- /dev/null
+++ b/src/lib/core/SmartWallet.ts
@@ -0,0 +1,39 @@
+import { Wallet, Contract, BytesLike, ContractTransaction, BigNumber } from 'ethers'
+import SmartWalletABI from './SmartWalletABI.json'
+
+const createSmartWalletContract = (address: string) => {
+  return new Contract(address, SmartWalletABI)
+}
+
+export class SmartWallet {
+  smartWalletContract: Contract
+
+  get wallet (): Wallet {
+    return this.smartWalletContract.signer as Wallet
+  }
+
+  get address (): string {
+    return this.wallet.address
+  }
+
+  get smartWalletAddress (): string {
+    return this.smartWalletContract.address
+  }
+
+  private constructor (smartWalletContract: Contract) {
+    this.smartWalletContract = smartWalletContract
+  }
+
+  static create (wallet: Wallet, smartWalletAddress: string) {
+    const smartWalletContract = createSmartWalletContract(smartWalletAddress).connect(wallet)
+    return new SmartWallet(smartWalletContract)
+  }
+
+  directExecute = (to: string, data: BytesLike, ...args: any): Promise<ContractTransaction> => this.smartWalletContract.directExecute(to, data, ...args)
+  estimateDirectExecute = (to: string, data: BytesLike, ...args: any): Promise<BigNumber> => this.smartWalletContract.estimateGas.directExecute(to, data, ...args)
+  callStaticDirectExecute = async (to: string, data: BytesLike, ...args: any): Promise<any> => {
+    const { success, ret }: { success: boolean, ret: string } = await this.smartWalletContract.callStatic.directExecute(to, data, ...args)
+    if (!success) throw new Error(ret)
+    return ret
+  }
+}
diff --git a/src/lib/core/smartWallet/SmartWalletABI.json b/src/lib/core/SmartWalletABI.json
similarity index 100%
rename from src/lib/core/smartWallet/SmartWalletABI.json
rename to src/lib/core/SmartWalletABI.json
diff --git a/src/lib/core/SmartWalletFactory.ts b/src/lib/core/SmartWalletFactory.ts
new file mode 100644
index 000000000..738a1dfc7
--- /dev/null
+++ b/src/lib/core/SmartWalletFactory.ts
@@ -0,0 +1,50 @@
+import { Wallet, Contract, constants, ContractTransaction } from 'ethers'
+import SmartWalletFactoryABI from './SmartWalletFactoryABI.json'
+
+interface ISmartWalletFactory {
+  getSmartWalletAddress(): Promise<string>
+
+  isDeployed(): Promise<boolean>
+  deploy(): Promise<ContractTransaction>
+}
+
+const createSmartWalletFactoryContract = (address: string) => {
+  return new Contract(address, SmartWalletFactoryABI)
+}
+
+/**
+ * This is a Smart Wallet Factory contract helper for a given Wallet
+ */
+export class SmartWalletFactory implements ISmartWalletFactory {
+  smartAddress: string
+  smartWalletFactoryContract: Contract
+
+  private constructor (smartAddress: string, smartWalletFactoryContract: Contract) {
+    this.smartAddress = smartAddress
+    this.smartWalletFactoryContract = smartWalletFactoryContract
+  }
+
+  private static getSmartWalletParams (address: string) {
+    return [
+      address,
+      constants.AddressZero,
+      constants.Zero
+    ]
+  }
+
+  static async create (wallet: Wallet, smartWalletFactoryContractAddress: string) {
+    const smartWalletFactoryContract = createSmartWalletFactoryContract(smartWalletFactoryContractAddress).connect(wallet)
+    const smartAddress = await smartWalletFactoryContract.getSmartWalletAddress(...SmartWalletFactory.getSmartWalletParams(wallet.address))
+    return new SmartWalletFactory(smartAddress, smartWalletFactoryContract)
+  }
+
+  // deployment
+  getSmartWalletAddress = (): Promise<string> => Promise.resolve(this.smartAddress)
+
+  isDeployed = (): Promise<boolean> => this.smartWalletFactoryContract.signer.provider!.getCode(this.smartAddress).then(code => code !== '0x')
+
+  deploy = (): Promise<ContractTransaction> => this.smartWalletFactoryContract.selfCreateUserSmartWallet(
+    constants.AddressZero,
+    constants.Zero
+  )
+}
diff --git a/src/lib/core/smartWallet/SmartWalletFactoryABI.json b/src/lib/core/SmartWalletFactoryABI.json
similarity index 99%
rename from src/lib/core/smartWallet/SmartWalletFactoryABI.json
rename to src/lib/core/SmartWalletFactoryABI.json
index fa7321d28..c8cad9080 100644
--- a/src/lib/core/smartWallet/SmartWalletFactoryABI.json
+++ b/src/lib/core/SmartWalletFactoryABI.json
@@ -341,4 +341,4 @@
     "stateMutability": "nonpayable",
     "type": "function"
   }
-]
\ No newline at end of file
+]
diff --git a/src/lib/core/Wallet.ts b/src/lib/core/Wallet.ts
deleted file mode 100644
index 3d7e709f5..000000000
--- a/src/lib/core/Wallet.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { generateMnemonic, mnemonicToSeedSync } from '@rsksmart/rif-id-mnemonic'
-import { TransactionRequest } from '@ethersproject/abstract-provider'
-import { Account } from '.'
-import { fromSeed } from 'bip32'
-import { QueuedTransaction } from './Account'
-
-class Wallet {
-  private mnemonic: string
-  private handleUxInteraction?: (
-    qt: QueuedTransaction,
-  ) => Promise<TransactionRequest>
-
-  // creates the mnemonic
-  constructor({
-    mnemonic,
-    handleUxInteraction,
-  }: {
-    mnemonic: string
-    handleUxInteraction?: (qt: QueuedTransaction) => any
-  }) {
-    this.mnemonic = mnemonic
-    this.handleUxInteraction = handleUxInteraction
-  }
-
-  static create(handleUxInteraction?: any): Wallet {
-    // TODO: disengage
-    const mnemonic = generateMnemonic(24)
-    const wallet = new Wallet({ mnemonic, handleUxInteraction })
-    return wallet
-  }
-
-  async getAccount(index: number): Promise<Account> {
-    const seed = mnemonicToSeedSync(this.mnemonic)
-    const hdKey = fromSeed(seed).derivePath("m/44'/37310'/0'/0")
-    const privateKey = hdKey.derive(index).privateKey!.toString('hex')
-    return await Account.create({
-      privateKey,
-      handleUxInteraction: this.handleUxInteraction,
-    })
-  }
-
-  get getMnemonic() {
-    return this.mnemonic
-  }
-}
-
-export default Wallet
diff --git a/src/lib/core/filterTxOptions.ts b/src/lib/core/filterTxOptions.ts
new file mode 100644
index 000000000..d2f4579bf
--- /dev/null
+++ b/src/lib/core/filterTxOptions.ts
@@ -0,0 +1,8 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider'
+
+export const filterTxOptions = (transactionRequest: TransactionRequest) => Object.keys(transactionRequest)
+  .filter(key => !['from', 'to', 'data'].includes(key))
+  .reduce((obj: any, key: any) => {
+    obj[key] = (transactionRequest as any)[key]
+    return obj
+  }, {})
diff --git a/src/lib/core/index.ts b/src/lib/core/index.ts
index c9463e6fa..c93ebe503 100644
--- a/src/lib/core/index.ts
+++ b/src/lib/core/index.ts
@@ -1,2 +1,2 @@
-export { default as Account } from './Account'
-export { default as Wallet } from './Wallet'
+export * from './KeyManagementSystem'
+export * from './RIFWallet'
diff --git a/src/lib/core/smartWallet/smart-wallet-factory.js b/src/lib/core/smartWallet/smart-wallet-factory.js
deleted file mode 100644
index 2e331b6eb..000000000
--- a/src/lib/core/smartWallet/smart-wallet-factory.js
+++ /dev/null
@@ -1,44 +0,0 @@
-import { Contract, constants } from 'ethers'
-import SmartWalletFactoryABI from './SmartWalletFactoryABI'
-
-const smartWalletFactoryTestnetAddress =
-  '0x3f71ce7bd7912bf3b362fd76dd34fa2f017b6388'
-const smartWalletFactoryContract = new Contract(
-  smartWalletFactoryTestnetAddress,
-  SmartWalletFactoryABI,
-)
-
-export class SmartWalletFactory {
-  constructor(signer) {
-    this.smartWalletFactory = smartWalletFactoryContract.connect(signer)
-  }
-
-  async getSmartWalletParams() {
-    return [
-      await this.smartWalletFactory.signer.getAddress(),
-      constants.AddressZero,
-      constants.Zero,
-    ]
-  }
-
-  getSmartAddress = async () =>
-    this.smartWalletFactory.getSmartWalletAddress(
-      ...(await this.getSmartWalletParams()),
-    )
-  getCodeInSmartWallet = async () =>
-    this.smartWalletFactory.signer.provider.getCode(
-      await this.getSmartAddress(),
-    )
-  createSmartWallet = () =>
-    this.smartWalletFactory.selfCreateUserSmartWallet(
-      constants.AddressZero,
-      constants.Zero,
-    )
-}
-
-/**
- * case 1: you want to send tokens direct send
- *   -> you need to create on your own (with sc tunned)
- * case 2: you want to send tokens relayed
- *   -> relay is creating your smart wallet
- */
diff --git a/src/lib/core/smartWallet/smart-wallet.js b/src/lib/core/smartWallet/smart-wallet.js
deleted file mode 100644
index e6190cb5e..000000000
--- a/src/lib/core/smartWallet/smart-wallet.js
+++ /dev/null
@@ -1,15 +0,0 @@
-import { Contract } from 'ethers'
-import SmartWalletFactoryABI from './SmartWalletABI'
-
-const createSmartWalletContract = address =>
-  new Contract(address, SmartWalletFactoryABI)
-
-export class SmartWallet {
-  constructor(address, signer) {
-    this.smartWalletContract =
-      createSmartWalletContract(address).connect(signer)
-  }
-
-  directExecute = (to, data, ...params) =>
-    this.smartWalletContract.directExecute(to, data, ...params)
-}
diff --git a/src/lib/core/tests/Account.test.ts b/src/lib/core/tests/Account.test.ts
deleted file mode 100644
index 919e7e21b..000000000
--- a/src/lib/core/tests/Account.test.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-// import { TransactionRequest } from '@ethersproject/abstract-provider'
-import Account from '../Account'
-import {
-  private_key_testnet_0,
-  private_key_testnet_1,
-  address_testnet_0,
-  address_testnet_1,
-  message,
-  sig_testnet_0,
-} from './test-case'
-
-// eslint-disable-next-line jest/no-disabled-tests
-describe.skip('Wallet', () => {
-  describe('info', () => {
-    test('has an address', async () => {
-      const account = await Account.create({
-        privateKey: private_key_testnet_0,
-      })
-      expect(account.address.toLowerCase()).toEqual(address_testnet_0)
-    })
-
-    test('creates the correct address', async () => {
-      const account = await Account.create({
-        privateKey: private_key_testnet_1,
-      })
-      expect(account.address.toLowerCase()).toEqual(address_testnet_1)
-    })
-  })
-
-  describe('proxy methods', function (this: { account: Account }) {
-    beforeEach(async () => {
-      this.account = await Account.create({ privateKey: private_key_testnet_0 })
-    })
-
-    test('returns account', async () => {
-      expect((await this.account.getAddress()).toLowerCase()).toEqual(
-        address_testnet_0,
-      )
-    })
-
-    test('signs messages', async () => {
-      expect(await this.account.signMessage(message)).toEqual(sig_testnet_0)
-    })
-
-    test('cannot change provider', () => {
-      expect(() => this.account.connect({} as any)).toThrow()
-    })
-  })
-
-  describe('transaction queue', function (this: { account: Account }) {
-    beforeEach(async () => {
-      this.account = await Account.create({ privateKey: private_key_testnet_0 })
-    })
-
-    test('cannot get next of emtpy queue', () => {
-      expect(() => this.account.nextTransaction()).toThrow()
-    })
-    /*
-    test('can queue a transaction', async () => {
-      const transactionRequest: TransactionRequest = { to: address_testnet_1 }
-      const transactionPromise =
-        this.account.sendTransaction(transactionRequest)
-
-      const nextTransaction = this.account.nextTransaction()
-      expect(nextTransaction.transactionRequest).toEqual(transactionRequest)
-
-      nextTransaction.confirm()
-
-      const transaction = await transactionPromise
-      expect(transaction).toBeDefined()
-    })
-
-    test('can queue many transaction', async () => {
-      const transactionRequest1: TransactionRequest = {
-        to: address_testnet_1,
-        data: '0x1234',
-      }
-      const transactionRequest2: TransactionRequest = {
-        to: address_testnet_1,
-        data: '0x5678',
-      }
-
-      const transactionPromise1 =
-        this.account.sendTransaction(transactionRequest1)
-      const transactionPromise2 =
-        this.account.sendTransaction(transactionRequest2)
-
-      let nextTransaction = this.account.nextTransaction()
-      expect(nextTransaction.transactionRequest).toEqual(transactionRequest1)
-
-      nextTransaction.confirm()
-
-      const transaction1 = await transactionPromise1
-      expect(transaction1).toBeDefined()
-
-      nextTransaction = this.account.nextTransaction()
-      expect(nextTransaction.transactionRequest).toEqual(transactionRequest2)
-
-      nextTransaction.confirm()
-
-      const transaction2 = await transactionPromise2
-      expect(transaction2).toBeDefined()
-      expect(transaction1).not.toEqual(transaction2)
-    })*/
-  })
-})
diff --git a/src/lib/core/tests/Wallet.test.ts b/src/lib/core/tests/Wallet.test.ts
deleted file mode 100644
index 856501059..000000000
--- a/src/lib/core/tests/Wallet.test.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import Wallet from '../Wallet'
-import {
-  mnemonic,
-  private_key_testnet_0,
-  private_key_testnet_1,
-} from './test-case'
-
-// eslint-disable-next-line jest/no-disabled-tests
-describe.skip('RIFWallet', () => {
-  describe('create a wallet', () => {
-    test('wallets have a 24 word mneomnic', () => {
-      const wallet = Wallet.create()
-      expect(wallet.getMnemonic.split(' ')).toHaveLength(24)
-    })
-
-    test('creates different wallets', () => {
-      const wallet = Wallet.create()
-      const anotherWallet = Wallet.create()
-      expect(wallet.getMnemonic).not.toEqual(anotherWallet.getMnemonic)
-    })
-  })
-
-  describe('import wallet', () => {
-    test('imports a wallet given a mnemonic', () => {
-      const wallet = new Wallet({ mnemonic })
-      expect(wallet.getMnemonic).toEqual(mnemonic)
-    })
-  })
-
-  describe('derives accounts', () => {
-    test('creates a private key for an account', async () => {
-      const wallet = new Wallet({ mnemonic })
-      const account = await wallet.getAccount(0)
-      expect(account.privateKey).toEqual(private_key_testnet_0)
-    })
-
-    test('creates the tree of private keys', async () => {
-      const wallet = new Wallet({ mnemonic })
-      const account = await wallet.getAccount(1)
-      expect(account.privateKey).toEqual(private_key_testnet_1)
-    })
-  })
-})
diff --git a/src/lib/core/tests/test-case.ts b/src/lib/core/tests/test-case.ts
deleted file mode 100644
index 11d8e8242..000000000
--- a/src/lib/core/tests/test-case.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-// test case - do not reuse
-export const mnemonic =
-  'stock potato vanish horn pattern piece decade tent month decrease mansion only pond enough bar boy lemon select depart bleak diagram creek maximum neglect'
-
-export const private_key_testnet_0 =
-  '0x66863843044406245f2352e8bd93e5cd6304c5c6f14909b65249b186af1b9deb'
-export const private_key_testnet_1 =
-  '0xb87803c196f7dd8fc506304de3f8d172fc26055d3b67671d8f623d780b70af21'
-
-export const address_testnet_0 = '0xf0c9322e8830f76b51f43751c8927be0e5f64bea'
-export const address_testnet_1 = '0x55ef3895938174a8cbeb3610a509b9ba35afa9e3'
-
-export const message = 'rif wallet'
-export const sig_testnet_0 =
-  '0x6fc710e13a87bd69a67c0bca261cbb224585fdb10a700ca99bde3d2d5f5aeab2482f4e54b7b47e1bb5421b752be4bd3039c331053ea5c0c7b8c38393fe22ecfe1b'
diff --git a/src/lib/token/tokenMetadata.ts b/src/lib/token/tokenMetadata.ts
index 66faa30e4..fc92dcb9e 100644
--- a/src/lib/token/tokenMetadata.ts
+++ b/src/lib/token/tokenMetadata.ts
@@ -11,10 +11,10 @@ import tokenMainnet from './assets/token-mainnet.svg'
 // @ts-ignore
 import tokenTestnet from './assets/token-testnet.svg'
 
-import { Signer } from 'ethers'
 import { IToken } from './BaseToken'
 import { ERC20Token } from './ERC20Token'
 import { RBTCToken } from './RBTCToken'
+import { RIFWallet } from '../core/RIFWallet'
 
 export interface ITokenMetadata {
   [address: string]: {
@@ -52,7 +52,7 @@ export const getTokenLogo = (address: string, chainId: number) => {
   return chainId === MAINNET_CHAINID ? tokenMainnet : tokenTestnet
 }
 
-export const getAllTokens = async (signer: Signer): Promise<IToken[]> => {
+export const getAllTokens = async (signer: RIFWallet): Promise<IToken[]> => {
   const chainId = await signer.getChainId()
 
   const metadataTokens =
diff --git a/src/modal/ReviewTransactionModal.test.tsx b/src/modal/ReviewTransactionModal.test.tsx
index 41e0664c1..64af6146c 100644
--- a/src/modal/ReviewTransactionModal.test.tsx
+++ b/src/modal/ReviewTransactionModal.test.tsx
@@ -2,29 +2,32 @@ import React from 'react'
 import { render, fireEvent } from '@testing-library/react-native'
 
 import ReviewTransactionModal from './ReviewTransactionModal'
-import { QueuedTransaction } from '../lib/core/Account'
+import { Request } from '../lib/core/RIFWallet'
+import { BigNumber } from '@ethersproject/bignumber'
 
 describe('ReviewTransactionModal', function (this: {
   confirm: ReturnType<typeof jest.fn>
   cancel: ReturnType<typeof jest.fn>
-  queuedTransaction: QueuedTransaction
+  queuedTransaction: Request
 }) {
   beforeEach(() => {
     this.confirm = jest.fn()
     this.cancel = jest.fn()
 
     this.queuedTransaction = {
-      id: 0,
-      transactionRequest: {
-        to: '0x123',
-        from: '0x456',
-        data: '',
-        value: 1000,
-        gasLimit: 10000,
-        gasPrice: 0.068,
+      type: 'sendTransaction',
+      payload: {
+        transactionRequest: {
+          to: '0x123',
+          from: '0x456',
+          data: '',
+          value: BigNumber.from(1000),
+          gasLimit: BigNumber.from(10000),
+          gasPrice: BigNumber.from(600000000),
+        },
       },
       confirm: this.confirm,
-      cancel: this.cancel,
+      reject: this.cancel,
     }
   })
 
@@ -51,9 +54,11 @@ describe('ReviewTransactionModal', function (this: {
       />,
     )
     fireEvent.press(getByTestId('Confirm.Button'))
-    expect(this.confirm).toBeCalledWith(
-      this.queuedTransaction.transactionRequest,
-    )
+
+    expect(this.confirm).toBeCalledWith({
+      gasPrice: this.queuedTransaction.payload.transactionRequest.gasPrice,
+      gasLimit: this.queuedTransaction.payload.transactionRequest.gasLimit,
+    })
     expect(closeModal).toBeCalled()
   })
 
@@ -80,16 +85,18 @@ describe('ReviewTransactionModal', function (this: {
       />,
     )
 
-    fireEvent.changeText(getByTestId('gasLimit.TextInput'), '20')
-    fireEvent.changeText(getByTestId('gasPrice.TextInput'), '1000')
+    const gasPrice = '20'
+    const gasLimit = '1000'
+
+    fireEvent.changeText(getByTestId('gasLimit.TextInput'), gasLimit)
+    fireEvent.changeText(getByTestId('gasPrice.TextInput'), gasPrice)
 
     fireEvent.press(getByTestId('Confirm.Button'))
-    expect(closeModal).toBeCalled()
 
     expect(this.confirm).toBeCalledWith({
-      ...this.queuedTransaction.transactionRequest,
-      gasLimit: 20,
-      gasPrice: 1000,
+      gasPrice: BigNumber.from(gasPrice),
+      gasLimit: BigNumber.from(gasLimit),
     })
+    expect(closeModal).toHaveBeenCalled()
   })
 })
diff --git a/src/modal/ReviewTransactionModal.tsx b/src/modal/ReviewTransactionModal.tsx
index 4d75c7f1d..63918ab84 100644
--- a/src/modal/ReviewTransactionModal.tsx
+++ b/src/modal/ReviewTransactionModal.tsx
@@ -1,9 +1,12 @@
 import React, { useState } from 'react'
 import { Modal, StyleSheet, TextInput, View } from 'react-native'
 
+import { TransactionRequest } from '@ethersproject/abstract-provider'
+import { Request } from '../lib/core/RIFWallet'
+
 import Button from '../components/button'
 import { Header2, Paragraph } from '../components/typography'
-import { QueuedTransaction, TransactionRequest } from '../lib/core/Account'
+import { BigNumber } from '@ethersproject/bignumber'
 
 /**
  * Used for UI only to make editing transactions easier. Allows for
@@ -19,68 +22,65 @@ interface StringTransaction {
 }
 
 interface Interface {
-  queuedTransactionRequest: QueuedTransaction
+  queuedTransactionRequest: Request
   closeModal: () => void
 }
 
+// string object helpers
+const convertValueToString = (value?: any) => (value ? value.toString() : '')
+const convertNumberToString = (value?: any) => (value ? value.toString() : '0')
+
+const convertTransactionToStrings = (tx: TransactionRequest) => ({
+  to: convertValueToString(tx.to),
+  from: convertValueToString(tx.from),
+  value: convertNumberToString(tx.value),
+  // nonce: convertNumberToString(tx.nonce),
+  data: convertValueToString(tx.data),
+  gasLimit: convertNumberToString(tx.gasLimit),
+  gasPrice: convertNumberToString(tx.gasPrice),
+})
+
+/*
+  removed validations for now. we can use BigNumber.from to validate
+  confirmTransaction will enforce that now
+
+  if (gasPrice.match(/^(\d*)([,.]\d{0,})?$/)) {
+    setUpdateTransaction({
+      ...updateTransaction,
+      gasPrice: gasPrice,
+    })
+  }
+  if (parseInt(gasLimit, 10).toString() === gasLimit || gasLimit === '') {
+    setUpdateTransaction({
+      ...updateTransaction,
+      gasLimit: gasLimit,
+    })
+  }
+
+*/
+
 const ReviewTransactionModal: React.FC<Interface> = ({
   queuedTransactionRequest,
   closeModal,
 }) => {
-  const { transactionRequest } = queuedTransactionRequest
-
-  // string object helpers
-  const convertValueToString = (value?: any) => (value ? value.toString() : '')
-  const convertNumberToString = (value?: any) =>
-    value ? value.toString() : '0'
-
-  const convertTransactionToStrings = (tx: TransactionRequest) => ({
-    to: convertValueToString(tx.to),
-    from: convertValueToString(tx.from),
-    value: convertNumberToString(tx.value),
-    // nonce: convertNumberToString(tx.nonce),
-    data: convertValueToString(tx.data),
-    gasLimit: convertNumberToString(tx.gasLimit),
-    gasPrice: convertNumberToString(tx.gasPrice),
-  })
-
-  const [updateTransaction, setUpdateTransaction] = useState<StringTransaction>(
-    convertTransactionToStrings(transactionRequest),
+  const transactionRequest = convertTransactionToStrings(
+    queuedTransactionRequest.payload.transactionRequest,
   )
 
-  // gasLimit can be a number or empty (temporarly)
-  const changeGasLimit = (gasLimit: string) => {
-    if (parseInt(gasLimit, 10).toString() === gasLimit || gasLimit === '') {
-      setUpdateTransaction({
-        ...updateTransaction,
-        gasLimit: gasLimit,
-      })
-    }
-  }
-
-  // gasPrice is an integer that temporarly can end with 0 or a dot
-  const changeGasPrice = (gasPrice: string) => {
-    if (gasPrice.match(/^(\d*)([,.]\d{0,})?$/)) {
-      setUpdateTransaction({
-        ...updateTransaction,
-        gasPrice: gasPrice,
-      })
-    }
-  }
+  const [gasPrice, setGasPrice] = useState(transactionRequest.gasPrice)
+  const [gasLimit, setGasLimit] = useState(transactionRequest.gasLimit)
 
   // convert from string to Transaction and pass out of component
   const confirmTransaction = () => {
     queuedTransactionRequest.confirm({
-      ...updateTransaction,
-      value: parseInt(updateTransaction.value, 10),
-      gasLimit: parseInt(updateTransaction.gasLimit, 10),
-      gasPrice: parseFloat(updateTransaction.gasPrice),
+      gasPrice: BigNumber.from(gasPrice),
+      gasLimit: BigNumber.from(gasLimit),
     })
     closeModal()
   }
 
   const cancelTransaction = () => {
-    queuedTransactionRequest.cancel()
+    queuedTransactionRequest.reject('User rejects the transaction')
     closeModal()
   }
 
@@ -105,9 +105,9 @@ const ReviewTransactionModal: React.FC<Interface> = ({
               </View>
               <View style={styles.column}>
                 <TextInput
-                  value={updateTransaction.gasLimit}
+                  value={gasLimit}
                   style={styles.textInput}
-                  onChangeText={changeGasLimit}
+                  onChangeText={setGasLimit}
                   keyboardType="number-pad"
                   placeholder="gas limit"
                   testID="gasLimit.TextInput"
@@ -120,9 +120,9 @@ const ReviewTransactionModal: React.FC<Interface> = ({
               </View>
               <View style={styles.column}>
                 <TextInput
-                  value={updateTransaction.gasPrice}
+                  value={gasPrice}
                   style={styles.textInput || ''}
-                  onChangeText={changeGasPrice}
+                  onChangeText={setGasPrice}
                   keyboardType="number-pad"
                   placeholder="gas price"
                   testID="gasPrice.TextInput"
diff --git a/src/screens/receive/ReceiveScreen.test.tsx b/src/screens/receive/ReceiveScreen.test.tsx
index 3f8b244e6..d238e5355 100644
--- a/src/screens/receive/ReceiveScreen.test.tsx
+++ b/src/screens/receive/ReceiveScreen.test.tsx
@@ -2,7 +2,7 @@ import React from 'react'
 
 import mockClipboard from './clipboard-mock'
 
-import { render, fireEvent, act, waitFor } from '@testing-library/react-native'
+import { render, fireEvent, act } from '@testing-library/react-native'
 
 import ReceiveScreen from './ReceiveScreen'
 
@@ -12,9 +12,7 @@ describe('ReceiveScreen', () => {
   const route = {
     params: {
       account: {
-        getSmartAddress: jest.fn(() =>
-          Promise.resolve('0xbd4c8e11cf2c560382e0dbd6aeef538debf1d449'),
-        ),
+        smartWalletAddress: '0xbd4c8e11cf2c560382e0dbd6aeef538debf1d449',
       },
     },
   }
@@ -26,10 +24,6 @@ describe('ReceiveScreen', () => {
   it('renders', async () => {
     const { getAllByText, rerender } = render(<ReceiveScreen route={route} />)
 
-    await waitFor(() =>
-      expect(route.params.account.getSmartAddress).toHaveBeenCalledTimes(1),
-    )
-
     act(() => {
       rerender(<ReceiveScreen route={route} />)
     })
diff --git a/src/screens/receive/ReceiveScreen.tsx b/src/screens/receive/ReceiveScreen.tsx
index 4020580ad..aec162e4c 100644
--- a/src/screens/receive/ReceiveScreen.tsx
+++ b/src/screens/receive/ReceiveScreen.tsx
@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from 'react'
+import React, { useState } from 'react'
 import { StyleSheet, View, ScrollView, Dimensions, Share } from 'react-native'
 import Clipboard from '@react-native-community/clipboard'
 
@@ -8,7 +8,7 @@ import { Paragraph } from '../../components/typography'
 import QRCode from 'react-qr-code'
 
 import { shortAddress } from '../../lib/utils'
-import { Account } from '../../lib/core'
+import { RIFWallet } from '../../lib/core/RIFWallet'
 
 // TODO: accountLink is hardcoded until we had the rns sdk
 const accountLink = 'ilan.rsk'
@@ -64,19 +64,15 @@ interface IReceiveScreenProps {
 }
 
 const ReceiveScreen: React.FC<IReceiveScreenProps> = ({ route }) => {
-  const account = route.params.account as Account
+  const account = route.params.account as RIFWallet
 
-  const [smartAddress, setSmartAddress] = useState('')
+  const smartAddress = account.smartWalletAddress
   const { isCopying: isCopyingAccount, handleCopy: handleCopyAccount } =
     useCopy(smartAddress)
   const { isCopying: isCopyingAccountLink, handleCopy: handleCopyAccountLink } =
     useCopy(accountLink)
   const { isSharing, handleShare } = useShare('Account', smartAddress)
 
-  useEffect(() => {
-    account.getSmartAddress().then(setSmartAddress)
-  }, [account])
-
   return (
     <ScrollView>
       <View style={styles.section}>
diff --git a/src/screens/send/SendTransaction.test.tsx b/src/screens/send/SendTransaction.test.tsx
index c12309d40..0c11462f9 100644
--- a/src/screens/send/SendTransaction.test.tsx
+++ b/src/screens/send/SendTransaction.test.tsx
@@ -89,10 +89,6 @@ describe('Load Tokens', () => {
       <SendTransaction route={route} />,
     )
 
-    await waitFor(() =>
-      expect(route.params.account.getSmartAddress).toHaveBeenCalledTimes(1),
-    )
-
     act(() => {
       rerender(<SendTransaction route={route} />)
     })
@@ -104,29 +100,24 @@ describe('Load Tokens', () => {
   test('selects tokens', async () => {
     const { rerender, getByTestId } = render(<SendTransaction route={route} />)
 
-    await waitFor(() =>
-      expect(route.params.account.getSmartAddress).toHaveBeenCalledTimes(1),
-    )
-    act(() => {
-      rerender(<SendTransaction route={route} />)
+    act(async () => {
+      await rerender(<SendTransaction route={route} />)
     })
 
     const picker = getByTestId('Tokens.Picker')
 
-    fireEvent(picker, 'onValueChange', 'FIRST_TEST_ERC20')
-
-    expect(picker.props.selectedIndex).toStrictEqual(0)
-    fireEvent(picker, 'onValueChange', 'SECOND_TEST_ERC20')
+    act(async () => {
+      await fireEvent(picker, 'onValueChange', 'FIRST_TEST_ERC20')
+      expect(picker.props.selectedIndex).toStrictEqual(0)
 
-    expect(picker.props.selectedIndex).toStrictEqual(1)
+      await fireEvent(picker, 'onValueChange', 'SECOND_TEST_ERC20')
+      expect(picker.props.selectedIndex).toBe(1)
+    })
   })
 
   test('send transaction', async () => {
     const { rerender, getByTestId } = render(<SendTransaction route={route} />)
 
-    await waitFor(() =>
-      expect(route.params.account.getSmartAddress).toHaveBeenCalledTimes(1),
-    )
     act(() => {
       rerender(<SendTransaction route={route} />)
     })
diff --git a/src/screens/send/SendTransaction.tsx b/src/screens/send/SendTransaction.tsx
index 425cf3f93..bb08e6a84 100644
--- a/src/screens/send/SendTransaction.tsx
+++ b/src/screens/send/SendTransaction.tsx
@@ -9,16 +9,18 @@ import Button from '../../components/button'
 import { Paragraph } from '../../components/typography'
 import { getAllTokens } from '../../lib/token/tokenMetadata'
 
-import Account from '../../lib/core/Account'
 import { TransactionReceipt } from '@ethersproject/abstract-provider'
 import { IToken } from '../../lib/token/BaseToken'
+import { RIFWallet } from '../../lib/core/RIFWallet'
 
 interface Interface {
   route: any
 }
 
 const SendTransaction: React.FC<Interface> = ({ route }) => {
-  const [smartAddress, setSmartAddress] = useState('')
+  const account = route.params.account as RIFWallet
+  const smartAddress = account.smartWalletAddress
+
   const [to, setTo] = useState('0x1D4F6A5FE927f0E0e4497B91CebfBcF64dA1c934')
   const [selectedSymbol, setSelectedSymbol] = useState('tRBTC')
   const [availableTokens, setAvailableTokens] = useState<IToken[]>()
@@ -28,10 +30,7 @@ const SendTransaction: React.FC<Interface> = ({ route }) => {
   const [txSent, setTxSent] = useState(false)
   const [info, setInfo] = useState('')
 
-  const account = route.params.account as Account
-
   useEffect(() => {
-    account.getSmartAddress().then(setSmartAddress)
     getAllTokens(account).then(tokens => setAvailableTokens(tokens))
   }, [account])
 
@@ -67,7 +66,7 @@ const SendTransaction: React.FC<Interface> = ({ route }) => {
           setTx(txReceipt)
           setInfo('Transaction Confirmed.')
           setTxConfirmed(true)
-        } catch (e) {
+        } catch (e: any) {
           setInfo('Transaction Failed: ' + e.message)
         }
       }
diff --git a/src/state/AppContext.tsx b/src/state/AppContext.tsx
index 82d83ccc5..e77998c08 100644
--- a/src/state/AppContext.tsx
+++ b/src/state/AppContext.tsx
@@ -1,26 +1,31 @@
+import { Wallet } from '@ethersproject/wallet'
 import React, { useEffect, useState } from 'react'
 
-import { Wallet } from '../lib/core'
-import { QueuedTransaction } from '../lib/core/Account'
+// import { Wallet } from '../lib/core'
+// import { QueuedTransaction } from '../lib/core/Account'
+import { KeyManagementSystem } from '../lib/core/KeyManagementSystem'
+import { Request, RIFWallet } from '../lib/core/RIFWallet'
+import { jsonRpcProvider } from '../lib/jsonRpcProvider'
+
 import { getStorage, setStorage, StorageKeys } from '../storage'
 
 export interface WalletProviderContextInterface {
-  wallet?: Wallet
-  setWallet: (wallet: Wallet) => void
-  userInteractionQue: QueuedTransaction[]
+  wallets: RIFWallet[]
+  getMnemonic: () => string
+  walletRequests: Request[]
+
   handleUxInteraction: any // (qt: QueuedTransaction) => Promise<TransactionRequest>
   resolveUxInteraction: () => void
-  reset: () => void
 }
 
 export const WalletProviderContext =
   React.createContext<WalletProviderContextInterface>({
-    wallet: undefined,
-    setWallet: (_wallet: Wallet) => {},
-    userInteractionQue: [],
-    handleUxInteraction: (_qt: any) => Promise.resolve({}),
+    wallets: [],
+    getMnemonic: () => '',
+    walletRequests: [],
+
+    handleUxInteraction: (_qt: Request) => Promise.resolve({}),
     resolveUxInteraction: () => null,
-    reset: () => {},
   })
 
 interface Web3ProviderElementInterface {
@@ -30,39 +35,68 @@ interface Web3ProviderElementInterface {
 export const WalletProviderElement: React.FC<Web3ProviderElementInterface> = ({
   children,
 }) => {
-  const [wallet, setWallet] = useState<Wallet | undefined>(undefined)
-  const [userInteractionQue, setUserInteractionQue] = useState<
-    QueuedTransaction[]
-  >([])
+  // private state:
+  const [keyManagementSystem, setKeyManagementSystem] = useState<
+    KeyManagementSystem | undefined
+  >(undefined)
 
-  const handleUxInteraction = (transactionRequest: QueuedTransaction) =>
-    setUserInteractionQue(userInteractionQue.concat(transactionRequest))
+  // exposed state via context:
+  const [wallets, setWallets] = useState<RIFWallet[]>([])
+  const [walletRequestQue, setWalletRequestQue] = useState<Request[]>([])
 
-  const resolveUxInteraction = () =>
-    setUserInteractionQue(userInteractionQue.slice(1))
+  const handleUxInteraction = (walletRequest: Request) => {
+    console.log('AppContext handleUxInteraction', walletRequest)
+    setWalletRequestQue([walletRequest])
+  }
+  const resolveUxInteraction = () => setWalletRequestQue([])
 
   const initialContext: WalletProviderContextInterface = {
-    wallet,
-    setWallet,
-    userInteractionQue,
+    wallets,
+    getMnemonic: () =>
+      keyManagementSystem ? keyManagementSystem?.mnemonic : '',
+    walletRequests: walletRequestQue,
     handleUxInteraction,
     resolveUxInteraction,
-    reset: () => setWallet(undefined),
   }
 
-  // Get the mnemonic from storage, or create a new wallet
+  const init = async (initProps: {
+    kms: KeyManagementSystem
+    wallets: Wallet[]
+  }) => {
+    console.log('the init! ;-)', initProps)
+
+    // save the KMS:
+    setKeyManagementSystem(initProps.kms)
+
+    // convert the Wallets[] into RIFWallets[]:
+    const tempWallet = initProps.wallets[0] // @todo: change to this to loop
+    const ethersWallet = tempWallet.connect(jsonRpcProvider)
+
+    RIFWallet.create(
+      ethersWallet,
+      '0x3f71ce7bd7912bf3b362fd76dd34fa2f017b6388',
+      handleUxInteraction,
+    ).then((wallet: RIFWallet) => setWallets([wallet]))
+  }
+
+  // Get the mnemonic from storage, or create a new KMS with default wallet
   useEffect(() => {
-    getStorage(StorageKeys.MNEMONIC)
-      .then(
-        (mnemonic: string | null) =>
-          mnemonic && setWallet(new Wallet({ mnemonic, handleUxInteraction })),
-      )
+    getStorage(StorageKeys.KMS)
+      .then((serialized: string | null) => {
+        if (serialized) {
+          console.log('getting wallet from storage')
+          init(KeyManagementSystem.fromSerialized(serialized))
+        }
+      })
       .catch(() => {
         // Error: key does not present
-        const newWallet = Wallet.create(handleUxInteraction)
-        setStorage(StorageKeys.MNEMONIC, newWallet.getMnemonic).then(() =>
-          setWallet(newWallet),
-        )
+        console.log('setting up new wallet')
+        const kms = KeyManagementSystem.create()
+        const firstWallet = kms.nextWallet(31)
+        firstWallet.save()
+        setStorage(StorageKeys.KMS, kms.serialize())
+
+        init({ kms, wallets: [firstWallet.wallet] })
       })
   }, [])
 
diff --git a/src/storage/index.ts b/src/storage/index.ts
index d6aaea3f7..a28a0f142 100644
--- a/src/storage/index.ts
+++ b/src/storage/index.ts
@@ -1,7 +1,7 @@
 import RNSecureStorage, { ACCESSIBLE } from 'rn-secure-storage'
 
 export enum StorageKeys {
-  MNEMONIC = 'mnemonic',
+  KMS = 'KEY_MANAGEMENT',
 }
 
 export const getStorage = (key: StorageKeys): Promise<string | null> =>
diff --git a/src/tempScreens/SmartWallet.tsx b/src/tempScreens/SmartWallet.tsx
index 7f5910ada..f167f5fb8 100644
--- a/src/tempScreens/SmartWallet.tsx
+++ b/src/tempScreens/SmartWallet.tsx
@@ -3,31 +3,16 @@ import { ScrollView } from 'react-native-gesture-handler'
 import { Transaction } from 'ethers'
 import Button from '../components/button'
 import { Header2, Paragraph } from '../components/typography'
-import { Account } from '../lib/core'
-import { SmartWalletFactory } from '../lib/core/smartWallet/smart-wallet-factory'
+import { RIFWallet } from '../lib/core/RIFWallet'
 
-import { Contract, BigNumber } from 'ethers'
+import { BigNumber } from 'ethers'
 import CopyComponent from '../components/copy'
-
-const abi = [
-  'function balanceOf(address owner) view returns (uint256)',
-  'function decimals() view returns (uint8)',
-  'function symbol() view returns (string)',
-
-  'function transfer(address to, uint amount) returns (bool)',
-
-  'event Transfer(address indexed from, address indexed to, uint amount)',
-]
-
-export const rifContract = new Contract(
-  '0x19f64674d8a5b4e652319f5e239efd3bc969a1fe',
-  abi,
-)
+import { ERC20Token } from '../lib/token/ERC20Token'
 
 const SmartWalletComponent = ({ route }: { route: any }) => {
   const [eoaBalance, setEoaBalance] = useState<null | BigNumber>(null)
-  const [smartWalletAddress, setSmartWalletAddress] = useState('')
-  const [smartWalletCode, setSmartWalletCode] = useState('')
+  const [isSmartWalletDeployed, setIsSmartWalletDeployed] =
+    useState<boolean>(false)
 
   const [smartWalletDeployTx, setSmartWalletDeployTx] =
     useState<null | Transaction>(null)
@@ -36,27 +21,29 @@ const SmartWalletComponent = ({ route }: { route: any }) => {
   const [sendRifTx, setSendRifTx] = useState<null | Transaction>(null)
   const [sendRifResponse, setSendRifResponse] = useState<null | string>(null)
 
-  const account = route.params.account as Account
-  console.log('eoa', account.address)
+  const account = route.params.account as RIFWallet
 
-  const smartWalletFactory = new SmartWalletFactory(account)
-  const rif = rifContract.connect(account)
+  const rif = new ERC20Token(
+    '0x19f64674d8a5b4e652319f5e239efd3bc969a1fe',
+    account,
+    'RIF',
+    'null.jpg',
+  )
 
   const getInfo = async () => {
-    const address = await account.getSmartAddress()
-    console.log('smart address', address)
-    setSmartWalletAddress(address)
-
     Promise.all([
-      account.getBalance().then(setEoaBalance),
-      smartWalletFactory.getCodeInSmartWallet().then(setSmartWalletCode),
-      rif.balanceOf(address).then(setRifBalance),
-    ])
+      account.smartWallet.wallet.getBalance().then(setEoaBalance),
+      account.smartWalletFactory.isDeployed().then(setIsSmartWalletDeployed),
+      rif.balance().then(setRifBalance),
+    ]).catch((err: Error) => {
+      console.log(err)
+    })
   }
 
   const deploy = async () => {
-    const txPromise = await account.deploy()
+    const txPromise = await account.smartWalletFactory.deploy()
     setSmartWalletDeployTx(await txPromise)
+    setIsSmartWalletDeployed(true)
   }
 
   const sendRif = async () => {
@@ -70,35 +57,35 @@ const SmartWalletComponent = ({ route }: { route: any }) => {
         setSendRifTx(tx)
         setSendRifResponse('Transaction sent.')
       })
-      .catch((err: Error) => {
-        console.log('SmartWallet.tsx catach ?', err)
-        setSendRifResponse(`Transaction Err: ${err.message}`)
-      })
+      .catch((err: Error) =>
+        setSendRifResponse(`Transaction Err: ${err.message}`),
+      )
   }
 
-  const isSmartWalletDeployed = !smartWalletCode || smartWalletCode !== '0x'
-
   return (
     <ScrollView>
       <Header2>Smart Wallet</Header2>
       <Paragraph>EOA:</Paragraph>
+      <CopyComponent value={account.smartWallet.wallet.address} />
+      <Paragraph>Smart Wallet Address:</Paragraph>
       <CopyComponent value={account.address} />
+
       <Button title="Get info" onPress={getInfo} />
       <Paragraph>
         RBTC Balance (EOA): {eoaBalance && eoaBalance.toString()}
       </Paragraph>
-      <Paragraph>Smart Wallet Address:</Paragraph>
-      <CopyComponent value={smartWalletAddress} />
-      <Paragraph>Smart wallet code:</Paragraph>
-      <CopyComponent value={smartWalletCode} />
+
+      <Paragraph>Is Deployed?: {isSmartWalletDeployed.toString()}</Paragraph>
+      {!isSmartWalletDeployed && (
+        <Button
+          title="Deploy"
+          onPress={deploy}
+          disabled={isSmartWalletDeployed}
+        />
+      )}
       <Paragraph>
         RIF Token balance: {rifBalance && rifBalance.toString()}
       </Paragraph>
-      <Button
-        title="Deploy"
-        onPress={deploy}
-        disabled={isSmartWalletDeployed}
-      />
       {smartWalletDeployTx && (
         <>
           <Paragraph>Deploy tx: {smartWalletDeployTx.hash}</Paragraph>
diff --git a/yarn.lock b/yarn.lock
index be2b35584..4d2fe797c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1625,10 +1625,10 @@
     lodash "^4.17.19"
     rskjs-util "^1.0.3"
 
-"@rsksmart/rif-id-mnemonic@^0.1.0":
-  version "0.1.0"
-  resolved "https://registry.npmjs.org/@rsksmart/rif-id-mnemonic/-/rif-id-mnemonic-0.1.0.tgz"
-  integrity sha512-8zXs6GPMj/wiUR8NLHFlOLJFy2KVYYZAYxbtvw577DnPlQUhqfEZDFyxx2U6BpCM/vi2eBM1dQ2hQ4IMTeEn4g==
+"@rsksmart/rif-id-mnemonic@^0.1.1":
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/@rsksmart/rif-id-mnemonic/-/rif-id-mnemonic-0.1.1.tgz#e72ad062755f45180603bc75251d15bc49041cdc"
+  integrity sha512-P6vFTq9Pg6N9GjqdnSXLW4XftGO0gkq9ZCMEFsykb2QnD/e8m/+a9d4PU9TqK/VHGNXBhYU92zUE49r9Zyekgw==
   dependencies:
     "@types/lodash" "^4.14.155"
     "@types/randombytes" "^2.0.0"
@@ -1637,6 +1637,11 @@
     lodash "^4.17.15"
     randombytes "^2.1.0"
 
+"@rsksmart/rlogin-dpath@^1.0.1":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@rsksmart/rlogin-dpath/-/rlogin-dpath-1.0.1.tgz#5ecb1d094d248231cbeda267c1fc5a779c8e46e3"
+  integrity sha512-97aalCxqCy6/JyE5eefka2isC9rU2hfvspQRfkvEVKB3zGJsC/xK0onDwCFH0kBCdkUn2K3lLO0GRnOStdbpIQ==
+
 "@rsksmart/rlogin-eip1193-types@^1.0.0-beta.7":
   version "1.0.1"
   resolved "https://registry.npmjs.org/@rsksmart/rlogin-eip1193-types/-/rlogin-eip1193-types-1.0.1.tgz"