diff --git a/api/src/main/java/org/apache/fineract/cn/stellarbridge/api/v1/events/EventConstants.java b/api/src/main/java/org/apache/fineract/cn/stellarbridge/api/v1/events/EventConstants.java
index f3619ba..c644272 100644
--- a/api/src/main/java/org/apache/fineract/cn/stellarbridge/api/v1/events/EventConstants.java
+++ b/api/src/main/java/org/apache/fineract/cn/stellarbridge/api/v1/events/EventConstants.java
@@ -25,6 +25,10 @@
   String SELECTOR_NAME = "action";
   String INITIALIZE = "initialize";
   String PUT_CONFIG = "put-config";
+  String STELLAR_PAYMENT_PROCESSED = "bridge-stellar-payment";
+  String FINERACT_PAYMENT_PROCESSED = "bridge-fineract-payment";
   String SELECTOR_INITIALIZE = SELECTOR_NAME + " = '" + INITIALIZE + "'";
-  String SELECTOR_POST_SAMPLE = SELECTOR_NAME + " = '" + PUT_CONFIG + "'";
+  String SELECTOR_PUT_CONFIG = SELECTOR_NAME + " = '" + PUT_CONFIG + "'";
+  String SELECTOR_STELLAR_PAYMENT_PROCESSED = SELECTOR_NAME + " = '" + STELLAR_PAYMENT_PROCESSED + "'";
+  String SELECTOR_FINERACT_PAYMENT_PROCESSED = SELECTOR_NAME + " = '" + FINERACT_PAYMENT_PROCESSED + "'";
 }
diff --git a/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/SuiteTestEnvironment.java b/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/SuiteTestEnvironment.java
index 13e360b..9ce6265 100644
--- a/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/SuiteTestEnvironment.java
+++ b/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/SuiteTestEnvironment.java
@@ -34,7 +34,7 @@
  */
 public class SuiteTestEnvironment {
   static final String APP_VERSION = "1";
-  static final String APP_NAME = "stellarbridge-v1" + APP_VERSION;
+  static final String APP_NAME = "stellarbridge-v" + APP_VERSION;
 
   static final TestEnvironment testEnvironment = new TestEnvironment(APP_NAME);
   static final CassandraInitializer cassandraInitializer = new CassandraInitializer();
diff --git a/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/TestBridgeConfiguration.java b/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/TestBridgeConfiguration.java
index 07b3c67..1a91fde 100644
--- a/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/TestBridgeConfiguration.java
+++ b/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/TestBridgeConfiguration.java
@@ -23,7 +23,7 @@
 import org.apache.fineract.cn.stellarbridge.api.v1.client.StellarBridgeManager;
 import org.apache.fineract.cn.stellarbridge.api.v1.domain.BridgeConfiguration;
 import org.apache.fineract.cn.stellarbridge.api.v1.events.EventConstants;
-import org.apache.fineract.cn.stellarbridge.service.StellarBridgeConfiguration;
+import org.apache.fineract.cn.stellarbridge.service.internal.config.StellarBridgeConfiguration;
 import org.apache.fineract.cn.test.fixture.TenantDataStoreContextTestRule;
 import org.apache.fineract.cn.test.listener.EnableEventRecording;
 import org.apache.fineract.cn.test.listener.EventRecorder;
@@ -48,7 +48,8 @@
 import org.springframework.test.context.junit4.SpringRunner;
 
 @RunWith(SpringRunner.class)
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT,
+    properties = {"stellarBridge.user=homer", "stellarBridge.horizonAddress=https://horizon-testnet.stellar.org"})
 public class TestBridgeConfiguration extends SuiteTestEnvironment {
   private static final String LOGGER_NAME = "test-logger";
   private static final String TEST_USER = "homer";
diff --git a/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/listener/BridgeConfigurationEventListener.java b/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/listener/BridgeConfigurationEventListener.java
index 9500f2c..5e695c4 100644
--- a/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/listener/BridgeConfigurationEventListener.java
+++ b/component-test/src/main/java/org/apache/fineract/cn/stellarbridge/listener/BridgeConfigurationEventListener.java
@@ -41,7 +41,7 @@
   @JmsListener(
       subscription = EventConstants.DESTINATION,
       destination = EventConstants.DESTINATION,
-      selector = EventConstants.SELECTOR_POST_SAMPLE
+      selector = EventConstants.SELECTOR_PUT_CONFIG
   )
   public void onChangeConfiguration(@Header(TenantHeaderFilter.TENANT_HEADER) final String tenant,
                              final String payload) {
diff --git a/service/build.gradle b/service/build.gradle
index 2b0a369..34ec58f 100644
--- a/service/build.gradle
+++ b/service/build.gradle
@@ -48,7 +48,7 @@
             [group: 'org.springframework.cloud', name: 'spring-cloud-starter-config'],
             [group: 'org.springframework.cloud', name: 'spring-cloud-starter-eureka'],
             [group: 'org.springframework.boot', name: 'spring-boot-starter-jetty'],
-            [group: 'org.apache.fineract.cn.identity', name: 'api', version: versions.identity],
+            [group: 'org.apache.fineract.cn.accounting', name: 'api', version: versions.accounting],
             [group: 'org.apache.fineract.cn.stellarbridge', name: 'api', version: project.version],
             [group: 'org.apache.fineract.cn.anubis', name: 'library', version: versions.frameworkanubis],
             [group: 'com.google.code.gson', name: 'gson'],
@@ -58,7 +58,8 @@
             [group: 'org.apache.fineract.cn', name: 'mariadb', version: versions.frameworkmariadb],
             [group: 'org.apache.fineract.cn', name: 'command', version: versions.frameworkcommand],
             [group: 'org.apache.fineract.cn.permitted-feign-client', name: 'library', version: versions.frameworkpermittedfeignclient],
-            [group: 'org.hibernate', name: 'hibernate-validator', version: versions.validator]
+            [group: 'org.hibernate', name: 'hibernate-validator', version: versions.validator],
+            [group: 'com.github.stellar', name: 'java-stellar-sdk', version: versions.stellar]
     )
 }
 
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/StellarBridgeApplication.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/StellarBridgeApplication.java
index ac5f8dd..32410ef 100644
--- a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/StellarBridgeApplication.java
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/StellarBridgeApplication.java
@@ -18,6 +18,7 @@
  */
 package org.apache.fineract.cn.stellarbridge.service;
 
