diff --git a/src/pages/Wallet/Send/Submit.tsx b/src/pages/Wallet/Send/Submit.tsx
index 5368a38..b91f663 100644
--- a/src/pages/Wallet/Send/Submit.tsx
+++ b/src/pages/Wallet/Send/Submit.tsx
@@ -41,10 +41,11 @@ export default function Submit ({ transactions, onSubmitted }: {
         <Button className={"gap-2"} onClick={({ currentTarget }) => {
           currentTarget.disabled = true
 
-          kaspa.request('node:submit', [ transactions ]).then((ids) => {
+          kaspa.request('account:submitContextful', [ transactions ]).then((ids) => {
             setIds(ids)
             onSubmitted()
-          }).catch(() => {
+          }).catch((err) => {
+            console.log(err)
             currentTarget.disabled = false
           })
         }}>
diff --git a/src/pages/Wallet/UTXOs.tsx b/src/pages/Wallet/UTXOs.tsx
index a5967d3..5f381d7 100644
--- a/src/pages/Wallet/UTXOs.tsx
+++ b/src/pages/Wallet/UTXOs.tsx
@@ -1,7 +1,6 @@
 import { useEffect, useRef, useState } from "react"
 import { Button } from "@/components/ui/button"
 import useKaspa from "@/hooks/useKaspa"
-import { OutputStatus } from "@/wallet/kaspa/account"
 
 export default function UTXOs () {
   const { kaspa } = useKaspa()
@@ -35,7 +34,7 @@ export default function UTXOs () {
       <div className={"grid grid-cols-3 mx-4 gap-2"}>
         {kaspa.utxos.slice(0, index).map((utxo, id) => {
           return (
-            <div key={id} className={"flex flex-col items-center py-2 border-2 rounded-xl w-full h-24 " + (utxo.status === OutputStatus.mature ? "hover:border-dashed" : (utxo.status === OutputStatus.incoming ? "border-yellow-600" : "border-red-600"))}>
+            <div key={id} className={"flex flex-col items-center py-2 border-2 rounded-xl w-full h-24 " + (utxo.mature ? "hover:border-dashed" : "border-yellow-600")}>
               <p className={"text-lg font-bold"}>{utxo.amount.toFixed(4)}</p>
               <Button variant="link" className={"text-inherit font-extrabold"} onClick={() => {
                 window.open(`https://explorer.kaspa.org/txs/${utxo.transaction}`)
diff --git a/src/wallet/kaspa/account/addresses.ts b/src/wallet/kaspa/account/addresses.ts
index 7bf8fb0..1715cba 100644
--- a/src/wallet/kaspa/account/addresses.ts
+++ b/src/wallet/kaspa/account/addresses.ts
@@ -1,12 +1,19 @@
-import { PublicKeyGenerator } from "@/../wasm"
+import { PublicKeyGenerator, UtxoContext } from "@/../wasm"
+import LocalStorage from "@/storage/LocalStorage"
+import { EventEmitter } from "events"
 
-export default class Addresses {
+export default class Addresses extends EventEmitter {
+  context: UtxoContext
   publicKey: PublicKeyGenerator | undefined
-  networkId: string
+  accountId: number | undefined
+  networkId: string // TODO: can be derived from context
   receiveAddresses: string[] = []
   changeAddresses: string[] = []
 
-  constructor (networkId: string) {
+  constructor (context: UtxoContext, networkId: string) {
+    super()
+
+    this.context = context
     this.networkId = networkId
   }
 
@@ -14,6 +21,15 @@ export default class Addresses {
     return [ ...this.receiveAddresses, ...this.changeAddresses ]
   }
 
+  async import (publicKey: PublicKeyGenerator, accountId: number) {
+    this.publicKey = publicKey
+    this.accountId = accountId
+
+    const account = (await LocalStorage.get('wallet', undefined))!.accounts[accountId]
+
+    await this.increment(account.receiveCount, account.changeCount, false)
+  }
+
   async derive (isReceive: boolean, start: number, end: number) {
     if (!this.publicKey) throw Error('No active account')
 
@@ -24,19 +40,22 @@ export default class Addresses {
     }
   }
 
-  async increment (receiveCount: number, changeCount: number) {
-    const [ receiveAddresses, changeAddresses ] = await Promise.all([
+  async increment (receiveCount: number, changeCount: number, commit = true) {
+    const addresses = await Promise.all([
       this.derive(true, this.receiveAddresses.length, this.receiveAddresses.length + receiveCount),
       this.derive(false, this.changeAddresses.length, this.changeAddresses.length + changeCount)
     ]) 
     
-    this.receiveAddresses.push(...receiveAddresses)
-    this.changeAddresses.push(...changeAddresses)
+    this.receiveAddresses.push(...addresses[0])
+    this.changeAddresses.push(...addresses[1])
     
-    return [ receiveAddresses, changeAddresses ]
+    if (this.context.isActive) await this.context.trackAddresses(addresses.flat())
+    if (commit) await this.commit()
+
+    this.emit('addresses', addresses)
   }
 
-  async setNetworkId (networkId: string) {
+  async changeNetwork (networkId: string) {
     this.networkId = networkId
     this.receiveAddresses = await this.derive(true, 0, this.receiveAddresses.length)
     this.changeAddresses = await this.derive(false, 0, this.changeAddresses.length)
@@ -44,8 +63,19 @@ export default class Addresses {
 
   reset () {
     delete this.publicKey
+    delete this.accountId
 
     this.receiveAddresses = []
     this.changeAddresses = []
   }
+
+  private async commit () {
+    const wallet = (await LocalStorage.get('wallet', undefined))!
+    const account = wallet.accounts[this.accountId!]
+  
+    account.receiveCount = this.receiveAddresses.length
+    account.changeCount = this.changeAddresses.length
+    
+    await LocalStorage.set('wallet', wallet)  
+  }
 }
\ No newline at end of file
diff --git a/src/wallet/kaspa/account/index.ts b/src/wallet/kaspa/account/index.ts
index 6999fbf..c491c12 100644
--- a/src/wallet/kaspa/account/index.ts
+++ b/src/wallet/kaspa/account/index.ts
@@ -2,33 +2,28 @@ import { EventEmitter } from "events"
 import { UtxoContext, UtxoProcessor, PublicKeyGenerator, PrivateKeyGenerator, createTransactions, Transaction, decryptXChaCha20Poly1305, kaspaToSompi, signTransaction, type UtxoEntryReference } from "@/../wasm"
 import type Node from "../node"
 import Addresses from "./addresses"
-import LocalStorage from "@/storage/LocalStorage"
-import SessionStorage, { ISession } from "@/storage/SessionStorage"
-
-export enum OutputStatus {
-  mature,
-  incoming,
-  outgoing
-}
+import SessionStorage from "@/storage/SessionStorage"
+import Transactions from "./transactions"
 
 export interface UTXO {
   amount: number
   transaction: string,
-  status: OutputStatus
+  mature: boolean
 }
 
 export default class Account extends EventEmitter  {
   processor: UtxoProcessor
   addresses: Addresses
-  session: ISession | undefined
   context: UtxoContext
+  transactions: Transactions
 
   constructor (node: Node) {
     super()
 
-    this.addresses = new Addresses(node.networkId)
     this.processor = new UtxoProcessor({ rpc: node.kaspa, networkId: node.networkId })
     this.context = new UtxoContext({ processor: this.processor })
+    this.addresses = new Addresses(this.context, node.networkId)
+    this.transactions = new Transactions(node.kaspa, this.context, this.addresses)
 
     node.on('network', async (networkId: string) => {
       if (this.processor.isActive) {
@@ -39,7 +34,7 @@ export default class Account extends EventEmitter  {
         this.processor.setNetworkId(networkId)
       }
 
-      await this.addresses.setNetworkId(networkId)
+      await this.addresses.changeNetwork(networkId)
     })
 
     this.registerProcessor()
@@ -51,60 +46,16 @@ export default class Account extends EventEmitter  {
   }
 
   get UTXOs () {
-    const mapUTXO = (utxo: UtxoEntryReference, status: OutputStatus) => ({
+    const mapUTXO = (utxo: UtxoEntryReference, mature: boolean) => ({
       amount: Number(utxo.amount) / 1e8,
       transaction: utxo.getTransactionId(),
-      status
+      mature
     })
 
-    const outgoingUTXOs = this.context.getPendingOutgoingTransactions().map(transaction => transaction.transaction.inputs.map((input) => mapUTXO(input.utxo!, OutputStatus.outgoing)))
-    const pendingUTXOs = this.context.getPending().map(utxo => mapUTXO(utxo, OutputStatus.incoming))
-    const matureUTXOs = this.context.getMatureRange(0, this.context.matureLength).map(utxo => mapUTXO(utxo, OutputStatus.mature))
+    const pendingUTXOs = this.context.getPending().map(utxo => mapUTXO(utxo, false))
+    const matureUTXOs = this.context.getMatureRange(0, this.context.matureLength).map(utxo => mapUTXO(utxo, true))
 
-    return [ ...outgoingUTXOs, ...pendingUTXOs, ...matureUTXOs ]
-  }
-
-  async createSend (recipient: string, amount: string, fee: string) {
-    const { transactions } = await createTransactions({
-      entries: this.context,
-      outputs: [{ 
-        address: recipient,
-        amount: kaspaToSompi(amount)!
-      }],
-      changeAddress: this.addresses.changeAddresses[this.addresses.changeAddresses.length - 1],
-      priorityFee: kaspaToSompi(fee)!,
-    })
-
-    await this.incrementAddresses(0, 1)
-    return transactions.map((transaction) => transaction.serializeToSafeJSON())
-  }
-
-  async sign (transactions: string[], password: string) {this.context.getPendingOutgoingTransactions()
-    const keyGenerator = new PrivateKeyGenerator(decryptXChaCha20Poly1305(this.session!.encryptedKey, password), false, BigInt(this.session!.activeAccount))
-    const signedTransactions: Transaction[] = []
-
-    for (const transaction of transactions) {
-      const parsedTransaction = Transaction.deserializeFromSafeJSON(transaction)
-      const privateKeys = []
-
-      for (const address of parsedTransaction.addresses(this.addresses.networkId)) {
-        const receiveIndex = this.addresses.receiveAddresses.indexOf(address.toString())
-        const changeIndex = this.addresses.changeAddresses.indexOf(address.toString())
-
-        if (receiveIndex !== -1) {
-          privateKeys.push(keyGenerator.receiveKey(receiveIndex))
-        } else if (changeIndex !== -1) {
-          privateKeys.push(keyGenerator.changeKey(changeIndex))
-        } else throw Error('UTXO is not owned by active wallet')
-      }
-
-      signedTransactions.push(signTransaction(parsedTransaction, privateKeys, false))
-    }
-    
-    const parsedTransactions = signedTransactions.map(transaction => transaction.serializeToSafeJSON())
-    this.emit('transactions', parsedTransactions)
-
-    return parsedTransactions
+    return [ ...pendingUTXOs, ...matureUTXOs ]
   }
 
   async scan (steps = 50, count = 10) {
@@ -123,11 +74,11 @@ export default class Account extends EventEmitter  {
         if (entries.length > 0) { foundIndex = startIndex }
       }
 
-      await this.incrementAddresses(isReceive ? foundIndex : 0, isReceive ? 0 : foundIndex)
+      await this.addresses.increment(isReceive ? foundIndex : 0, isReceive ? 0 : foundIndex)
     }
   
-    await scanAddresses(true, this.addresses.receiveAddresses.length - 1)
-    await scanAddresses(false, this.addresses.changeAddresses.length - 1)
+    await scanAddresses(true, this.addresses.receiveAddresses.length)
+    await scanAddresses(false, this.addresses.changeAddresses.length)
   }
 
   private registerProcessor () {
@@ -140,7 +91,7 @@ export default class Account extends EventEmitter  {
       const utxos = event.data.data.utxoEntries
 
       if (utxos.some(utxo => utxo.address?.toString() === this.addresses.receiveAddresses[this.addresses.receiveAddresses.length - 1])) {
-        await this.incrementAddresses(1, 0)
+        await this.addresses.increment(1, 0)
       }
     })
 
@@ -149,39 +100,17 @@ export default class Account extends EventEmitter  {
     })
   }
 
-  private async incrementAddresses (receiveCount: number, changeCount: number, initial = false) {
-    const addresses = await this.addresses.increment(receiveCount, changeCount)
-    if (this.processor.isActive) await this.context.trackAddresses(addresses.flat())
-    
-    if (!initial) {
-      const wallet = (await LocalStorage.get('wallet', undefined))!
-      const account = wallet.accounts[this.session!.activeAccount]
-
-      account.receiveCount = this.addresses.receiveAddresses.length
-      account.changeCount = this.addresses.changeAddresses.length
-  
-      await LocalStorage.set('wallet', wallet)
-    }
-
-    this.emit('addresses', addresses)
-  }
-
   private listenSession () {
     SessionStorage.subscribeChanges(async (key, newValue) => {
       if (key !== 'session') return
 
       if (newValue) {
-        this.session = newValue // TODO: Possibly get rid of this w account set optimizations
-        this.addresses.publicKey = await PublicKeyGenerator.fromXPub(this.session.publicKey)
-
-        const account = (await LocalStorage.get('wallet', undefined))!.accounts[this.session.activeAccount]
-        
-        await this.incrementAddresses(account.receiveCount, account.changeCount, true)
+        await this.addresses.import(PublicKeyGenerator.fromXPub(newValue.publicKey), newValue.activeAccount)
+        await this.transactions.import(newValue.encryptedKey, newValue.activeAccount)
         await this.processor.start()
       } else {
-        delete this.session
-
         this.addresses.reset()
+        this.transactions.reset()
         await this.processor.stop()
         await this.context.clear()
       }
diff --git a/src/wallet/kaspa/account/transactions.ts b/src/wallet/kaspa/account/transactions.ts
new file mode 100644
index 0000000..1f52bd5
--- /dev/null
+++ b/src/wallet/kaspa/account/transactions.ts
@@ -0,0 +1,102 @@
+import { createTransactions, decryptXChaCha20Poly1305, kaspaToSompi, PendingTransaction, PrivateKeyGenerator, RpcClient, signTransaction, Transaction, UtxoContext } from "@/../wasm"
+import Addresses from "./addresses"
+import EventEmitter from "events"
+
+export default class Transactions extends EventEmitter {
+  kaspa: RpcClient
+  context: UtxoContext
+  addresses: Addresses
+
+  encryptedKey: string | undefined
+  accountId: number | undefined
+
+  private transactions: Map<string, PendingTransaction> = new Map()
+
+  constructor (kaspa: RpcClient, context: UtxoContext, addresses: Addresses) {
+    super()
+    
+    this.kaspa = kaspa
+    this.context = context
+    this.addresses = addresses
+  }
+
+  async import (encryptedKey: string, accountId: number) {
+    this.encryptedKey = encryptedKey
+    this.accountId = accountId
+  }
+
+  async createSend (recipient: string, amount: string, fee: string) {
+    const { transactions } = await createTransactions({
+      entries: this.context,
+      outputs: [{ 
+        address: recipient,
+        amount: kaspaToSompi(amount)!
+      }],
+      changeAddress: this.addresses.changeAddresses[this.addresses.changeAddresses.length - 1],
+      priorityFee: kaspaToSompi(fee)!,
+    })
+
+    await this.addresses.increment(0, 1)
+
+    for (const transaction of transactions) {
+      this.transactions.set(transaction.id, transaction)
+    }
+
+    return transactions.map((transaction) => transaction.serializeToSafeJSON())
+  }
+
+  async sign (transactions: string[], password: string) {
+    if (!this.encryptedKey) throw Error('No imported account')
+
+    const keyGenerator = new PrivateKeyGenerator(decryptXChaCha20Poly1305(this.encryptedKey, password), false, BigInt(this.accountId!))
+    const signedTransactions: Transaction[] = []
+
+    for (const transaction of transactions) {
+      const parsedTransaction = Transaction.deserializeFromSafeJSON(transaction)
+      const privateKeys = []
+
+      for (const address of parsedTransaction.addresses(this.addresses.networkId)) {
+        const receiveIndex = this.addresses.receiveAddresses.indexOf(address.toString())
+        const changeIndex = this.addresses.changeAddresses.indexOf(address.toString())
+
+        if (receiveIndex !== -1) {
+          privateKeys.push(keyGenerator.receiveKey(receiveIndex))
+        } else if (changeIndex !== -1) {
+          privateKeys.push(keyGenerator.changeKey(changeIndex))
+        } else throw Error('UTXO is not owned by active wallet')
+      }
+
+      signedTransactions.push(signTransaction(parsedTransaction, privateKeys, false))
+    }
+    
+    const parsedTransactions = signedTransactions.map(transaction => transaction.serializeToSafeJSON())
+    this.emit('transactions', parsedTransactions)
+
+    return parsedTransactions
+  }
+
+  async submitContextful (transactions: string[]) {
+    const submittedIds: string[] = []
+
+    for (const transaction of transactions) {
+      const parsedTransaction = Transaction.deserializeFromSafeJSON(transaction)
+      const cachedTransaction = this.transactions.get(parsedTransaction.id)
+
+      if (!cachedTransaction) throw Error('Transaction is not generated by wallet')
+
+      for (let i = 0; i < parsedTransaction.inputs.length; i++) {
+        const input = parsedTransaction.inputs[i]
+        cachedTransaction.fillInput(i, input.signatureScript)
+      }
+
+      submittedIds.push(await cachedTransaction.submit(this.kaspa))
+    }
+
+    return submittedIds
+  }
+
+  reset () {
+    delete this.encryptedKey
+    delete this.accountId
+  }
+}
\ No newline at end of file
diff --git a/src/wallet/messaging/protocol.ts b/src/wallet/messaging/protocol.ts
index 15ab1f9..cb44034 100644
--- a/src/wallet/messaging/protocol.ts
+++ b/src/wallet/messaging/protocol.ts
@@ -17,6 +17,7 @@ export interface RequestMappings {
   'account:utxos': []
   'account:createSend': [ string, string, string ]
   'account:sign': [ string[], string ]
+  'account:submitContextful': [ string[] ]
   'account:scan': []
   'provider:connect': [ string ]
   'provider:connectedURL': []
@@ -45,6 +46,7 @@ export interface ResponseMappings {
   'account:utxos': UTXO[]
   'account:createSend': string[]
   'account:sign': string[]
+  'account:submitContextful': string[]
   'account:scan': boolean
   "provider:connect": boolean
   'provider:connectedURL': string
diff --git a/src/wallet/messaging/wallet/notifier.ts b/src/wallet/messaging/wallet/notifier.ts
index 80fc53e..c5f2c7d 100644
--- a/src/wallet/messaging/wallet/notifier.ts
+++ b/src/wallet/messaging/wallet/notifier.ts
@@ -15,7 +15,7 @@ export default class Notifications {
   }) {
     wallet.on('status', (status) => this.handleEvent('wallet:status', status))
     account.on('balance', (balance) => this.handleEvent('account:balance', balance))
-    account.on('addresses', (addresses) => this.handleEvent('account:addresses', addresses))
+    account.addresses.on('addresses', (addresses) => this.handleEvent('account:addresses', addresses))
     node.on('connection', (status) => this.handleEvent('node:connection', status))
     node.on('network', (networkId) => this.handleEvent('node:network', networkId))
     provider.on('connection', (url) => this.handleEvent('provider:connection', url))
diff --git a/src/wallet/messaging/wallet/provider/index.ts b/src/wallet/messaging/wallet/provider/index.ts
index 6fe10f4..8dd030a 100644
--- a/src/wallet/messaging/wallet/provider/index.ts
+++ b/src/wallet/messaging/wallet/provider/index.ts
@@ -92,7 +92,7 @@ export default class Provider extends EventEmitter {
         }
       })
 
-      this.account.once('transactions', (parsedTransactions) => transactions = parsedTransactions)
+      this.account.transactions.once('transactions', (parsedTransactions) => transactions = parsedTransactions)
     }
   }
 }
\ No newline at end of file
diff --git a/src/wallet/messaging/wallet/router.ts b/src/wallet/messaging/wallet/router.ts
index 8c8c907..de1935d 100644
--- a/src/wallet/messaging/wallet/router.ts
+++ b/src/wallet/messaging/wallet/router.ts
@@ -31,8 +31,9 @@ export default class Router {
       'account:addresses': () => [ account.addresses.receiveAddresses, account.addresses.changeAddresses ],
       'account:balance': () => account.balance,
       'account:utxos': () => account.UTXOs,
-      'account:createSend': (recipient, amount, fee) => account.createSend(recipient, amount, fee),
-      'account:sign': (transactions, password) => account.sign(transactions, password),
+      'account:createSend': (recipient, amount, fee) => account.transactions.createSend(recipient, amount, fee),
+      'account:sign': (transactions, password) => account.transactions.sign(transactions, password),
+      'account:submitContextful': (transactions) => account.transactions.submitContextful(transactions),
       'account:scan': () => account.scan(),
       'provider:connect': (url) => provider.connect(url),
       'provider:connectedURL': () => provider.connectedURL,