Bug/dot-transfer-broadcast

core/api/service/author/impl/author_api_impl.cpp

@@ -178,14 +178,18 @@ namespace kagome::api {
   outcome::result<AuthorApi::SubscriptionId>
   AuthorApiImpl::submitAndWatchExtrinsic(Extrinsic extrinsic) {
     if (auto service = api_service_.lock()) {
+      OUTCOME_TRY(
+          tx,
+          pool_->constructTransaction(TransactionSource::External, extrinsic));
+      OUTCOME_TRY(sub_id, service->subscribeForExtrinsicLifecycle(tx.hash));
       OUTCOME_TRY(tx_hash,
                   submitExtrinsic(
                       // submit and watch could be executed only
                       // from RPC call, so External source is chosen
                       TransactionSource::External,
                       extrinsic));
+      BOOST_ASSERT(tx_hash == tx.hash);
 
-      OUTCOME_TRY(sub_id, service->subscribeForExtrinsicLifecycle(tx_hash));
       SL_DEBUG(logger_, "Subscribe for ex hash={}", tx_hash);
 
       return sub_id;

core/transaction_pool/impl/transaction_pool_impl.hpp

@@ -69,11 +69,11 @@ namespace kagome::transaction_pool {
 
     Status getStatus() const override;
 
-   private:
     outcome::result<primitives::Transaction> constructTransaction(
         primitives::TransactionSource source,
-        primitives::Extrinsic extrinsic) const;
+        primitives::Extrinsic extrinsic) const override;
 
+   private:
     outcome::result<void> submitOne(const std::shared_ptr<Transaction> &tx);
 
     outcome::result<void> processTransaction(

core/transaction_pool/transaction_pool.hpp

@@ -79,6 +79,10 @@ namespace kagome::transaction_pool {
         const primitives::BlockId &at) = 0;
 
     virtual Status getStatus() const = 0;
+
+    virtual outcome::result<primitives::Transaction> constructTransaction(
+        primitives::TransactionSource source,
+        primitives::Extrinsic extrinsic) const = 0;
   };
 
   struct TransactionPool::Status {

test/core/api/service/author/author_api_test.cpp

@@ -442,6 +442,9 @@ TEST_F(AuthorApiTest, HasKeyFail) {
 TEST_F(AuthorApiTest, SubmitAndWatchExtrinsicSubmitsAndWatches) {
   Transaction::Hash tx_hash{};
 
+  EXPECT_CALL(*transaction_pool,
+              constructTransaction(TransactionSource::External, *extrinsic))
+      .WillOnce(Return(outcome::success()));
   EXPECT_CALL(*transaction_pool,
               submitExtrinsic(TransactionSource::External, *extrinsic))
       .WillOnce(testing::DoAll(

test/mock/core/transaction_pool/transaction_pool_mock.hpp

@@ -50,6 +50,11 @@ namespace kagome::transaction_pool {
                 (override));
 
     MOCK_METHOD(Status, getStatus, (), (const, override));
+
+    MOCK_METHOD(outcome::result<primitives::Transaction>,
+                constructTransaction,
+                (primitives::TransactionSource, primitives::Extrinsic),
+                (const, override));
   };
 
 }  // namespace kagome::transaction_pool