We have created a suite of packages that, together, mock an account servicing entity that has deployed Rafiki, exposing an SPSP endpoint, the Open Payments APIs with its required GNAP auth endpoints to request grants, a STREAM endpoint for receiving Interledger packets, and a UI to view and manage the Rafiki instance. Additionally, we provide a simple request signing service that is used by Postman to generate request signatures required by the Open Payments APIs.
These packages include:
backend(SPSP, Open Payments APIs, GraphQL Admin APIs, STREAM endpoint)
auth(GNAP auth server)
mock-account-servicing-entity(mocks an Account Servicing Entity)
frontend(Remix app to expose a UI for Rafiki Admin management via interaction with the
These packages depend on the following databases:
- TigerBeetle or Postgres (accounting)
- Postgres (Open Payments resources, auth resources)
- Redis (STREAM details)
We provide containerized versions of our packages together with two pre-configured docker-compose files (Cloud Nine Wallet and Happy Life Bank) to start two Mock Account Servicing Entities with their respective Rafiki backend and auth servers. They automatically peer and 2 to 3 user accounts are created on both of them.
This environment will set up a playground where you can use the Rafiki Admin APIs and the Open Payments APIs.
Cloud Nine Wallet
(a) User Interface - accessible at http://localhost:3030
(b) Admin API - accessible at http://localhost:3001/graphql
(c) Open Payments API - accessible at http://localhost:3000
(d) Rafiki Admin - accessible at http://localhost:3010
(e) Open Payments Auth API - accessible at http://localhost:3006
Postman Signature Service - accessible at http://localhost:3040
Happy Life Bank
(g) User Interface - accessible at http://localhost:3031
(h) Admin API - accessible at http://localhost:4001/graphql
(i) Open Payments API - accessible at http://localhost:4000
(j) Rafiki Admin - accessible at http://localhost:4010
(k) Open Payments Auth API - accessible at http://localhost:4006
Postman Signature Service - accessible at http://localhost:3041
(m) Postgres Server - accessible at http://localhost:5432
Exploring Accounts on Mock Account Servicing Entity
localhost:3030 to view the accounts on one instance of the Mock Account Servicing Entity called Cloud Nine Wallet.
The accounts of the second instance (Happy Life Bank) can be found on
When clicking on the Account Name, a list of Transactions appears.
Running the local environment
The following should be run from the root of the project.
If you want to use Postgres as the accounting database instead of TigerBeetle, you can use the
psql variant of the
The local environment consists of a primary Rafiki instance and a secondary Rafiki instance, each with
its own docker compose files (Cloud Nine Wallet, Happy Life Bank).
The primary Cloud Nine Wallet docker compose file (
./cloud-nine-wallet/docker-compose.yml) includes the main Rafiki services
auth, as well
as the required data stores tigerbeetle (if enabled), redis, and postgres, so it can be run on its own.
The secondary Happy Life Bank docker compose file (
./happy-life-bank/docker-compose.yml) includes only the Rafiki services, not the data stores. It uses the
data stores created by the primary Rafiki instance so it can’t be run by itself.
pnpm localenv:compose up command starts both the primary instance and the secondary.
pnpm localenv:compose config
|Show all merged config (with Tigerbeetle)
pnpm localenv:compose up
|Start (with Tigerbeetle)
pnpm localenv:compose up -d
|Start (with Tigerbeetle) detached
pnpm localenv:compose down
|Down (with Tigerbeetle)
pnpm localenv:compose down --volumes
|Down and kill volumes (with Tigerbeetle)
pnpm localenv:compose:psql config
|Show all merged config (with Postgresql)
pnpm localenv:compose build
|Build all the containers (with Tigerbeetle)
pnpm localenv:compose:psql up
|Start (with Postgresql)
pnpm localenv:compose:psql up -d
|Start (with Postgresql) detached
pnpm localenv:compose:psql down
|Down (with Postgresql)
pnpm localenv:compose:psql down --volumes
|Down (with Postgresql) and kill volumes
pnpm localenv:compose:psql build
|Build all the containers (with Postgresql)
Postman & Open Payments APIs
The Open Payments APIs can be interacted with using the Postman API collection. You can either log into Postman and fork the collection or you can import it from source. It requires you to either load the Local Environment or the Remote Environment.
The Examples folder in the Postman API collection includes an eCommerce (Open Payments) example that can be executed one by one. It
- gets the sender’s wallet address
- gets the receiver’s wallet address
- requests a grant to create an incoming payment on the receiver’s account
- creates an incoming payment on the receiver’s account
- requests a grant to create (and read) a quote on the senders’s account
- creates a quote on the sender’s account
- requests a grant to create (and read) an outgoing payment on the sender’s account
- creates an outgoing payment on the sender’s account
- fetches the outgoing payment on the sender’s account
Note that one has to go through the interaction flow after requesting a grant for an outgoing payment. More information about the interaction flow can be found here.
In order to manage, and view information about the Rafiki instance(s) using a UI, you can navigate to
localhost:3010 (Cloud Nine Wallet) or
localhost:4010 (Happy Life Bank). This is the
frontend project which runs a Remix app for querying info and executing mutations against the Rafiki Admin APIs.
In addition to the using the Admin UI for interacting with the Admin APIs, you can also use the Apollo explorer (on
localhost:4001/graphql, respectively), and also via the Postman collection. The Postman collection is configured to use the default endpoints of the local environment.
Every wallet address also serves as an SPSP endpoint. A GET request to e.g.
application/spsp4+json will return an SPSP response with STREAM connection details.