remove redundant APIs

iot-block · May 22, 2019 · d3df5b7 · d3df5b7
1 parent c3bfbc7
commit d3df5b7
Show file tree

Hide file tree

Showing 34 changed files with 172 additions and 684 deletions.
diff --git a/LICENSE b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 JBOK
+Copyright (c) 2018 - 2019 The JBOK Authors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

diff --git a/app/jvm/src/main/resources/db/migration/V1__Add_All_Tables.sql b/app/jvm/src/main/resources/db/migration/V1__Add_All_Tables.sql
@@ -17,23 +17,6 @@ CREATE TABLE transactions
   location    int unsigned not null
 );
 
-CREATE TABLE blocks
-(
-  blockHash        varchar(255) primary key,
-  parentHash       varchar(255)  not null,
-  beneficiary      varchar(255)  not null,
-  stateRoot        varchar(255)  not null,
-  transactionsRoot varchar(255)  not null,
-  receiptsRoot     varchar(255)  not null,
-  logsBloom        varchar(1024) not null,
-  difficulty       varchar(255)  not null,
-  blockNumber      int unsigned  not null,
-  gasLimit         varchar(255)  not null,
-  gasUsed          varchar(255)  not null,
-  unixTimestamp    varchar(255)  not null,
-  extra            varchar(255)  not null
-);
-
 CREATE INDEX `from_address_index` ON transactions (fromAddress);
 CREATE INDEX `to_address_index` ON transactions (toAddress);
 
diff --git a/app/jvm/src/main/scala/jbok/app/AppModule.scala b/app/jvm/src/main/scala/jbok/app/AppModule.scala
@@ -7,8 +7,8 @@ import cats.effect.concurrent.Ref
 import distage._
 import doobie.util.transactor.Transactor
 import jbok.app.service._
-import jbok.app.service.store.doobie.{Doobie, DoobieBlockStore, DoobieTransactionStore}
-import jbok.app.service.store.{BlockStore, Migration, TransactionStore}
+import jbok.app.service.store.doobie.{Doobie, DoobieTransactionStore}
+import jbok.app.service.store.{Migration, TransactionStore}
 import jbok.common.config.Config
 import jbok.core.CoreModule
 import jbok.core.api._