+import org.apache.fineract.cn.stellarbridge.service.internal.config.StellarBridgeConfiguration;
 import org.springframework.boot.SpringApplication;
 
 public class StellarBridgeApplication {
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/AccountingAdapter.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/AccountingAdapter.java
new file mode 100644
index 0000000..6075143
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/AccountingAdapter.java
@@ -0,0 +1,31 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.accounting;
+
+import java.math.BigDecimal;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationEntity;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AccountingAdapter {
+  private final JournalEntryCreator journalEntryCreator;
+
+  @Autowired
+  public AccountingAdapter(
+      final JournalEntryCreator journalEntryCreator) {
+    this.journalEntryCreator = journalEntryCreator;
+  }
+
+  public String adjustFineractBalances(
+      final BridgeConfigurationEntity bridgeConfigurationEntity,
+      final BigDecimal amount,
+      final String assetCode) {
+    //journalEntryCreator.createJournalEntry(journalEntry);
+    return null;
+  }
+
+  public void tellFineractPaymentSucceeded(String fineractStagingAccountIdentifier,
+      String assetCode, BigDecimal amount)
+  {
+
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/AccountingListener.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/AccountingListener.java
new file mode 100644
index 0000000..b4ff467
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/AccountingListener.java
@@ -0,0 +1,28 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.accounting;
+
+import org.apache.fineract.cn.command.gateway.CommandGateway;
+import org.apache.fineract.cn.lang.config.TenantHeaderFilter;
+import org.apache.fineract.cn.stellarbridge.service.internal.command.FineractPaymentCommand;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.messaging.handler.annotation.Header;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AccountingListener {
+  private final CommandGateway commandGateway;
+
+  @Autowired
+  public AccountingListener(
+      final CommandGateway commandGateway) {
+    this.commandGateway = commandGateway;
+  }
+
+  public void onFineractPayment(
+      @Header(TenantHeaderFilter.TENANT_HEADER) final String tenant,
+      final String payload) {
+    final FineractPaymentCommand fineractPaymentCommand = new FineractPaymentCommand(tenant,
+        payload, null, null, null, null);
+    commandGateway.process(fineractPaymentCommand);
+  }
+
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/JournalEntryCreator.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/JournalEntryCreator.java
new file mode 100644
index 0000000..5375cda
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/accounting/JournalEntryCreator.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.cn.stellarbridge.service.internal.accounting;
+
+import org.apache.fineract.cn.accounting.api.v1.client.JournalEntryAlreadyExistsException;
+import org.apache.fineract.cn.accounting.api.v1.client.JournalEntryValidationException;
+import org.apache.fineract.cn.accounting.api.v1.domain.JournalEntry;
+import org.apache.fineract.cn.anubis.annotation.Permittable;
+import org.apache.fineract.cn.api.annotation.ThrowsException;
+import org.apache.fineract.cn.api.annotation.ThrowsExceptions;
+import org.apache.fineract.cn.permittedfeignclient.annotation.EndpointSet;
+import org.apache.fineract.cn.permittedfeignclient.annotation.PermittedFeignClientsConfiguration;
+import org.springframework.cloud.netflix.feign.FeignClient;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+/**
+ * @author Myrle Krantz
+ */
+@EndpointSet(identifier = "stellarbridge__v1__accounting__v1")
+@FeignClient(name="accounting-v1", path="/accounting/v1", configuration=PermittedFeignClientsConfiguration.class)
+public interface JournalEntryCreator {
+  @RequestMapping(
+      value = "/journal",
+      method = RequestMethod.POST,
+      produces = {MediaType.APPLICATION_JSON_VALUE},
+      consumes = {MediaType.APPLICATION_JSON_VALUE}
+  )
+  @ThrowsExceptions({
+      @ThrowsException(status = HttpStatus.BAD_REQUEST, exception = JournalEntryValidationException.class),
+      @ThrowsException(status = HttpStatus.CONFLICT, exception = JournalEntryAlreadyExistsException.class)
+  })
+  @Permittable(groupId = org.apache.fineract.cn.accounting.api.v1.PermittableGroupIds.THOTH_JOURNAL)
+  void createJournalEntry(@RequestBody final JournalEntry journalEntry);
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/FineractPaymentCommand.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/FineractPaymentCommand.java
new file mode 100644
index 0000000..d830386
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/FineractPaymentCommand.java
@@ -0,0 +1,52 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.command;
+
+import java.math.BigDecimal;
+
+public class FineractPaymentCommand {
+
+  final private String tenantIdentifer;
+  final private String transactionIdentifier;
+  final private String targetAccount;
+  final private String sinkDomain;
+  final private BigDecimal amount;
+  final private String assetCode;
+
+  public FineractPaymentCommand(
+      String tenantIdentifer,
+      String transactionIdentifier,
+      String targetAccount,
+      String sinkDomain,
+      BigDecimal amount,
+      String assetCode) {
+    this.tenantIdentifer = tenantIdentifer;
+    this.transactionIdentifier = transactionIdentifier;
+    this.targetAccount = targetAccount;
+    this.sinkDomain = sinkDomain;
+    this.amount = amount;
+    this.assetCode = assetCode;
+  }
+
+  public String getTenantIdentifier() {
+    return tenantIdentifer;
+  }
+
+  public String getTransactionIdentifier() {
+    return transactionIdentifier;
+  }
+
+  public String getTargetAccount() {
+    return targetAccount;
+  }
+
+  public String getSinkDomain() {
+    return sinkDomain;
+  }
+
+  public BigDecimal getAmount() {
+    return amount;
+  }
+
+  public String getAssetCode() {
+    return assetCode;
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/StellarPaymentCommand.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/StellarPaymentCommand.java
new file mode 100644
index 0000000..d1cd85a
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/StellarPaymentCommand.java
@@ -0,0 +1,28 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.command;
+
+import java.math.BigDecimal;
+
+public class StellarPaymentCommand {
+
+  private final String tenantIdentifier;
+  private final String assetCode;
+  private final BigDecimal amount;
+
+  public StellarPaymentCommand(String tenantIdentifier, String assetCode, BigDecimal amount) {
+    this.tenantIdentifier = tenantIdentifier;
+    this.assetCode = assetCode;
+    this.amount = amount;
+  }
+
+  public String getTenantIdentifier() {
+    return tenantIdentifier;
+  }
+
+  public String getAssetCode() {
+    return assetCode;
+  }
+
+  public BigDecimal getAmount() {
+    return amount;
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/BridgeConfigurationCommandHandler.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/BridgeConfigurationCommandHandler.java
index 9522086..973eeb4 100644
--- a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/BridgeConfigurationCommandHandler.java
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/BridgeConfigurationCommandHandler.java
@@ -25,7 +25,7 @@
 import org.apache.fineract.cn.stellarbridge.service.internal.command.ChangeConfigurationCommand;
 import org.apache.fineract.cn.stellarbridge.service.internal.mapper.BridgeConfigurationMapper;
 import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationEntity;
-import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationEntityRepository;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -33,16 +33,17 @@
 @Aggregate
 public class BridgeConfigurationCommandHandler {
 
-  private final BridgeConfigurationEntityRepository bridgeConfigurationEntityRepository;
+  private final BridgeConfigurationRepository bridgeConfigurationRepository;
   private final EventHelper eventHelper;
 
   @Autowired
   public BridgeConfigurationCommandHandler(
-      final BridgeConfigurationEntityRepository bridgeConfigurationEntityRepository,
+      final BridgeConfigurationRepository bridgeConfigurationRepository,
       final EventHelper eventHelper) {
-    this.bridgeConfigurationEntityRepository = bridgeConfigurationEntityRepository;
+    this.bridgeConfigurationRepository = bridgeConfigurationRepository;
     this.eventHelper = eventHelper;
   }
+
   @CommandHandler(logStart = CommandLogLevel.INFO, logFinish = CommandLogLevel.INFO)
   @Transactional
   public void handle(final ChangeConfigurationCommand changeConfigurationCommand) {
@@ -50,7 +51,7 @@
     final BridgeConfigurationEntity entity = BridgeConfigurationMapper.map(
         changeConfigurationCommand.tenantIdentifier(),
         changeConfigurationCommand.instance());
-    this.bridgeConfigurationEntityRepository.save(entity);
+    this.bridgeConfigurationRepository.save(entity);
 
     eventHelper.sendEvent(EventConstants.PUT_CONFIG, changeConfigurationCommand.tenantIdentifier(), null);
   }
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/FineractPaymentCommandHandler.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/FineractPaymentCommandHandler.java
new file mode 100644
index 0000000..328a542
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/FineractPaymentCommandHandler.java
@@ -0,0 +1,74 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.command.handler;
+
+import java.util.Optional;
+import org.apache.fineract.cn.command.annotation.Aggregate;
+import org.apache.fineract.cn.command.annotation.CommandHandler;
+import org.apache.fineract.cn.command.annotation.CommandLogLevel;
+import org.apache.fineract.cn.stellarbridge.api.v1.events.EventConstants;
+import org.apache.fineract.cn.stellarbridge.service.internal.accounting.AccountingAdapter;
+import org.apache.fineract.cn.stellarbridge.service.internal.command.FineractPaymentCommand;
+import org.apache.fineract.cn.stellarbridge.service.internal.federation.StellarAccountId;
+import org.apache.fineract.cn.stellarbridge.service.internal.federation.StellarAddress;
+import org.apache.fineract.cn.stellarbridge.service.internal.federation.StellarAddressResolver;
+import org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter.HorizonServerUtilities;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationEntity;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Aggregate
+public class FineractPaymentCommandHandler {
+  private final BridgeConfigurationRepository bridgeConfigurationRepository;
+  private final StellarAddressResolver stellarAddressResolver;
+  private final HorizonServerUtilities horizonServerUtilities;
+  private final AccountingAdapter accountingAdapter;
+  private final EventHelper eventHelper;
+
+  @Autowired
+  public FineractPaymentCommandHandler(
+      final BridgeConfigurationRepository bridgeConfigurationRepository,
+      final StellarAddressResolver stellarAddressResolver,
+      final HorizonServerUtilities horizonServerUtilities,
+      AccountingAdapter accountingAdapter,
+      final EventHelper eventHelper) {
+    this.bridgeConfigurationRepository = bridgeConfigurationRepository;
+    this.stellarAddressResolver = stellarAddressResolver;
+    this.horizonServerUtilities = horizonServerUtilities;
+    this.accountingAdapter = accountingAdapter;
+    this.eventHelper = eventHelper;
+  }
+
+  @CommandHandler(logStart = CommandLogLevel.INFO, logFinish = CommandLogLevel.INFO)
+  @Transactional
+  public void handle(final FineractPaymentCommand command) {
+
+    final Optional<BridgeConfigurationEntity> accountBridge =
+        bridgeConfigurationRepository.findByTenantIdentifier(command.getTenantIdentifier());
+
+    accountBridge.ifPresent(x -> pay(command, x));
+  }
+
+  private void pay(
+      final FineractPaymentCommand command,
+      final BridgeConfigurationEntity bridgeConfigurationEntity)
+  {
+    final StellarAccountId targetAccountId;
+    targetAccountId =  stellarAddressResolver.getAccountIdOfStellarAccount(
+        StellarAddress.forTenant(command.getTargetAccount(), command.getSinkDomain()));
+
+    final char[] decodedStellarPrivateKey =
+        bridgeConfigurationEntity.getStellarAccountPrivateKey();
+
+    horizonServerUtilities.findPathPay(
+        targetAccountId,
+        command.getAmount(), command.getAssetCode(),
+        decodedStellarPrivateKey);
+
+    accountingAdapter.tellFineractPaymentSucceeded(
+        bridgeConfigurationEntity.getFineractStagingAccountIdentifier(),
+        command.getAssetCode(),
+        command.getAmount());
+
+    eventHelper.sendEvent(EventConstants.FINERACT_PAYMENT_PROCESSED, command.getTenantIdentifier(), command.getTransactionIdentifier());
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/StellarPaymentCommandHandler.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/StellarPaymentCommandHandler.java
new file mode 100644
index 0000000..00ea780
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/command/handler/StellarPaymentCommandHandler.java
@@ -0,0 +1,46 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.command.handler;
+
+import java.util.Optional;
+import org.apache.fineract.cn.command.annotation.Aggregate;
+import org.apache.fineract.cn.command.annotation.CommandHandler;
+import org.apache.fineract.cn.command.annotation.CommandLogLevel;
+import org.apache.fineract.cn.stellarbridge.api.v1.events.EventConstants;
+import org.apache.fineract.cn.stellarbridge.service.internal.accounting.AccountingAdapter;
+import org.apache.fineract.cn.stellarbridge.service.internal.command.StellarPaymentCommand;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationEntity;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Aggregate
+public class StellarPaymentCommandHandler {
+  private final BridgeConfigurationRepository bridgeConfigurationRepository;
+  private final AccountingAdapter accountingAdapter;
+  private final EventHelper eventHelper;
+
+  @Autowired
+  public StellarPaymentCommandHandler(
+      final BridgeConfigurationRepository bridgeConfigurationRepository,
+      final AccountingAdapter accountingAdapter,
+      final EventHelper eventHelper) {
+    this.bridgeConfigurationRepository = bridgeConfigurationRepository;
+    this.accountingAdapter = accountingAdapter;
+    this.eventHelper = eventHelper;
+  }
+
+
+  @CommandHandler(logStart = CommandLogLevel.INFO, logFinish = CommandLogLevel.INFO)
+  @Transactional
+  public void handle(final StellarPaymentCommand command) {
+
+    final Optional<BridgeConfigurationEntity> accountBridge =
+        bridgeConfigurationRepository.findByTenantIdentifier(command.getTenantIdentifier());
+
+    final Optional<String> transactionIdentifier = accountBridge.map(x -> accountingAdapter.adjustFineractBalances(
+        x, command.getAmount(), command.getAssetCode()));
+
+    transactionIdentifier.ifPresent(x ->
+        eventHelper.sendEvent(EventConstants.STELLAR_PAYMENT_PROCESSED, command.getTenantIdentifier(), x));
+  }
+
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/StellarBridgeConfiguration.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/config/StellarBridgeConfiguration.java
similarity index 82%
rename from service/src/main/java/org/apache/fineract/cn/stellarbridge/service/StellarBridgeConfiguration.java
rename to service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/config/StellarBridgeConfiguration.java
index 74398be..fec205f 100644
--- a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/StellarBridgeConfiguration.java
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/config/StellarBridgeConfiguration.java
@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.apache.fineract.cn.stellarbridge.service;
+package org.apache.fineract.cn.stellarbridge.service.internal.config;
 
 import org.apache.fineract.cn.anubis.config.EnableAnubis;
 import org.apache.fineract.cn.api.config.EnableApiFactory;
@@ -28,7 +28,8 @@
 import org.apache.fineract.cn.lang.config.EnableTenantContext;
 import org.apache.fineract.cn.mariadb.config.EnableMariaDB;
 import org.apache.fineract.cn.permittedfeignclient.config.EnablePermissionRequestingFeignClient;
-import org.apache.fineract.cn.stellarbridge.service.internal.identity.ApplicationPermissionRequestCreator;
+import org.apache.fineract.cn.stellarbridge.service.ServiceConstants;
+import org.apache.fineract.cn.stellarbridge.service.internal.accounting.JournalEntryCreator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -50,18 +51,22 @@
 @EnableAsync
 @EnableTenantContext
 @EnableCassandra
-@EnableMariaDB
+@EnableMariaDB(forTenantContext = false)
 @EnableCommandProcessing
 @EnableAnubis
 @EnableServiceException
-@EnablePermissionRequestingFeignClient(feignClasses = {ApplicationPermissionRequestCreator.class})
+@EnablePermissionRequestingFeignClient(feignClasses = {JournalEntryCreator.class})
 @RibbonClient(name = "rhythm-v1")
 @EnableApplicationName
-@EnableFeignClients(clients = {ApplicationPermissionRequestCreator.class})
+@EnableFeignClients(clients = {JournalEntryCreator.class})
 @ComponentScan({
     "org.apache.fineract.cn.stellarbridge.service.rest",
     "org.apache.fineract.cn.stellarbridge.service.internal.service",
+    "org.apache.fineract.cn.stellarbridge.service.internal.config",
     "org.apache.fineract.cn.stellarbridge.service.internal.repository",
+    "org.apache.fineract.cn.stellarbridge.service.internal.federation",
+    "org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter",
+    "org.apache.fineract.cn.stellarbridge.service.internal.accounting",
     "org.apache.fineract.cn.stellarbridge.service.internal.command.handler"
 })
 @EnableJpaRepositories({
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/config/StellarBridgeProperties.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/config/StellarBridgeProperties.java
new file mode 100644
index 0000000..5452b0c
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/config/StellarBridgeProperties.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.cn.stellarbridge.service.internal.config;
+
+import org.apache.fineract.cn.lang.validation.constraints.ValidIdentifier;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+import org.springframework.validation.annotation.Validated;
+
+/**
+ * @author Myrle Krantz
+ */
+@Component
+@ConfigurationProperties(prefix="stellarBridge")
+@Validated
+public class StellarBridgeProperties {
+  @ValidIdentifier
+  private String user;
+
+  private String horizonAddress;
+
+
+  public StellarBridgeProperties() {
+  }
+
+  public void setUser(String user) {
+    this.user = user;
+  }
+
+  public String getUser() {
+    return user;
+  }
+
+  public String getHorizonAddress() {
+    return horizonAddress;
+  }
+
+  public void setHorizonAddress(String horizonAddress) {
+    this.horizonAddress = horizonAddress;
+  }
+}
\ No newline at end of file
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/ExternalFederationService.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/ExternalFederationService.java
new file mode 100644
index 0000000..0fd46b7
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/ExternalFederationService.java
@@ -0,0 +1,92 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.federation;
+
+import java.io.IOException;
+import org.springframework.stereotype.Service;
+import org.stellar.sdk.federation.Federation;
+import org.stellar.sdk.federation.FederationResponse;
+import org.stellar.sdk.federation.MalformedAddressException;
+
+@Service
+public class ExternalFederationService {
+
+  class StellarResolver
+  { //To make a static function mockable.
+    FederationResponse resolve(final String address)
+        throws IOException, MalformedAddressException {
+      return Federation.resolve(address);
+    }
+  }
+
+  private StellarResolver stellarResolver;
+
+  ExternalFederationService()
+  {
+    this.stellarResolver = new StellarResolver();
+  }
+
+  ExternalFederationService(final StellarResolver stellarResolver)
+  {
+    this.stellarResolver = stellarResolver;
+  }
+
+  /**
+   * Based on the stellar address, finds the stellar account id.  Resolves the domain, and calls
+   * the federation service to do so.  This only returns an account id if the memo type is id or
+   * there is no memo type.
+   *
+   * @param stellarAddress The stellar address for which to return a stellar account id.
+   * @return The corresponding stellar account id.
+   *
+   * @throws FederationFailedException for the following cases:
+   * * domain server not reachable,
+   * * stellar.toml not parseable for federation server,
+   * * federation server not reachable,
+   * * federation server response does not match expected format.
+   * * memo type is not id.
+   */
+  public StellarAccountId getAccountId(final StellarAddress stellarAddress)
+      throws FederationFailedException
+  {
+    final org.stellar.sdk.federation.FederationResponse federationResponse;
+    try {
+      federationResponse = stellarResolver.resolve(stellarAddress.toString());
+    }
+    catch (final MalformedAddressException e)
+    {
+      throw FederationFailedException.malformedAddress(stellarAddress.toString());
+    }
+    catch (final IOException e)
+    {
+      throw FederationFailedException
+          .domainDoesNotReferToValidFederationServer(stellarAddress.getDomain().toString());
+    }
+
+    if (federationResponse == null)
+    {
+      throw FederationFailedException.addressNameNotFound(stellarAddress.toString());
+    }
+    if (federationResponse.getAccountId() == null)
+    {
+      throw FederationFailedException.addressNameNotFound(stellarAddress.toString());
+    }
+
+    return convertFederationResponseToStellarAddress(federationResponse);
+  }
+
+  private StellarAccountId convertFederationResponseToStellarAddress(
+      final org.stellar.sdk.federation.FederationResponse response)
+  {
+    if (response.getMemoType().equalsIgnoreCase("text"))
+    {
+      return StellarAccountId.subAccount(response.getAccountId(), response.getMemo());
+    }
+    else if (response.getMemoType() == null || response.getMemoType().isEmpty())
+    {
+      return StellarAccountId.mainAccount(response.getAccountId());
+    }
+    else
+    {
+      throw FederationFailedException.addressRequiresUnsupportedMemoType(response.getMemoType());
+    }
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/FederationFailedException.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/FederationFailedException.java
new file mode 100644
index 0000000..09effbd
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/FederationFailedException.java
@@ -0,0 +1,37 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.federation;
+
+public class FederationFailedException extends RuntimeException {
+  private FederationFailedException(final String message) { super(message);
+  }
+
+  static FederationFailedException domainDoesNotReferToValidFederationServer
+      (final String domain)
+  {
+    return new FederationFailedException(
+        "The federation server for the given domain could not be reached: " + domain);
+  }
+
+  static FederationFailedException addressRequiresUnsupportedMemoType(final String memoType)
+  {
+    return new FederationFailedException(
+        "The given federation address returned an unsupported memo type: " + memoType);
+  }
+
+  static FederationFailedException wrongDomain(final String domain) {
+    return new FederationFailedException("Wrong domain: " + domain);
+  }
+
+  static FederationFailedException addressNameNotFound(final String address) {
+    return new FederationFailedException("The address name is not found: " + address);
+  }
+
+  static FederationFailedException malformedAddress(final String address) {
+    return new FederationFailedException("The address is not a valid stellar address: " + address);
+  }
+
+  static FederationFailedException needTopLevelStellarAccount
+      (final String address) {
+    return new FederationFailedException(
+        "Need top level Stellar account: " + address);
+  }
+}
\ No newline at end of file
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/InvalidStellarAddressException.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/InvalidStellarAddressException.java
new file mode 100644
index 0000000..8effca3
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/InvalidStellarAddressException.java
@@ -0,0 +1,17 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.federation;
+
+public class InvalidStellarAddressException extends RuntimeException {
+  private InvalidStellarAddressException(final String message) {
+    super(message);
+  }
+
+  static InvalidStellarAddressException invalidDomainName(final String domainName) {
+    return new InvalidStellarAddressException("Domain name is not valid: " + domainName);
+  }
+
+  static InvalidStellarAddressException nonConformantStellarAddress(final String address) {
+    return new InvalidStellarAddressException(
+        "Non-conformant stellar address: " + address
+    );
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAccountId.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAccountId.java
new file mode 100644
index 0000000..d9eb45a
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAccountId.java
@@ -0,0 +1,48 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.federation;
+
+import java.util.Objects;
+import java.util.Optional;
+
+public class StellarAccountId {
+  private final String publicKey;
+  private final Optional<String> subAccount;
+
+  static public StellarAccountId mainAccount(final String publicKey)
+  {
+    return new StellarAccountId(publicKey, Optional.empty());
+  }
+
+  static public StellarAccountId subAccount(final String mainAccountPublicKey,
+      final String subAccountId)
+  {
+    //TODO: Check what the correct form of the memo should be here...
+    return new StellarAccountId(mainAccountPublicKey, Optional.of(subAccountId));
+  }
+
+  private StellarAccountId(final String publicKey, final Optional<String> subAccount)
+  {
+    this.publicKey = publicKey;
+    this.subAccount = subAccount;
+  }
+
+  public String getPublicKey() {
+    return publicKey;
+  }
+
+  public Optional<String> getSubAccount() {
+    return subAccount;
+  }
+
+  @Override public boolean equals(Object o) {
+    if (this == o)
+      return true;
+    if (o == null || getClass() != o.getClass())
+      return false;
+    StellarAccountId that = (StellarAccountId) o;
+    return Objects.equals(publicKey, that.publicKey) && Objects.equals(subAccount, that.subAccount);
+  }
+
+  @Override public int hashCode() {
+    return Objects.hash(publicKey, subAccount);
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAddress.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAddress.java
new file mode 100644
index 0000000..626f964
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAddress.java
@@ -0,0 +1,119 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.federation;
+
+import com.google.common.net.InternetDomainName;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class StellarAddress {
+
+  private final InternetDomainName domain;
+  private final String tenantName;
+  private final Optional<String> userAccountId;
+  private final boolean isVaultAddress;
+
+  public static StellarAddress forTenant(final String tenantName, final String domain)
+  {
+    return new StellarAddress(InternetDomainName.from(domain), tenantName, Optional.empty());
+  }
+
+  public static StellarAddress parse(final String address)
+      throws InvalidStellarAddressException
+  {
+    //I chose not to use Pattern.UNICODE_CHARACTER_CLASS because of potential performance issues and
+    //no current knowledge of use cases which require unicode addresses.  Certainly the domain
+    //name can't contain unicode characters.  According to the federation servers specs at
+    //Stellar, the part before the * might contain them.  Depending on what use cases we encounter,
+    //we may need to adjust this.
+    final Pattern stellarAddressPattern = Pattern.compile(
+        "(?<name>^[^\\:\\*@\\p{Space}]+)(:(?<subname>[^\\:\\*@\\p{Space}]+))?+\\*(?<domain>[\\p{Alnum}-\\.]+)$");
+
+    final Matcher addressMatcher = stellarAddressPattern.matcher(address);
+    if (!addressMatcher.matches()) {
+      throw InvalidStellarAddressException.nonConformantStellarAddress(address);
+    }
+
+    if (addressMatcher.group("subname") != null)
+    {
+      return new StellarAddress(getInternetDomainName(addressMatcher.group("domain")),
+          addressMatcher.group("name"), Optional.of(addressMatcher.group("subname")));
+    }
+    else
+    {
+      return new StellarAddress(getInternetDomainName(addressMatcher.group("domain")),
+          addressMatcher.group("name"), Optional.empty());
+    }
+  }
+
+  private static InternetDomainName getInternetDomainName(final String domain)
+      throws InvalidStellarAddressException
+  {
+    try {
+      return InternetDomainName.from(domain);
+    }
+    catch (final IllegalArgumentException e)
+    {
+      throw InvalidStellarAddressException.invalidDomainName(domain);
+    }
+  }
+
+  private StellarAddress(
+      final InternetDomainName domain,
+      final String tenantName,
+      final Optional<String> userAccountId)
+  {
+    this.domain = domain;
+    this.tenantName = tenantName;
+    if (userAccountId.orElse("").equals("vault")) {
+      isVaultAddress = true;
+      this.userAccountId = Optional.empty();
+    }
+    else
+    {
+      isVaultAddress = false;
+      this.userAccountId = userAccountId;
+    }
+  }
+
+  @Override public boolean equals(Object o) {
+    if (this == o)
+      return true;
+    if (!(o instanceof StellarAddress))
+      return false;
+    StellarAddress that = (StellarAddress) o;
+    return isVaultAddress == that.isVaultAddress &&
+        Objects.equals(domain, that.domain) &&
+        Objects.equals(tenantName, that.tenantName) &&
+        Objects.equals(userAccountId, that.userAccountId);
+  }
+
+  @Override public int hashCode() {
+    return Objects.hash(domain, tenantName, userAccountId, isVaultAddress);
+  }
+
+  public String toString() {
+    if (isVaultAddress) {
+      return tenantName + ":" + "vault" + "*" + domain.toString();
+    }
+    else
+      return userAccountId.map(s -> tenantName + ":" + s + "*" + domain.toString())
+          .orElseGet(() -> tenantName + "*" + domain.toString());
+  }
+
+  public InternetDomainName getDomain() {
+    return domain;
+  }
+
+  public String getTenantName() {
+    return tenantName;
+  }
+
+  public Optional<String> getUserAccountId() {
+    return userAccountId;
+  }
+
+  public boolean isVaultAddress() {
+    return isVaultAddress;
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAddressResolver.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAddressResolver.java
new file mode 100644
index 0000000..f8b404f
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/federation/StellarAddressResolver.java
@@ -0,0 +1,21 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.federation;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class StellarAddressResolver {
+  private final ExternalFederationService externalFederationService;
+
+  @Autowired
+  public StellarAddressResolver(
+      final ExternalFederationService externalFederationService) {
+    this.externalFederationService = externalFederationService;
+  }
+
+  public StellarAccountId getAccountIdOfStellarAccount(final StellarAddress stellarAddress)
+      throws FederationFailedException
+  {
+      return externalFederationService.getAccountId(stellarAddress);
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerEffectsListener.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerEffectsListener.java
new file mode 100644
index 0000000..f9726a9
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerEffectsListener.java
@@ -0,0 +1,132 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter;
+
+import java.math.BigDecimal;
+import java.util.Date;
+import java.util.Optional;
+import org.apache.fineract.cn.command.gateway.CommandGateway;
+import org.apache.fineract.cn.stellarbridge.service.ServiceConstants;
+import org.apache.fineract.cn.stellarbridge.service.internal.command.StellarPaymentCommand;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationEntity;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationRepository;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.StellarCursorEntity;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.StellarCursorRepository;
+import org.slf4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+import org.stellar.sdk.Asset;
+import org.stellar.sdk.AssetTypeCreditAlphaNum;
+import org.stellar.sdk.requests.EventListener;
+import org.stellar.sdk.responses.effects.AccountCreditedEffectResponse;
+import org.stellar.sdk.responses.effects.AccountDebitedEffectResponse;
+import org.stellar.sdk.responses.effects.EffectResponse;
+
+@Component
+public class HorizonServerEffectsListener implements EventListener<EffectResponse> {
+
+  private final BridgeConfigurationRepository accountBridgeRepository;
+  private final StellarCursorRepository stellarCursorRepository;
+  private final CommandGateway commandGateway;
+
+  private final Logger logger;
+
+
+  @Autowired
+  HorizonServerEffectsListener(
+      final BridgeConfigurationRepository accountBridgeRepository,
+      final StellarCursorRepository stellarCursorRepository,
+      final CommandGateway commandGateway,
+      @Qualifier(ServiceConstants.LOGGER_NAME) final Logger logger)
+  {
+    this.accountBridgeRepository = accountBridgeRepository;
+    this.stellarCursorRepository = stellarCursorRepository;
+    this.commandGateway = commandGateway;
+    this.logger = logger;
+  }
+
+  @Override public void onEvent(final EffectResponse operation) {
+    final String pagingToken = operation.getPagingToken();
+
+    //This is important, because an event can be sent twice if we are managing both the sending and
+    //receiving account.  We need to be certain we process it only once.
+    final StellarCursorEntity cursorPersistency = markPlace(pagingToken);
+    if (cursorPersistency.getProcessed())
+      return;
+
+    logger.info("Operation with cursor {}", pagingToken);
+
+    handleOperation(operation);
+
+    cursorPersistency.setProcessed(true);
+    stellarCursorRepository.save(cursorPersistency);
+  }
+
+  StellarCursorEntity markPlace(final String pagingToken)
+  {
+    synchronized (stellarCursorRepository) {
+      final Optional<StellarCursorEntity> entry =
+          stellarCursorRepository.findByCursor(pagingToken);
+
+      return entry.orElse(
+          stellarCursorRepository.save(new StellarCursorEntity(pagingToken, new Date())));
+    }
+  }
+
+  private void handleOperation(final EffectResponse effect) {
+
+    if (effect instanceof AccountCreditedEffectResponse)
+    {
+      final AccountCreditedEffectResponse accountCreditedEffect = (AccountCreditedEffectResponse) effect;
+      final BridgeConfigurationEntity toAccount
+          = accountBridgeRepository.findByStellarAccountIdentifier(effect.getAccount().getAccountId());
+      if (toAccount == null)
+        return; //Nothing to do.  Not one of ours.
+
+      final BigDecimal amount
+          = StellarAccountHelpers.stellarBalanceToBigDecimal(accountCreditedEffect.getAmount());
+      final Asset asset = accountCreditedEffect.getAsset();
+      final String assetCode = StellarAccountHelpers.getAssetCode(asset);
+      final String issuer = StellarAccountHelpers.getIssuer(asset);
+
+      logger.info("Credit to {} of {}, in currency {}@{}",
+          toAccount.getTenantIdentifier(), amount, assetCode, issuer);
+
+      //TODO: This will prevent lumens from being registered in the mifos account (likewise below in debit)...
+      if (!(asset instanceof AssetTypeCreditAlphaNum))
+        return;
+
+      final StellarPaymentCommand receivePaymentCommand =
+          new StellarPaymentCommand(toAccount.getTenantIdentifier(), assetCode, amount);
+      commandGateway.process(receivePaymentCommand);
+    }
+    else if (effect instanceof AccountDebitedEffectResponse)
+    {
+      final AccountDebitedEffectResponse accountDebitedEffect = (AccountDebitedEffectResponse)effect;
+
+      final BridgeConfigurationEntity toAccount = accountBridgeRepository
+          .findByStellarAccountIdentifier(accountDebitedEffect.getAccount().getAccountId());
+      if (toAccount == null)
+        return; //Nothing to do.  Not one of ours.
+
+      final BigDecimal amount
+          = StellarAccountHelpers.stellarBalanceToBigDecimal(accountDebitedEffect.getAmount());
+      final Asset asset = accountDebitedEffect.getAsset();
+      final String assetCode = StellarAccountHelpers.getAssetCode(asset);
+      final String issuer = StellarAccountHelpers.getIssuer(asset);
+
+      logger.info("Debit to {} of {}, in currency {}@{}",
+          toAccount.getTenantIdentifier(), amount, assetCode, issuer);
+
+      if (!(asset instanceof AssetTypeCreditAlphaNum))
+        return;
+
+      final StellarPaymentCommand receivePaymentCommand =
+          new StellarPaymentCommand(toAccount.getTenantIdentifier(), assetCode, amount.negate());
+      commandGateway.process(receivePaymentCommand);
+    }
+    else
+    {
+      logger.info("Effect of type {}", effect.getType());
+    }
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerPaymentObserver.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerPaymentObserver.java
new file mode 100644
index 0000000..53e9acd
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerPaymentObserver.java
@@ -0,0 +1,82 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter;
+
+import java.net.URI;
+import java.util.Optional;
+import javax.annotation.PostConstruct;
+import javax.validation.constraints.NotNull;
+import org.apache.fineract.cn.stellarbridge.service.ServiceConstants;
+import org.apache.fineract.cn.stellarbridge.service.internal.config.StellarBridgeProperties;
+import org.apache.fineract.cn.stellarbridge.service.internal.federation.StellarAccountId;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationRepository;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.StellarCursorEntity;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.StellarCursorRepository;
+import org.slf4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+import org.stellar.sdk.KeyPair;
+import org.stellar.sdk.requests.EffectsRequestBuilder;
+
+@Component
+public class HorizonServerPaymentObserver {
+  private final StellarBridgeProperties stellarBridgeProperties;
+
+  private final BridgeConfigurationRepository bridgeConfigurationRepository;
+  private final StellarCursorRepository stellarCursorRepository;
+  private final HorizonServerEffectsListener listener;
+  private final Logger logger;
+
+  @PostConstruct
+  void init()
+  {
+    final Optional<String> cursor = getCurrentCursor();
+
+    bridgeConfigurationRepository.findAll()
+        .forEach(config -> setupListeningForAccount(
+            StellarAccountId.mainAccount(config.getStellarAccountIdentifier()), cursor));
+  }
+
+  @Autowired
+  HorizonServerPaymentObserver(
+      final StellarBridgeProperties stellarBridgeProperties,
+      final BridgeConfigurationRepository bridgeConfigurationRepository,
+      final StellarCursorRepository stellarCursorRepository,
+      final HorizonServerEffectsListener listener,
+      @Qualifier(ServiceConstants.LOGGER_NAME) final Logger logger)
+  {
+    this.stellarBridgeProperties = stellarBridgeProperties;
+    this.bridgeConfigurationRepository = bridgeConfigurationRepository;
+    this.stellarCursorRepository = stellarCursorRepository;
+
+    this.listener = listener;
+
+    this.logger = logger;
+  }
+
+  public void setupListeningForAccount(final StellarAccountId stellarAccountId)
+  {
+    setupListeningForAccount(stellarAccountId, Optional.empty());
+  }
+
+  private Optional<String> getCurrentCursor() {
+    final Optional<StellarCursorEntity> cursorPersistency
+        = stellarCursorRepository.findTopByProcessedTrueOrderByCreatedOnDesc();
+
+    return cursorPersistency.map(StellarCursorEntity::getCursor);
+  }
+
+  private void setupListeningForAccount(
+      @NotNull final StellarAccountId stellarAccountId, @NotNull final Optional<String> cursor)
+  {
+    logger.info("HorizonServerPaymentObserver.setupListeningForAccount {}, cursor {}",
+        stellarAccountId.getPublicKey(), cursor);
+
+    final EffectsRequestBuilder effectsRequestBuilder
+        = new EffectsRequestBuilder(URI.create(stellarBridgeProperties.getHorizonAddress()));
+    effectsRequestBuilder.forAccount(KeyPair.fromAccountId(stellarAccountId.getPublicKey()));
+    cursor.ifPresent(effectsRequestBuilder::cursor);
+
+    effectsRequestBuilder.stream(listener);
+  }
+
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerUtilities.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerUtilities.java
new file mode 100644
index 0000000..cb86bda
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/HorizonServerUtilities.java
@@ -0,0 +1,301 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.net.URISyntaxException;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Supplier;
+import javax.annotation.PostConstruct;
+import org.apache.fineract.cn.stellarbridge.service.ServiceConstants;
+import org.apache.fineract.cn.stellarbridge.service.internal.config.StellarBridgeProperties;
+import org.apache.fineract.cn.stellarbridge.service.internal.federation.StellarAccountId;
+import org.slf4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+import org.stellar.sdk.Account;
+import org.stellar.sdk.Asset;
+import org.stellar.sdk.KeyPair;
+import org.stellar.sdk.Memo;
+import org.stellar.sdk.PathPaymentOperation;
+import org.stellar.sdk.Server;
+import org.stellar.sdk.Transaction;
+import org.stellar.sdk.responses.AccountResponse;
+import org.stellar.sdk.responses.Page;
+import org.stellar.sdk.responses.PathResponse;
+import org.stellar.sdk.responses.SubmitTransactionResponse;
+
+@Component
+public class HorizonServerUtilities {
+  private final StellarBridgeProperties stellarBridgeProperties;
+  private final Logger logger;
+
+  private Server server;
+
+  private final LoadingCache<String, Account> accounts;
+
+  @Autowired
+  HorizonServerUtilities(
+      final StellarBridgeProperties stellarBridgeProperties,
+      @Qualifier(ServiceConstants.LOGGER_NAME) final Logger logger)
+  {
+    this.stellarBridgeProperties = stellarBridgeProperties;
+    this.logger = logger;
+
+    accounts = CacheBuilder.newBuilder().build(
+        new CacheLoader<String, Account>() {
+          public Account load(final String accountId)
+              throws InvalidConfigurationException {
+            final KeyPair accountKeyPair = KeyPair.fromAccountId(accountId);
+            final StellarAccountHelpers accountHelper = getAccount(accountKeyPair);
+            final Long sequenceNumber = accountHelper.get().getSequenceNumber();
+            return new Account(accountKeyPair, sequenceNumber);
+          }
+        });
+  }
+
+  @PostConstruct
+  void init()
+  {
+    server = new Server(stellarBridgeProperties.getHorizonAddress());
+  }
+
+  public void simplePay(
+      final StellarAccountId targetAccountId,
+      final BigDecimal amount,
+      final String assetCode,
+      final StellarAccountId issuingAccountId,
+      final char[] stellarAccountPrivateKey)
+      throws InvalidConfigurationException, StellarPaymentFailedException
+  {
+    logger.info("HorizonServerUtilities.simplePay");
+    final Asset asset = StellarAccountHelpers.getAsset(assetCode, issuingAccountId);
+
+    pay(targetAccountId, amount, asset, asset, stellarAccountPrivateKey);
+  }
+
+  private void pay(
+      final StellarAccountId targetAccountId,
+      final BigDecimal amount,
+      final Asset sendAsset,
+      final Asset receiveAsset,
+      final char[] stellarAccountPrivateKey)
+      throws InvalidConfigurationException, StellarPaymentFailedException
+  {
+    final KeyPair sourceAccountKeyPair = KeyPair.fromSecretSeed(stellarAccountPrivateKey);
+    final KeyPair targetAccountKeyPair = KeyPair.fromAccountId(targetAccountId.getPublicKey());
+
+    final Account sourceAccount = accounts.getUnchecked(sourceAccountKeyPair.getAccountId());
+
+    final Transaction.Builder transferTransactionBuilder
+        = new Transaction.Builder(sourceAccount);
+    final PathPaymentOperation paymentOperation =
+        new PathPaymentOperation.Builder(
+            sendAsset,
+            StellarAccountHelpers.bigDecimalToStellarBalance(amount),
+            targetAccountKeyPair,
+            receiveAsset,
+            StellarAccountHelpers.bigDecimalToStellarBalance(amount))
+            .setSourceAccount(sourceAccountKeyPair).build();
+
+    transferTransactionBuilder.addOperation(paymentOperation);
+
+    if (targetAccountId.getSubAccount().isPresent())
+    {
+      final Memo subAccountMemo = Memo.text(targetAccountId.getSubAccount().get());
+      transferTransactionBuilder.addMemo(subAccountMemo);
+    }
+
+    submitTransaction(sourceAccount, transferTransactionBuilder, sourceAccountKeyPair,
+        StellarPaymentFailedException::transactionFailed);
+  }
+
+  public BigDecimal getBalance(
+      final StellarAccountId stellarAccountId,
+      final String assetCode)
+  {
+    logger.info("HorizonServerUtilities.getBalance");
+    return getAccount(KeyPair.fromAccountId(stellarAccountId.getPublicKey())).getBalance(assetCode);
+  }
+
+  public BigDecimal getBalanceByIssuer(
+      final StellarAccountId stellarAccountId,
+      final String assetCode,
+      final StellarAccountId accountIdOfIssuingStellarAddress)
+      throws InvalidConfigurationException
+  {
+    logger.info("HorizonServerUtilities.getBalanceByIssuer");
+
+    final Asset asset = StellarAccountHelpers.getAsset(assetCode, accountIdOfIssuingStellarAddress);
+
+    return getAccount(KeyPair.fromAccountId(stellarAccountId.getPublicKey()))
+        .getBalanceOfAsset(asset);
+  }
+
+  private StellarAccountHelpers getAccount(final KeyPair installationAccountKeyPair)
+      throws InvalidConfigurationException
+  {
+    final AccountResponse installationAccount;
+    try {
+      installationAccount = server.accounts().account(installationAccountKeyPair);
+    }
+    catch (final IOException e) {
+      throw InvalidConfigurationException.unreachableStellarServerAddress(stellarBridgeProperties.getHorizonAddress());
+    }
+
+    if (installationAccount == null)
+    {
+      throw InvalidConfigurationException.invalidInstallationAccountSecretSeed();
+    }
+
+    return new StellarAccountHelpers(installationAccount);
+  }
+
+
+  public void findPathPay(
+      final StellarAccountId targetAccountId,
+      final BigDecimal amount,
+      final String assetCode,
+      final char[] stellarAccountPrivateKey)
+      throws InvalidConfigurationException, StellarPaymentFailedException
+  {
+    logger.info("HorizonServerUtilities.findPathPay");
+    final KeyPair sourceAccountKeyPair = KeyPair.fromSecretSeed(stellarAccountPrivateKey);
+    final KeyPair targetAccountKeyPair = KeyPair.fromAccountId(targetAccountId.getPublicKey());
+
+    final StellarAccountHelpers sourceAccount = getAccount(sourceAccountKeyPair);
+    final StellarAccountHelpers targetAccount = getAccount(targetAccountKeyPair);
+
+    final Set<Asset> targetAssets = targetAccount.findAssetsWithTrust(amount, assetCode);
+    final Set<Asset> sourceAssets = sourceAccount.findAssetsWithBalance(amount, assetCode);
+
+    final Optional<MatchingAssetPair> assetPair = findAnyMatchingAssetPair(
+        amount, sourceAssets, targetAssets, sourceAccountKeyPair, targetAccountKeyPair);
+    if (!assetPair.isPresent())
+      throw StellarPaymentFailedException.noPathExists(assetCode);
+
+    pay(targetAccountId, amount,
+        assetPair.get().asset1, assetPair.get().asset2,
+        stellarAccountPrivateKey);
+  }
+
+  static class MatchingAssetPair {
+    final Asset asset1;
+    final Asset asset2;
+
+    MatchingAssetPair(Asset asset1, Asset asset2) {
+      this.asset1 = asset1;
+      this.asset2 = asset2;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      MatchingAssetPair that = (MatchingAssetPair) o;
+      return Objects.equals(asset1, that.asset1) &&
+          Objects.equals(asset2, that.asset2);
+    }
+
+    @Override
+    public int hashCode() {
+
+      return Objects.hash(asset1, asset2);
+    }
+  }
+
+  private Optional<MatchingAssetPair> findAnyMatchingAssetPair(
+      final BigDecimal amount,
+      final Set<Asset> sourceAssets,
+      final Set<Asset> targetAssets,
+      final KeyPair sourceAccountKeyPair,
+      final KeyPair targetAccountKeyPair) {
+    if (sourceAssets.isEmpty())
+      return Optional.empty();
+
+    for (final Asset targetAsset : targetAssets) {
+      Page<PathResponse> paths;
+      try {
+        paths = server.paths()
+            .sourceAccount(sourceAccountKeyPair)
+            .destinationAccount(targetAccountKeyPair)
+            .destinationAsset(targetAsset)
+            .destinationAmount(StellarAccountHelpers.bigDecimalToStellarBalance(amount))
+            .execute();
+      } catch (final IOException e) {
+        return Optional.empty();
+      }
+
+      while (paths != null && paths.getRecords() != null) {
+        for (final PathResponse path : paths.getRecords())
+        {
+          if (StellarAccountHelpers.stellarBalanceToBigDecimal(path.getSourceAmount()).compareTo(amount) <= 0)
+          {
+            if (sourceAssets.contains(path.getSourceAsset()))
+            {
+              return Optional.of(new MatchingAssetPair(path.getSourceAsset(), targetAsset));
+            }
+          }
+        }
+
+        try {
+          paths = ((paths.getLinks() == null) || (paths.getLinks().getNext() == null)) ?
+              null : paths.getNextPage();
+        } catch (final URISyntaxException | IOException e) {
+          return Optional.empty();
+        }
+      }
+    }
+
+    return Optional.empty();
+  }
+
+  private <T extends Exception> void submitTransaction(
+      final Account transactionSubmitter,
+      final Transaction.Builder transactionBuilder,
+      final KeyPair signingKeyPair,
+      final Supplier<T> failureHandler)
+      throws T
+  {
+    try {
+      //final Long sequenceNumberSubmitted = account.getSequenceNumber();
+
+      //noinspection SynchronizationOnLocalVariableOrMethodParameter
+      synchronized (transactionSubmitter) {
+        final Transaction transaction = transactionBuilder.build();
+        transaction.sign(signingKeyPair);
+        final SubmitTransactionResponse transactionResponse = server.submitTransaction(transaction);
+        if (!transactionResponse.isSuccess()) {
+          if (transactionResponse.getExtras() != null) {
+            logger.info("Stellar transaction failed, request: {}", transactionResponse.getExtras().getEnvelopeXdr());
+            logger.info("Stellar transaction failed, response: {}", transactionResponse.getExtras().getResultXdr());
+          }
+          else
+          {
+            logger.info("Stellar transaction failed.  No extra information available.");
+          }
+          //TODO: resend transaction if you get a bad sequence.
+              /*Thread.sleep(6000); //Wait for ledger to close.
+              Long sequenceNumberShouldHaveBeen =
+                  server.accounts().account(account.getKeypair()).getSequenceNumber();
+              if (sequenceNumberSubmitted != sequenceNumberShouldHaveBeen) {
+                logger.info("Sequence number submitted: {}, Sequence number should have been: {}",
+                    sequenceNumberSubmitted, sequenceNumberShouldHaveBeen);
+              }*/
+          throw failureHandler.get();
+        }
+      }
+    } catch (final IOException e) {
+      throw InvalidConfigurationException.unreachableStellarServerAddress(stellarBridgeProperties.getHorizonAddress());
+    }
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/InvalidConfigurationException.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/InvalidConfigurationException.java
new file mode 100644
index 0000000..f0417cb
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/InvalidConfigurationException.java
@@ -0,0 +1,20 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter;
+
+public class InvalidConfigurationException extends RuntimeException {
+  private InvalidConfigurationException(final String message)
+  {
+    super(message);
+  }
+
+  static InvalidConfigurationException invalidInstallationAccountSecretSeed() {
+    return new InvalidConfigurationException(
+        "Invalid installation account secret seed.  Have your admin check configuration.");
+  }
+
+  static InvalidConfigurationException unreachableStellarServerAddress(
+      final String serverAddress) {
+    return new InvalidConfigurationException(
+        "Unreachable stellar server address: " + serverAddress +
+            ". Have your admin check configuration.");
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/StellarAccountHelpers.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/StellarAccountHelpers.java
new file mode 100644
index 0000000..1ad52a0
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/StellarAccountHelpers.java
@@ -0,0 +1,184 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.fineract.cn.stellarbridge.service.internal.federation.StellarAccountId;
+import org.stellar.sdk.Asset;
+import org.stellar.sdk.AssetTypeCreditAlphaNum;
+import org.stellar.sdk.AssetTypeNative;
+import org.stellar.sdk.KeyPair;
+import org.stellar.sdk.responses.AccountResponse;
+import org.stellar.sdk.responses.AccountResponse.Balance;
+
+class StellarAccountHelpers {
+  static String getAssetCode(final Asset asset) {
+    if (asset instanceof AssetTypeCreditAlphaNum)
+    {
+      return ((AssetTypeCreditAlphaNum)asset).getCode();
+    }
+    else
+    {
+      return "XLM";
+    }
+  }
+
+  static String getIssuer(final Asset asset) {
+    if (asset instanceof AssetTypeCreditAlphaNum)
+    {
+      return ((AssetTypeCreditAlphaNum)asset).getIssuer().getAccountId();
+    }
+    else
+    {
+      return "stellar";
+    }
+  }
+
+  static boolean balanceIsInAsset(final AccountResponse.Balance balance, final String assetCode)
+  {
+    if (balance.getAssetType() == null)
+      return false;
+
+    if (balance.getAssetCode() == null) {
+      return assetCode.equals("XLM") && balance.getAssetType().equals("native");
+    }
+
+    return balance.getAssetCode().equals(assetCode);
+  }
+
+  static Asset getAssetOfBalance(final AccountResponse.Balance balance)
+  {
+    if (balance.getAssetCode() == null)
+      return new AssetTypeNative();
+    else
+      return Asset.createNonNativeAsset(balance.getAssetCode(),
+          KeyPair.fromAccountId(balance.getAssetIssuer()));
+  }
+
+  static BigDecimal stellarBalanceToBigDecimal(final String balance)
+  {
+    return BigDecimal.valueOf(Double.parseDouble(balance));
+  }
+
+  static String bigDecimalToStellarBalance(final BigDecimal balance)
+  {
+    return balance.toString();
+  }
+
+
+  static Asset getAsset(final String assetCode, final StellarAccountId targetIssuer) {
+    return Asset.createNonNativeAsset(assetCode, KeyPair.fromAccountId(targetIssuer.getPublicKey()));
+  }
+
+  static BigDecimal remainingTrustInBalance(final AccountResponse.Balance balance)
+  {
+    return stellarBalanceToBigDecimal(balance.getLimit())
+        .subtract(stellarBalanceToBigDecimal(balance.getBalance()));
+  }
+
+  private final AccountResponse account;
+
+  StellarAccountHelpers(final AccountResponse account)
+  {
+    this.account = account;
+  }
+
+  AccountResponse get()
+  {
+    return account;
+  }
+
+  BigDecimal getBalanceOfAsset(final Asset asset)
+  {
+    return getNumericAspectOfAsset(asset,
+        balance -> stellarBalanceToBigDecimal(balance.getBalance()));
+  }
+
+  BigDecimal getNumericAspectOfAsset(
+      final Asset asset,
+      final Function<Balance, BigDecimal> aspect)
+  {
+    final Optional<BigDecimal> balanceOfGivenAsset
+        = Arrays.stream(account.getBalances())
+        .filter(balance -> getAssetOfBalance(balance).equals(asset))
+        .map(aspect)
+        .max(BigDecimal::compareTo);
+
+    //Theoretically there shouldn't be more than one balance, but if this should turn out to be
+    //incorrect, we return the largest one, rather than adding them together.
+
+    return balanceOfGivenAsset.orElse(BigDecimal.ZERO);
+  }
+
+  BigDecimal getBalance(final String assetCode) {
+    final AccountResponse.Balance[] balances = account.getBalances();
+
+    return Arrays.stream(balances)
+        .filter(balance -> balanceIsInAsset(balance, assetCode))
+        .map(balance -> stellarBalanceToBigDecimal(balance.getBalance()))
+        .reduce(BigDecimal.ZERO, BigDecimal::add);
+  }
+
+  Set<Asset> findAssetsWithBalance(
+      final BigDecimal amount,
+      final String assetCode) {
+
+    return findAssetsWithAspect(amount, assetCode,
+        balance -> stellarBalanceToBigDecimal(balance.getBalance()));
+  }
+
+  Set<Asset> findAssetsWithTrust(
+      final BigDecimal amount,
+      final String assetCode) {
+
+    return findAssetsWithAspect(amount, assetCode,
+        StellarAccountHelpers::remainingTrustInBalance);
+  }
+
+  private Set<Asset> findAssetsWithAspect(
+      final BigDecimal amount,
+      final String assetCode,
+      final Function<AccountResponse.Balance, BigDecimal> numericAspect)
+  {
+    return Arrays.stream(account.getBalances())
+        .filter(balance -> balanceIsInAsset(balance, assetCode))
+        .filter(balance -> numericAspect.apply(balance).compareTo(amount) >= 0)
+        .sorted(Comparator.comparing(numericAspect::apply))
+        .map(StellarAccountHelpers::getAssetOfBalance)
+        .collect(Collectors.toSet());
+  }
+
+  Stream<Balance> getAllNonnativeBalancesStream(final String assetCode, final Asset vaultAsset)
+  {
+    return Arrays.stream(account.getBalances())
+        .filter(balance -> balanceIsInAsset(balance, assetCode))
+        .filter(balance -> !getAssetOfBalance(balance).equals(vaultAsset));
+  }
+
+  public BigDecimal getRemainingTrustInAsset(final Asset asset) {
+    return getTrustInAsset(asset).subtract(getBalanceOfAsset(asset));
+  }
+
+  public BigDecimal getTrustInAsset(final Asset asset) {
+    return getNumericAspectOfAsset(asset,
+        balance -> stellarBalanceToBigDecimal(balance.getLimit()));
+  }
+
+  public Stream<AccountResponse.Balance> getVaultBalancesStream(final String stellarVaultAccountId) {
+    return Arrays.stream(account.getBalances())
+        .filter(balance -> balance.getAssetIssuer() != null)
+        .filter(balance -> balance.getAssetIssuer().equals(stellarVaultAccountId))
+        .filter(balance -> stellarBalanceToBigDecimal(balance.getLimit()).compareTo(BigDecimal.ZERO) != 0);
+  }
+
+  public Stream<AccountResponse.Balance> getAllNonnativeBalancesStream() {
+    return Arrays.stream(account.getBalances())
+        .filter(balance -> balance.getAssetIssuer() != null)
+        .filter(balance -> stellarBalanceToBigDecimal(balance.getBalance()).compareTo(BigDecimal.ZERO) != 0);
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/StellarPaymentFailedException.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/StellarPaymentFailedException.java
new file mode 100644
index 0000000..d9f4b3e
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/horizonadapter/StellarPaymentFailedException.java
@@ -0,0 +1,16 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.horizonadapter;
+
+public class StellarPaymentFailedException extends RuntimeException {
+  private StellarPaymentFailedException(final String msg) {
+    super(msg);
+  }
+
+  static StellarPaymentFailedException noPathExists(final String assetCode) {
+    return new StellarPaymentFailedException("No path exists in the given currency: " + assetCode);
+  }
+
+  static StellarPaymentFailedException transactionFailed() {
+    return new StellarPaymentFailedException(
+        "Stellar Horizon server did not accept payment for unknown reason.");
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/identity/ApplicationPermissionRequestCreator.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/identity/ApplicationPermissionRequestCreator.java
deleted file mode 100644
index b3c1e7f..0000000
--- a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/identity/ApplicationPermissionRequestCreator.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.fineract.cn.stellarbridge.service.internal.identity;
-
-import javax.validation.Valid;
-import org.apache.fineract.cn.anubis.annotation.Permittable;
-import org.apache.fineract.cn.api.annotation.ThrowsException;
-import org.apache.fineract.cn.identity.api.v1.client.ApplicationPermissionAlreadyExistsException;
-import org.apache.fineract.cn.identity.api.v1.domain.Permission;
-import org.apache.fineract.cn.permittedfeignclient.annotation.EndpointSet;
-import org.apache.fineract.cn.permittedfeignclient.annotation.PermittedFeignClientsConfiguration;
-import org.springframework.cloud.netflix.feign.FeignClient;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-
-/**
- * @author Myrle Krantz
- */
-@EndpointSet(identifier = "stellarbridge__v1__identity__v1")
-@FeignClient(name="identity-v1", path="/identity/v1", configuration=PermittedFeignClientsConfiguration.class)
-public interface ApplicationPermissionRequestCreator {
-
-  @RequestMapping(value = "/applications/{applicationidentifier}/permissions", method = RequestMethod.POST,
-          consumes = {MediaType.APPLICATION_JSON_VALUE},
-          produces = {MediaType.ALL_VALUE})
-  @ThrowsException(status = HttpStatus.CONFLICT, exception = ApplicationPermissionAlreadyExistsException.class)
-  @Permittable(groupId = org.apache.fineract.cn.identity.api.v1.PermittableGroupIds.APPLICATION_SELF_MANAGEMENT)
-  void createApplicationPermission(
-      @PathVariable("applicationidentifier") String applicationIdentifier,
-      @RequestBody @Valid Permission permission);
-}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationEntity.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationEntity.java
index 544d076..9c582eb 100644
--- a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationEntity.java
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationEntity.java
@@ -36,8 +36,12 @@
   private String fineractIncomingAccountIdentifier;
   @Column(name = "fineract_outgoing_identifier")
   private String fineractOutgoingAccountIdentifier;
+  @Column(name = "fineract_staging_identifier")
+  private String fineractStagingAccountIdentifier;
   @Column(name = "stellar_identifier")
   private String stellarAccountIdentifier;
+  @Column(name = "stellar_account_private_key")
+  private char[] stellarAccountPrivateKey;
 
   public BridgeConfigurationEntity() {
     super();
@@ -75,6 +79,14 @@
     this.fineractOutgoingAccountIdentifier = fineractOutgoingAccountIdentifier;
   }
 
+  public String getFineractStagingAccountIdentifier() {
+    return fineractStagingAccountIdentifier;
+  }
+
+  public void setFineractStagingAccountIdentifier(String fineractStagingAccountIdentifier) {
+    this.fineractStagingAccountIdentifier = fineractStagingAccountIdentifier;
+  }
+
   public String getStellarAccountIdentifier() {
     return stellarAccountIdentifier;
   }
@@ -83,6 +95,14 @@
     this.stellarAccountIdentifier = stellarAccountIdentifier;
   }
 
+  public char[] getStellarAccountPrivateKey() {
+    return stellarAccountPrivateKey;
+  }
+
+  public void setStellarAccountPrivateKey(char[] stellarAccountPrivateKey) {
+    this.stellarAccountPrivateKey = stellarAccountPrivateKey;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationEntityRepository.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationRepository.java
similarity index 85%
rename from service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationEntityRepository.java
rename to service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationRepository.java
index 28839ad..358d064 100644
--- a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationEntityRepository.java
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/BridgeConfigurationRepository.java
@@ -23,6 +23,8 @@
 import org.springframework.stereotype.Repository;
 
 @Repository
-public interface BridgeConfigurationEntityRepository extends JpaRepository<BridgeConfigurationEntity, Long> {
+public interface BridgeConfigurationRepository extends JpaRepository<BridgeConfigurationEntity, Long> {
   Optional<BridgeConfigurationEntity> findByTenantIdentifier(String identifier);
+
+  BridgeConfigurationEntity findByStellarAccountIdentifier(String accountId);
 }
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/StellarCursorEntity.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/StellarCursorEntity.java
new file mode 100644
index 0000000..c69bc17
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/StellarCursorEntity.java
@@ -0,0 +1,64 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.repository;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import java.util.Date;
+
+@SuppressWarnings("unused")
+@Entity
+@Table(name = "nenet_stellar_cursor")
+public class StellarCursorEntity {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "id")
+  private Long id;
+
+  @Column(name = "cursor")
+  private String cursor;
+
+  @SuppressWarnings("unused")
+  @Column(name = "processed")
+  private Boolean processed;
+
+  @Column(name = "created_on")
+  @Temporal(TemporalType.TIMESTAMP)
+  private Date createdOn;
+
+  @SuppressWarnings("unused")
+  public StellarCursorEntity() { }
+
+  public StellarCursorEntity(final String cursor, final Date createdOn) {
+    this.cursor = cursor;
+    this.processed = false;
+    this.createdOn = createdOn;
+  }
+
+  public String getCursor() {
+    return cursor;
+  }
+
+  public void setProcessed(Boolean processed) {
+    this.processed = processed;
+  }
+
+  public Boolean getProcessed() {
+    return processed;
+  }
+
+  @SuppressWarnings("unused")
+  public Date getCreatedOn() {
+    return createdOn;
+  }
+
+  @SuppressWarnings("unused")
+  public void setCreatedOn(final Date createdOn) {
+    this.createdOn = createdOn;
+  }
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/StellarCursorRepository.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/StellarCursorRepository.java
new file mode 100644
index 0000000..3ead558
--- /dev/null
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/repository/StellarCursorRepository.java
@@ -0,0 +1,11 @@
+package org.apache.fineract.cn.stellarbridge.service.internal.repository;
+
+import java.util.Optional;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface StellarCursorRepository extends CrudRepository<StellarCursorEntity, Long> {
+  Optional<StellarCursorEntity> findTopByProcessedTrueOrderByCreatedOnDesc();
+  Optional<StellarCursorEntity> findByCursor(String cursor);
+}
diff --git a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/service/BridgeConfigurationService.java b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/service/BridgeConfigurationService.java
index b6ccc5f..4eb621e 100644
--- a/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/service/BridgeConfigurationService.java
+++ b/service/src/main/java/org/apache/fineract/cn/stellarbridge/service/internal/service/BridgeConfigurationService.java
@@ -21,22 +21,22 @@
 import java.util.Optional;
 import org.apache.fineract.cn.stellarbridge.api.v1.domain.BridgeConfiguration;
 import org.apache.fineract.cn.stellarbridge.service.internal.mapper.BridgeConfigurationMapper;
-import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationEntityRepository;
+import org.apache.fineract.cn.stellarbridge.service.internal.repository.BridgeConfigurationRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 @Service
 public class BridgeConfigurationService {
 
-  private final BridgeConfigurationEntityRepository bridgeConfigurationEntityRepository;
+  private final BridgeConfigurationRepository bridgeConfigurationRepository;
 
   @Autowired
-  public BridgeConfigurationService(final BridgeConfigurationEntityRepository bridgeConfigurationEntityRepository) {
+  public BridgeConfigurationService(final BridgeConfigurationRepository bridgeConfigurationRepository) {
     super();
-    this.bridgeConfigurationEntityRepository = bridgeConfigurationEntityRepository;
+    this.bridgeConfigurationRepository = bridgeConfigurationRepository;
   }
 
   public Optional<BridgeConfiguration> findByTenantIdentifier(final String tenantIdentifier) {
-    return this.bridgeConfigurationEntityRepository.findByTenantIdentifier(tenantIdentifier).map(BridgeConfigurationMapper::map);
+    return this.bridgeConfigurationRepository.findByTenantIdentifier(tenantIdentifier).map(BridgeConfigurationMapper::map);
   }
 }
diff --git a/service/src/main/resources/db/migrations/mariadb/V1__initial_setup.sql b/service/src/main/resources/db/migrations/mariadb/V1__initial_setup.sql
index d1614c6..d5d568e 100644
--- a/service/src/main/resources/db/migrations/mariadb/V1__initial_setup.sql
+++ b/service/src/main/resources/db/migrations/mariadb/V1__initial_setup.sql
@@ -20,9 +20,20 @@
 CREATE TABLE nenet_configuration (
   id BIGINT NOT NULL AUTO_INCREMENT,
   tenant_identifier        VARCHAR(32)  NOT NULL,
-  fineract_incoming_identifier VARCHAR(512) NOT NULL,
-  fineract_outgoing_identifier VARCHAR(512) NOT NULL,
+  fineract_incoming_ledger VARCHAR(512) NOT NULL,
+  fineract_outgoing_ledger VARCHAR(512) NOT NULL,
+  fineract_stellar_ledger VARCHAR(512) NOT NULL,
   stellar_identifier VARCHAR(512) NULL,
-  CONSTRAINT nenet_uq UNIQUE (tenant_identifier),
-  CONSTRAINT stellar_identifier PRIMARY KEY (id)
+  stellar_private_key VARCHAR(512) NULL,
+  CONSTRAINT nenet_configuration_uq UNIQUE (tenant_identifier),
+  CONSTRAINT nenet_configuration_pk PRIMARY KEY (id)
 );
+
+CREATE TABLE nenet_stellar_cursor (
+  id BIGINT NOT NULL AUTO_INCREMENT,
+  xcursor            VARCHAR(50)  NOT NULL,
+  processed          BOOLEAN      NOT NULL,
+  created_on         TIMESTAMP    NOT NULL,
+  CONSTRAINT nenet_stellar_cursor_uq UNIQUE (xcursor),
+  CONSTRAINT nenet_stellar_cursor_pk PRIMARY KEY (id)
+);
\ No newline at end of file
diff --git a/shared.gradle b/shared.gradle
index 778c355..7d08b55 100644
--- a/shared.gradle
+++ b/shared.gradle
@@ -28,7 +28,8 @@
         frameworktest: '0.1.0-BUILD-SNAPSHOT',
         frameworkanubis: '0.1.0-BUILD-SNAPSHOT',
         frameworkpermittedfeignclient: '0.1.0-BUILD-SNAPSHOT',
-        identity:  '0.1.0-BUILD-SNAPSHOT',
+        accounting :  '0.1.0-BUILD-SNAPSHOT',
+        stellar : '0.1.6',
         validator : '5.3.0.Final'
 ]
 
@@ -45,6 +46,8 @@
 repositories {
     jcenter()
     mavenLocal()
+    mavenCentral()
+    maven { url "https://jitpack.io" }
 }
 
 dependencyManagement {