Handling Deposits

Search…
Handling Deposits
Phase 1: Receiving Deposit Request from a User
Step 1
The user should send the deposit request to the server. The deposit request should have the currency and amount being transferred.
1
// Express post endpoint to receive deposit requests
2
app.post(
3
    '/plugins/bank/deposit',
4
    toolsLib.security.verifyBearerTokenExpressMiddleware(['user']),
5
    (req, res) => {
6
        ...
7
    }
8
);
Copied!
Step 2
The server creates a unique key (UUID) for the deposit. This UUID will ensure that this transaction occurs only once.
After creating the UUID, the deposit data (amount, currency, user ID, UUID) should be stored on Redis. We recommend setting the UUID as the key. It's also a  good idea to give the data an expiry time.
1
const transferUuid = // generate uuid
2
const amount, currency = // deposit data from request
3
const user_id = // ID of user making request
4
​
5
const payload = {
6
    amount,
7
		currency,
8
		user_id
9
};
10
​
11
// store transfer data on redis with uuid as key
12
await toolsLib.database.client.setAsync(transferUuid, JSON.stringify(payload));
Copied!
Step 3
After the deposit is given a UUID and is stored on Redis, the server should then forward the payment request to the payment service. The payment service should receive the amount, currency, and UUID of the requested deposit.
Step 4
Once the request from the server is received, the payment service will prompt the user to complete the payment. This can be handled by the server or by the payment service directly via a redirect.
This step will differ based on which service is used but will ultimately end up with the user being asked to complete the payment.
Phase 2: User completes deposit
Phase 3: Payment service notifies the server of completed deposit
Step 1
Once the user completes the payment, the service will notify the server of the completed payment. The way notifications are handled will depend on the payment service used. This notification should come with the amount and currency of the completed deposit. It should also provide the UUID the server created for this deposit in Phase 1.
1
// Express post endpoint to receive deposit notifications
2
// Accepts uuid as path parameter
3
app.post(
4
    '/plugins/bank/:uuid',
5
    (req, res) => {
6
        ...
7
    }
8
);
Copied!
Step 2
Once the server receives the notification, it should first check Redis to make sure the UUID is valid.
If no data is found on Redis with the received UUID, the deposit should be rejected. 
If data is found with the UUID, that data should be deleted from Redis. After deletion, the server should verify that the amount and currency of the deposit received from the payment service matches the ones found on Redis.
If the user paid less than the required amount or used a different currency, the deposit should be rejected.
1
const uuid = // uuid received in notification
2
const amount, currency = // deposit data from notification
3
​
4
// get transfer data from Redis using uuid 
5
const storedDepositData = await toolsLib.database.client.getAsync(uuid);
6
​
7
// if no data found on Redis, reject transfer
8
if (!storedDepositData) {
9
    throw err;
10
}
11
​
12
// Delete data from Redis
13
await toolsLib.database.client.delAsync(uuid);
14
​
15
// If deposit amount or currency don't match data found on redis, reject transfer
16
if (
17
    storedDepositData.amount !== amount
18
    || storedDepositData.currency !== currency
19
) {
20
    throw err;
21
}
Copied!
Step 3
Once everything is validated, the server should mint the asset to the user. This completes the deposit flow.
Code Example
For this example, we will use a redirect for prompting the user to complete the payment and receive a notification of the completed payment via a callback URL. The process for both may be different for some payment services but the overall flow should remain the same.
1
// PHASE 1: RECEIVE DEPOSIT REQUEST FROM USER
2
app.post('/plugins/bank/deposit', toolsLib.security.verifyBearerTokenExpressMiddleware(['user']), (req, res) => {
3
	const { currency, amount } = req.body;
4
	const user_id = req.auth.sub.id;
5
​
6
	// Create UUID for this deposit
7
	const transactionId = uuid();
8
	
9
	// Callback url for payment notification
10
	const callback_url = `${toolsLib.getKitConfig().info.url}/plugins/bank/${transactionId}`;
11
​
12
	const payload = {
13
		amount,
14
		currency,
15
		callback_url,
16
		user_id, // user_id added for callback
17
		expires: moment().add(5, 'minutes') // if payment occurs 5 minutes after expires, deny transfer
18
	};
19
​
20
	// Store deposit data in Redis
21
	await toolsLib.database.client.setAsync(transferUuid, JSON.stringify(payload));
22
​
23
	// PAYMENT_SERVICE is the payment service being used
24
	const transferResponse = await PAYMENT_SERVICE.deposit(payment);
25
​
26
	// Redirect user for completing the payment
27
	return res.redirect(transferResponse.url);
28
});
29
​
30
// PHASE 3: RECEIVE NOTIFICATION OF COMPLETED DEPOSIT FROM PAYMENT SERVICE
31
app.post('/plugins/bank/:uuid', (req, res) => {
32
	const { uuid } = req.params;
33
	const { amount, currency, transaction_id } = req.body;
34
	
35
	// Get deposit data from Redis via uuid
36
	const storedDepositData = await toolsLib.database.client.getAsync(uuid);
37
	
38
	// If data is not found, reject deposit
39
	if (!storedDepositData) {
40
		return res.status(400).json({ message: `No deposit found with UUID ${uuid}` });
41
	}
42
	
43
	storedDepositData = JSON.parse(storedDepositData);
44
	
45
	// Delete data from Redis
46
	await toolsLib.database.client.delAsync(uuid);
47
	
48
	// If deposit occured after expiry time, reject the deposit
49
	if (moment().isAfter(storedDepositData.expires)) {
50
		return res.status(400).json({ message: 'Deposit is expired' });
51
	}
52
	
53
	// If deposit amount or currency don't match ones stored on Redis, reject the deposit
54
	if (amount !== storedDepositData.amount || currency !== storedDepositData.currency) {
55
		return res.status(400).json({ message: 'Incorrect amount or currency given' });
56
	}
57
	
58
	// All checks passed, mint the asset with the transaction ID obtained from serivce provider
59
	const mintResponse = await toolsLib.wallet.mintAssetByKitId(
60
		storedDepositData.user_id, // User kit id
61
		storedDepositData.currency, // currency
62
		storedDepositData.amount, // amount
63
		{
64
				description: 'Bank Deposit', // description
65
				transactionId: transaction_id // transaction id
66
		}
67
	);
68
	
69
	return res.json(mintResponse);
70
});
Copied!
How-tos - Previous
Bank integration
Handling Withdrawals
Last modified 1yr ago
Copy link
Contents
Phase 1: Receiving Deposit Request from a User
Phase 2: User completes deposit
Phase 3: Payment service notifies the server of completed deposit
Code Example