1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
const bolt11 = require("bolt11");
const { Op } = require("sequelize");
send = async (amount, memo, hash, user) => {
let payreq = bolt11.decode(hash);
let routingInfo = payreq.tags.find(t => t.tagName === "routing_info");
if (
routingInfo &&
routingInfo.data.find(d => d.fee_proportional_millionths > 1000)
)
throw new Error("Fee rate too high");
if (!amount || payreq.satoshis > amount) amount = payreq.satoshis;
if (seen.includes(hash)) {
l.warn("attempted to pay a paid invoice", user.username);
throw new Error("Invoice has been paid, can't pay again");
}
let error, fee, total, preimage, payment;
await db.transaction(async transaction => {
let account = await db.Account.findOne({
where: {
user_id: user.id,
asset: config.liquid.btcasset,
pubkey: null,
balance: {
[Op.gte]: amount
}
},
lock: transaction.LOCK.UPDATE,
transaction
});
if (!account || account.balance < amount) {
throw new Error("Insufficient funds");
}
await account.decrement({ balance: amount }, { transaction });
await account.reload({ transaction });
if (config.lna.clightning) {
let m = await lna.pay(hash);
let sent;
({
msatoshi: total,
msatoshi_sent: sent,
payment_preimage: preimage
} = m);
fee = parseInt((sent - total) / 1000);
total = parseInt(total / 1000);
} else {
let m = await lnp.sendPaymentSync({
amt: amount,
payment_request: hash,
max_parts: 10,
fee_limit: { fixed: Math.min(10000, account.balance) },
});
if (m.payment_error) throw new Error(m.payment_error);
({
payment_route: { total_fees: fee, total_amt: total },
payment_preimage: preimage
} = m);
}
preimage = preimage.toString("hex");
if (seen.includes(preimage)) {
l.warn("duplicate payment detected", preimage);
throw new Error("Duplicate payment detected");
}
});
await db.transaction(async transaction => {
let account = await db.Account.findOne({
where: {
user_id: user.id,
asset: config.liquid.btcasset,
pubkey: null
},
lock: transaction.LOCK.UPDATE,
transaction
});
total = parseInt(total);
fee = parseInt(fee);
await account.decrement({ balance: fee }, { transaction });
await account.reload({ transaction });
payment = await db.Payment.create(
{
amount: -(total - fee),
account_id: account.id,
user_id: user.id,
hash,
memo,
preimage,
rate: app.get("rates")[user.currency],
currency: user.currency,
confirmed: true,
network: "lightning",
fee
},
{ transaction }
);
payment = payment.get({ plain: true });
payment.account = account.get({ plain: true });
emit(user.username, "account", payment.account);
emit(user.username, "payment", payment);
seen.push(preimage);
seen.push(hash);
l.info("sent lightning", user.username, total - fee, fee);
});
return payment;
};
|
