Sam Kummary and Miguel de Barros, have had the privilege of working on the Mojaloop OSS (Open Source Software) project since its inception, first through ModusBox and now as INFITX and they are proud to be part of a growing community. To support technical contributions, they have often assisted new community members in coming up to speed on Mojaloop and the tools & processes a developer needs to go through.
This series is part of their contribution to the community that looks to package that advice and learnings, hoping that we can support more contributors more quickly, and get feedback on what works or doesn’t. Please let us know what works for you.
This blog is the first “brain dump” that hopes to give an overview of the resources that a Technically-Oriented Mojalooper may find valuable, specifically someone who is interested in the Mojaloop technical internals, or if you would like to contribute as a Developer to the Open Source Mojaloop Project.
Expect each section to get its own in-depth blog in the future (please let us know which areas might be more urgent). We will start by looking at an overview of the Technical and API aspects of Mojaloop, followed by its standards, then installing Mojaloop, and finally some examples of how you can set up a development environment.
Feel free to use the following quick links to jump between sections.
Quick Links:
If you want to dive right in, then have a look at section 5.2 of the Development Environment, where you can execute a Mojaloop transaction through all the phases (Discovery, Agreement & Transfer) using a Mobile Simulator. You will also be able to monitor the integration flows in real time along with their associated API messages, have the ability to view participant positions, and settle the corresponding transfers.
If you are more interested in developing participant tools or services (“Participant” here refers to any institution that might be connected to the hub, and when we talk about a DFSP this is a participating organization that is a holder of customer accounts, like a Bank or Mobile Money Provider), then consider using the Testing Toolkit (TTK) as described in section 4.4 or 4.5 of the Development Environment.
If you are a product or business-minded Mojalooper and got this far, hats off to you – more business-oriented information can be found in these Mojaloop Training Program programs: MOJA101, HUB101, and DFSP101. However, you may still find the use case flows in section 1.1 in the Technical Overview to be useful.
1: Technical Overview
As a developer, we would suggest first starting here by looking at the Technical aspects of the Mojaloop platform itself. All of these concepts, diagrams, and ideas are covered by the Mojaloop Training Program Technical Overview course – MOJA103, which we can’t recommend enough as it provides a synthesis of all the information below into a succinct presentation.
- The following link will provide you with a good overview of the high-level Mojaloop flows between Payer and Payee account holding institutions (aka DFSPs). These provide the interactions from a System perspective, covering the three main Mojaloop interactions: “Discovery”, “Agreement”, and “Transfers”: https://docs.mojaloop.io/technical as the A, B, and C flows respectively.
- The next link will give you a more detailed view of the “Transfers” processing flow of the Central-Ledger and its supporting components: https://docs.mojaloop.io/technical/central-ledger/
- Here you can also see the underlying run-time environment, supporting service, and components: https://docs.mojaloop.io/legacy/mojaloop-technical-overview/overview. This link provides a detailed breakdown of the physical microservice components within the Mojaloop product, and how they are associated with the persistence/message backend service by their color gradients. For example, take the Quoting Service, which is a single Deep-blue gradient indicating that it has a dependency on MySQL. Another example is the ML API Adapter with a gradient from Purple to Light-blue, which has a dependency on both Kafka and MongoDB.
2: API Overview
There are several APIs that are part of the Mojaloop product, and as such we recommend becoming familiar with them at least at a high level:
- FSP Interoperability (FSPIOP) APIs handle the “Discovery”, “Agreement”, and “Transfers” interactions. This specification is rather large, so we would suggest at least focusing initially on the P2P use case and the provided end-to-end example – https://docs.mojaloop.io/api/fspiop/v1.1/api-definition.html
We also recommend looking at the Mojaloop Training Program Technical Overview course which covers the above API interactions in detail – MOJA101. - Administration API which handles the Onboarding of FSPs, Accounts, Callback URLs, and Funds-in/out – https://docs.mojaloop.io/api/administration
- Settlement API which can be used to generate a Settlement Matrix, as well as to track external settlements by receiving acknowledgments – https://docs.mojaloop.io/api/settlement
- Third-party Payment Initiation (3PPI/PISP) API allowing non-fund-holding participants, specifically Payment Initiation Service Providers (PISPs) to interact with other (fund/account holding) institutions over a centralized Mojaloop hub – https://docs.mojaloop.io/api/thirdparty
3: Community Standards
The Mojaloop Design Authority in conjunction with the wider Community has documented several standards from both a technical and process perspective:
- Here you will find documented standards guide for the Mojaloop platform which includes the runtime, microservice architecture, code style, CI/CD (Continuous Integration/Deployment), documentation, project structures, config files, dependency management, tools/frameworks, implementation guidelines, code of conduct, licensing, etc: https://docs.mojaloop.io/community/standards/guide.html
- If you are contributing, then ensure that you have a look at our Pull-Request (PR) process which includes everything from forking, and branching to opening a PR: https://docs.mojaloop.io/community/standards/creating-new-features.html
4: Deploying Mojaloop
We would also recommend that you make yourself familiar with how to deploy Mojaloop, or at least understand what options you have to do so. Thus a great place to start would be the Getting Started Installation page. Here you will find the necessary links to how you can install Mojaloop either directly on your own Kubernetes (K8s) environment or use one of the bespoke IaC deployment scripts/tools depending on your requirements. These deployments could also be as a development or quality assurance platform to test new features, contributions, or bug fixes:
- If you want to set up your own or have an existing K8s environment, then have a look at the Mojaloop Deployment Guide
- If you want a simple Mojaloop deployment with basic functionality that is well suited for local demonstration and testing that runs on a single K8s-node, then consider using Mini-loop
- However, If you are looking for something that can be used as a foundation to build a “production” grade-like deployment that is secure and includes additional add-ons, such as an API Gateway and simulated/example FSPs that are accessible through the secure Payment Manager for Mojaloop (PM4ML), then make sure you have a look at the IaC Platform for Mojaloop: https://github.com/mojaloop/iac-aws-platform.
Also, make sure to have a look at the Mojaloop Infrastructure as Code series written by the principal infrastructure architect behind the IaC workstream, David Fry where he talks about how to use the IaC to its full effect and the journey it is on to support on-prem deployments. - Lastly, the Azure Marketplace. provides a simple (not current, yet) version of Mojaloop for PoC-type deployments to the Azure cloud. The Mojaloop community is working to update this to support the latest Mojaloop versions, which we expect to be made available in the near future.
5: Development Environment
If you are actively developing new features or implementing bug fixes for Mojaloop, you definitely want an environment that is more lightweight that can be run locally to test against, and in some cases even debug. Below we have provided several options on how this can be done, using the Central Ledger as an example.
- Using the Docker-Compose of the Central-Ledger repo we can stand-up a very simple and lightweight environment that can be used to test the “Transfers” processing flow on your local machine. You can either interact through the FSPIOP API Services (via the ML-API-Adapter) or alternatively by creating messages directly on the Kafka broker:
https://github.com/mojaloop/central-ledger#development-environment - If you are more interested in running all core Mojaloop services so that the “Discovery”, “Agreement”, and “Transfers” interactions are available via Docker-Compose, then the Mojaloop Core Test Harness is what you should consider. This also utilizes the Mojaloop Testing Toolkit which provides a great UI experience and also a Mobile-Simulator demo that showcases all of the above three interactions with simulated settlements.
- We recommend having a look at this blog post by TTK’s main developer and a fellow INFITX colleague Vijay Kumar Guthi – “Get Hands-On Locally with Core Mojaloop”
- Running P2P Transfer using the TTK Web UI
- Running P2P Transfers using the Testing Toolkit Mobile Simulator
- If you want to test/debug directly on either your local or remote Kubernetes environment, then you should consider using one of the following host-sync tools:
- https://www.devspace.sh (this being my preference)
- https://tilt.dev
- https://skaffold.dev
- If you are more interested in developing interoperable tools or services with Mojaloop either as a DFSP or a third-party/PISP, ie. If you are a System Integrator interested in connecting your client’s back-end systems to Mojaloop, then we would recommend utilizing Mojaloop Testing Toolkit as either a Hub simulator and/or a DFSP simulator. This means you avoid the need to deploy Mojaloop during the development of the core connector and can just focus on the job at hand.
- Hosted Mode with “Docker Compose”
- Mojaloop Training Program Mojaloop Testing Toolkit – TTK101
- Lastly, if you are a fintech and are interested in providing a Third-party (3PPI or PISP) or Payment initiation service and would like to get started quickly, here’s a simulation of Mojaloop’s third-party functionality (only for third-party providers, which can be a viewed as a local sandbox) using the TTK that you can locally deploy and get started on your solution
Conclusion
In conclusion, this article attempts to capture the necessary resources and information required by a developer to contribute to the Open Source Mojaloop Project. We have covered several topics touching everything from the Technical aspects of Mojaloop, to the community standards that one would use when developing features/bugs, to how one can deploy mojaloop, and finally how one can set up a development environment.
We hope you find this blog useful. Let us know if there is any area that you would like us to delve into more detail, or if you have any questions.
Just a reminder that INFITX can help ramp up your technical capabilities to support you on your fintech journey: https://www.infitx.com/capacity-building.
Feel free to reach out to us via Mojaloop’s Slack, or Mojaloop’s Community Central if you have any questions.
References
- https://mojaloop.io
- https://mojaloop.io/community
- https://community.mojaloop.io
- https://mojaloop.io/mojaloop-training-program
- https://github.com/mojaloop/project/issues
- https://docs.mojaloop.io/community/standards/creating-new-features.html
- https://rtplex.io/payment-manager-oss
- https://github.com/pm4ml/on-premise-deploy
- https://github.com/mojaloop/iac-aws-platform
- https://github.com/mojaloop/ml-testing-toolkit/blob/master/documents
- https://github.com/mojaloop/ml-core-test-harness
- https://github.com/mojaloop/pisp-ttk-sandbox
- https://github.com/mojaloop/central-ledger
- https://github.com/mojaloop/quoting-service
- https://github.com/mojaloop/ml-api-adapter
- https://azuremarketplace.microsoft.com/en-gb/marketplace/apps/mojaloopfoundationinc1648049563908.mojaloop
- https://kubernetes.io
- https://kafka.apache.org
- https://www.infitx.com/series/mojaloop-iac-series
- https://www.infitx.com/devs-get-hands-on-locally-with-core-mojaloop
