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
|
const axios = require("axios");
const crypto = require("crypto");
app.get("/assets", async (req, res) => {
let assets;
try {
assets = await axios.get("https://assets.blockstream.info/");
res.send(assets.data);
} catch (e) {
l.error("error fetching assets", e);
res.status(500).send("error fetching assets");
}
});
app.post("/assets", auth, async (req, res) => {
try {
const sha256 = crypto.createHash("sha256");
const { id: user_id } = req.user;
const token_address = await lq.getNewAddress("", "legacy");
const asset_address = await lq.getNewAddress("", "legacy");
const blind = false;
const info = await lq.getAddressInfo(asset_address);
const { pubkey: issuer_pubkey } = info;
const { name, asset_amount, token_amount, precision, ticker } = req.body;
const domain = "adamsoltys.com";
const version = 0;
const contract = {
entity: { domain },
issuer_pubkey,
name,
precision,
ticker,
version
};
sha256.update(JSON.stringify(contract));
const hash = sha256.digest("hex");
const contract_hash = hash
.match(/[a-f0-9]{2}/g)
.reverse()
.join("");
const rawtx = await lq.createRawTransaction([], { data: "00" });
const funded = await lq.fundRawTransaction(rawtx, { feeRate: 0.000002 });
const ria = await lq.rawIssueAsset(funded.hex, [
{
asset_amount,
token_amount,
asset_address,
token_address,
blind,
contract_hash
}
]);
const { asset, hex } = ria[0];
const brt = await lq.blindRawTransaction(hex, true, [], false);
const srt = await lq.signRawTransactionWithWallet(brt);
const allowed = (await lq.testMempoolAccept([srt.hex]))[0].allowed;
if (allowed) {
const txid = await lq.sendRawTransaction(srt.hex);
await db.transaction(async transaction => {
let account = await db.Account.findOne({
where: {
user_id,
asset: config.liquid.btcasset
},
lock: transaction.LOCK.UPDATE,
transaction
});
if (Math.round(funded.fee * SATS) > account.balance) {
l.error("amount exceeds balance", asset_amount, funded.fee, account.balance);
throw new Error(`Insufficient funds to pay fee of ${funded.fee} BTC`);
}
account.balance -= Math.round(funded.fee * SATS);
await account.save({ transaction });
account = await db.Account.create(
{
asset,
user_id,
ticker,
precision,
name,
balance: 0,
pending: asset_amount * SATS
},
{ transaction }
);
const payment = await db.Payment.create({
account_id: account.id,
user_id,
hash: txid,
amount: asset_amount * SATS,
received: true,
confirmed: false,
address: asset_address,
network: "LBTC"
});
issuances[txid] = { user_id, asset, asset_amount, payment_id: payment.id };
let user = await getUserById(user_id, transaction);
emit(user.username, "user", user);
});
res.send(issuances[txid]);
}
} catch (e) {
l.error("asset issuance failed", e.message);
res.status(500).send(e.message);
}
});
|