@@ -19,9 +19,8 @@ import jbok.core.models.Address
 class AppModule[F[_]: TagK](implicit F: ConcurrentEffect[F], cs: ContextShift[F], T: Timer[F]) extends ModuleDef {
   addImplicit[Bracket[F, Throwable]]
 
-  make[Transactor[F]].fromResource((config: CoreConfig) => Doobie.fromConfig[F](config.db))
+  make[Transactor[F]].fromResource((config: CoreConfig) => Doobie.xa[F](config.db))
   make[Unit].fromEffect((config: CoreConfig) => Migration.migrate[F](config.db))
-  make[BlockStore[F]].from[DoobieBlockStore[F]]
   make[TransactionStore[F]].from[DoobieTransactionStore[F]]
   make[Ref[F, Map[Address, Wallet]]].fromEffect(Ref.of[F, Map[Address, Wallet]](Map.empty))
 

diff --git a/app/jvm/src/main/scala/jbok/app/service/AccountService.scala b/app/jvm/src/main/scala/jbok/app/service/AccountService.scala
@@ -2,15 +2,16 @@ package jbok.app.service
 
 import cats.effect.Sync
 import cats.implicits._
-import jbok.core.config.HistoryConfig
+import jbok.app.service.store.TransactionStore
 import jbok.core.config.HistoryConfig
 import jbok.core.ledger.History
 import jbok.core.models.{Account, Address, SignedTransaction}
 import jbok.core.pool.TxPool
-import jbok.core.api.{AccountAPI, BlockTag}
+import jbok.core.api.{AccountAPI, BlockTag, HistoryTransaction}
 import scodec.bits.ByteVector
 
-final class AccountService[F[_]](config: HistoryConfig, history: History[F], txPool: TxPool[F], helper: ServiceHelper[F])(implicit F: Sync[F]) extends AccountAPI[F] {
+final class AccountService[F[_]](config: HistoryConfig, history: History[F], txPool: TxPool[F], helper: ServiceHelper[F], txStore: TransactionStore[F])(implicit F: Sync[F])
+    extends AccountAPI[F] {
 
   override def getCode(address: Address, tag: BlockTag): F[ByteVector] =
     for {
@@ -35,9 +36,8 @@ final class AccountService[F[_]](config: HistoryConfig, history: History[F], txP
       storage <- history.getStorage(account.storageRoot, position)
     } yield storage
 
-  override def getTransactions(address: Address): F[List[SignedTransaction]] = ???
-
-  override def getTokenTransactions(address: Address, contract: Option[Address]): F[List[SignedTransaction]] = ???
+  override def getTransactions(address: Address): F[List[HistoryTransaction]] =
+    txStore.findTransactionsByAddress(address.toString, 1, 1000)
 
   override def getPendingTxs(address: Address): F[List[SignedTransaction]] =
     txPool.getPendingTransactions.map(_.keys.toList.filter(_.senderAddress.exists(_ == address)))

diff --git a/app/jvm/src/main/scala/jbok/app/service/ContractService.scala b/app/jvm/src/main/scala/jbok/app/service/ContractService.scala
@@ -4,14 +4,13 @@ import cats.effect.Sync
 import cats.implicits._
 import jbok.core.ledger.{BlockExecutor, History}
 import jbok.core.models.{Address, Block, SignedTransaction, Transaction}
-import jbok.evm.solidity.Ast
 import jbok.core.api.{BlockTag, CallTx, ContractAPI}
 import scodec.bits.ByteVector
 
 final class ContractService[F[_]](history: History[F], executor: BlockExecutor[F], helper: ServiceHelper[F])(implicit F: Sync[F]) extends ContractAPI[F] {
-  override def getABI(address: Address): F[Option[Ast.ContractDef]] = ???
-
-  override def getSourceCode(address: Address): F[Option[String]] = ???
+//  override def getABI(address: Address): F[Option[Ast.ContractDef]] = ???
+//
+//  override def getSourceCode(address: Address): F[Option[String]] = ???
 
   override def call(callTx: CallTx, tag: BlockTag): F[ByteVector] =
     for {

diff --git a/app/jvm/src/main/scala/jbok/app/service/PersonalService.scala b/app/jvm/src/main/scala/jbok/app/service/PersonalService.scala
@@ -1,29 +1,23 @@
 package jbok.app.service
 
 import cats.effect.Sync
-import cats.effect.concurrent.Ref
 import cats.implicits._
+import jbok.core.api.PersonalAPI
 import jbok.core.config.HistoryConfig
-import jbok.core.keystore.{KeyStore, Wallet}
+import jbok.core.keystore.KeyStore
 import jbok.core.ledger.History
-import jbok.core.models.Address
+import jbok.core.models.{Address, Transaction}
 import jbok.core.pool.TxPool
-import jbok.crypto._
-import jbok.crypto.signature._
-import jbok.core.api.{PersonalAPI, TransactionRequest}
 import scodec.bits.ByteVector
 
-import scala.concurrent.duration.Duration
 import scala.util.Try
 
 final class PersonalService[F[_]](
     historyConfig: HistoryConfig,
     keyStore: KeyStore[F],
     history: History[F],
-    txPool: TxPool[F],
-    unlockedWallets: Ref[F, Map[Address, Wallet]]
-)(implicit F: Sync[F])
-    extends PersonalAPI[F] {
+    txPool: TxPool[F]
+)(implicit F: Sync[F]) extends PersonalAPI[F] {
 
   override def importRawKey(privateKey: ByteVector, passphrase: String): F[Address] =
     keyStore.importPrivateKey(privateKey, passphrase)
@@ -37,99 +31,44 @@ final class PersonalService[F[_]](
   override def listAccounts: F[List[Address]] =
     keyStore.listAccounts
 
-  override def unlockAccount(address: Address, passphrase: String, duration: Option[Duration]): F[Boolean] =
-    for {
-      wallet <- keyStore.unlockAccount(address, passphrase)
-      _      <- unlockedWallets.update(_ + (address -> wallet))
-    } yield true
-
-  override def lockAccount(address: Address): F[Boolean] =
-    unlockedWallets.update(_ - address).map(_ => true)
-
-  override def sign(message: ByteVector, address: Address, passphrase: Option[String]): F[CryptoSignature] =
-    for {
-      wallet <- passphrase.fold(unlockedWallets.get.map(_(address)))(p => keyStore.unlockAccount(address, p))
-      sig    <- Signature[ECDSA].sign[F](getMessageToSign(message).toArray, wallet.keyPair, history.chainId)
-    } yield sig
-
-  override def ecRecover(message: ByteVector, signature: CryptoSignature): F[Address] = F.fromOption(
-    Signature[ECDSA]
-      .recoverPublic(getMessageToSign(message).toArray, signature, history.chainId)
-      .map(public => Address(public.bytes.kec256)),
-    new Exception(s"unable to recover signing address")
-  )
-
-  override def sendTransaction(tx: TransactionRequest, passphrase: Option[String]): F[ByteVector] =
-    passphrase match {
-      case Some(p) =>
-        for {
-          wallet <- keyStore.unlockAccount(tx.from, p)
-          hash   <- sendTransaction(tx, wallet)
-        } yield hash
-
-      case None =>
-        unlockedWallets.get.map(_.get(tx.from)).flatMap {
-          case Some(wallet) =>
-            sendTransaction(tx, wallet)
-          case None =>
-            F.raiseError(new Exception("invalidRequest"))
-        }
-    }
-
-  override def deleteWallet(address: Address): F[Boolean] =
-    for {
-      _ <- unlockedWallets.update(_ - address)
-      r <- keyStore.deleteAccount(address)
-    } yield r
+  override def sendTransaction(
+      from: Address,
+      passphrase: String,
+      to: Option[Address],
+      value: Option[BigInt],
+      gasLimit: Option[BigInt],
+      gasPrice: Option[BigInt],
+      nonce: Option[BigInt],
+      data: Option[ByteVector],
+  ): F[ByteVector] = {
 
-  override def changePassphrase(address: Address, oldPassphrase: String, newPassphrase: String): F[Boolean] =
-    keyStore.changePassphrase(address, oldPassphrase, newPassphrase)
-
-//  override def getAccountTransactions(address: Address, fromBlock: BlockParam, toBlock: BlockParam): F[List[SignedTransaction]] = {
-//    def collectTxs: PartialFunction[SignedTransaction, SignedTransaction] = {
-//      case stx if stx.senderAddress.contains(address) => stx
-//      case stx if stx.receivingAddress == address     => stx
-//    }
-//
-//    def resolveNumber(param: BlockParam): F[BigInt] = param match {
-//      case BlockParam.Earliest      => BigInt(0).pure[F]
-//      case BlockParam.Latest        => history.getBestBlockNumber
-//      case BlockParam.WithNumber(n) => n.pure[F]
-//    }
-//
-//    for {
-//      sn     <- resolveNumber(fromBlock)
-//      en     <- resolveNumber(toBlock)
-//      blocks <- (sn to en).toList.filter(_ >= BigInt(0)).traverse(history.getBlockByNumber)
-//      stxsFromBlock = blocks.collect {
-//        case Some(block) => block.body.transactionList.collect(collectTxs)
-//      }.flatten
-//      pendingStxs <- txPool.getPendingTransactions
-//      stxsFromPool = pendingStxs.keys.toList.collect(collectTxs)
-//    } yield stxsFromBlock ++ stxsFromPool
-//  }
-
-  private[jbok] def getMessageToSign(message: ByteVector) = {
-    val prefixed: Array[Byte] =
-      0x19.toByte +: s"Ethereum Signed Message:\n${message.length}".getBytes ++: message.toArray
-    ByteVector(prefixed.kec256)
-  }
+    val defaultGasPrice: BigInt = 2 * BigInt(10).pow(10)
+    val defaultGasLimit: BigInt = 90000
 
-  private[jbok] def sendTransaction(request: TransactionRequest, wallet: Wallet): F[ByteVector] = {
     implicit val chainId: BigInt = history.chainId
+
     for {
+      wallet  <- keyStore.unlockAccount(from, passphrase)
       pending <- txPool.getPendingTransactions
       latestNonceOpt = Try(pending.collect {
         case (stx, _) if stx.senderAddress.contains(wallet.address) => stx.nonce
       }.max).toOption
       bn              <- history.getBestBlockNumber
-      currentNonceOpt <- history.getAccount(request.from, bn).map(_.map(_.nonce.toBigInt))
+      currentNonceOpt <- history.getAccount(from, bn).map(_.map(_.nonce.toBigInt))
       maybeNextTxNonce = latestNonceOpt.map(_ + 1).orElse(currentNonceOpt)
-      tx               = request.toTransaction(maybeNextTxNonce.getOrElse(historyConfig.accountStartNonce))
-
+      tx = Transaction(
+        nonce = nonce.getOrElse(maybeNextTxNonce.getOrElse(historyConfig.accountStartNonce)),
+        gasPrice = gasPrice.getOrElse(defaultGasPrice),
+        gasLimit = gasLimit.getOrElse(defaultGasLimit),
+        receivingAddress = to,
+        value = value.getOrElse(BigInt(0)),
+        payload = data.getOrElse(ByteVector.empty)
+      )
       stx <- wallet.signTx[F](tx)
       _   <- txPool.addOrUpdateTransaction(stx)
     } yield stx.hash
   }
 
+  override def changePassphrase(address: Address, oldPassphrase: String, newPassphrase: String): F[Boolean] =
+    keyStore.changePassphrase(address, oldPassphrase, newPassphrase)
 }
diff --git a/app/jvm/src/main/scala/jbok/app/service/models/package.scala b/app/jvm/src/main/scala/jbok/app/service/models/package.scala
diff --git a/app/jvm/src/main/scala/jbok/app/service/store/BlockStore.scala b/app/jvm/src/main/scala/jbok/app/service/store/BlockStore.scala
diff --git a/app/jvm/src/main/scala/jbok/app/service/store/TransactionStore.scala b/app/jvm/src/main/scala/jbok/app/service/store/TransactionStore.scala
@@ -1,14 +1,12 @@
 package jbok.app.service.store
 
-import jbok.app.service.models.Transaction
-import jbok.core.models.{Receipt, Block => CoreBlock}
+import jbok.core.api.HistoryTransaction
+import jbok.core.models.{Block, Receipt}
 
 trait TransactionStore[F[_]] {
-  def findAllTxs(page: Int, size: Int): F[List[Transaction]]
+  def findTransactionsByAddress(address: String, page: Int, size: Int): F[List[HistoryTransaction]]
 
-  def findTransactionsByAddress(address: String, page: Int, size: Int): F[List[Transaction]]
+  def findTransactionByHash(txHash: String): F[Option[HistoryTransaction]]
 
-  def findTransactionByHash(txHash: String): F[Option[Transaction]]
-
-  def insertBlockTransactions(block: CoreBlock, receipts: List[Receipt]): F[Unit]
+  def insertBlockTransactions(block: Block, receipts: List[Receipt]): F[Unit]
 }