LumeWeb
/
relay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

*switch to using bcfg

This commit is contained in:
Derrick Hammer 2022-07-05 15:02:07 -04:00
parent 6103edf4a4
commit e6d8decd07
11 changed files with 83 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
package.json
View File

@ -19,6 +19,7 @@
"@types/ws": "^8.5.3",
"@types/xml2js": "^0.4.11",
"async-mutex": "^0.3.2",
"bcfg": "^0.1.7",
"dotenv": "^16.0.1",
"ethers": "^5.6.9",
"express": "^4.18.1",

35
src/config.ts Normal file
View File

@ -0,0 +1,35 @@
// @ts-ignore
import BConfig from "bcfg";
import { errorExit } from "./util.js";
const config = new BConfig("lumeweb-relay");
config.inject({
relayPort: 8080,
});
config.load({
env: true,
argv: true,
});
try {
config.open("config.conf");
} catch (e) {}
for (const setting of ["relay-domain", "afraid-username", "relay-seed"]) {
if (!config.get(setting)) {
errorExit(`Required config option ${setting} not set`);
}
}
let usingPocketGateway = true;
export function usePocketGateway() {
return usingPocketGateway;
}
export function updateUsePocketGateway(state: boolean): void {
usingPocketGateway = state;
}
export default config;

34
src/constant_vars.ts
View File

@ -1,34 +0,0 @@
import fs from "fs";
import dotenv from "dotenv";
import path from "path";
import { fileURLToPath } from "url";
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const envPath = path.resolve(__dirname, "..", "lumerelay.env");
if (fs.existsSync(envPath)) {
dotenv.config({ path: envPath });
}
export const RELAY_PORT = process.env.RELAY_PORT ?? 8080;
export const RELAY_DOMAIN = process.env.RELAY_DOMAIN;
export const AFRAID_USERNAME = process.env.AFRAID_USERNAME;
export const AFRAID_PASSWORD = process.env.AFRAID_PASSWORD;
export const RELAY_SEED = process.env.RELAY_SEED;
export const POCKET_APP_ID = process.env.POCKET_APP_ID || false;
export const POCKET_APP_KEY = process.env.POCKET_APP_KEY || false;
export const POCKET_ACCOUNT_PUBLIC_KEY =
process.env.POCKET_ACCOUNT_PUBLIC_KEY || false;
export const POCKET_ACCOUNT_PRIVATE_KEY =
process.env.POCKET_ACCOUNT_PRIVATE_KEY || false;
export const HSD_USE_EXTERNAL_NODE = process.env.HSD_USE_EXTERNAL_NODE || false;
export const HSD_NETWORK_TYPE = process.env.HSD_NETWORK || "main";
export const HSD_HOST = process.env.HSD_HOST || "localhost";
export const HSD_PORT = Number(process.env.HSD_PORT) || 12037;
export const HSD_API_KEY = process.env.HSD_API_KEY || "foo";
export const POCKET_HOST = process.env.POCKET_HOST || "localhost";
export const POCKET_PORT = process.env.POCKET_PORT || 8081;

27
src/constants.ts
View File

@ -1,27 +0,0 @@
import * as CONFIG from "./constant_vars.js";
let error = false;
for (const constant in CONFIG) {
// @ts-ignore
if (CONFIG[constant] === null || CONFIG[constant] === undefined) {
console.error(`Missing constant ${constant}`);
error = true;
}
}
if (error) {
process.exit(1);
}
let usingPocketGateway = true;
export function usePocketGateway() {
return usingPocketGateway;
}
export function updateUsePocketGateway(state: boolean): void {
usingPocketGateway = state;
}
export * from "./constant_vars.js";

10
src/dht.ts
View File

@ -8,7 +8,7 @@ import {
seedPhraseToSeed,
validSeedPhrase,
} from "libskynet";
import { RELAY_SEED } from "./constant_vars";
import config from "./config.js";
let server: {
listen: (arg0: ed25519Keypair) => void;
@ -16,14 +16,14 @@ let server: {
};
async function start() {
let [, err] = validSeedPhrase(RELAY_SEED as string);
const seed = config.str("relay-seed");
let [, err] = validSeedPhrase(seed);
if (err !== null) {
errorExit("RELAY_SEED is invalid. Aborting.");
}
const keyPair = deriveMyskyRootKeypair(
seedPhraseToSeed(RELAY_SEED as string)[0]
);
const keyPair = deriveMyskyRootKeypair(seedPhraseToSeed(seed)[0]);
const node = new DHT({ keyPair });

18
src/dns.ts
View File

@ -1,9 +1,3 @@
import {
AFRAID_USERNAME,
AFRAID_PASSWORD,
RELAY_PORT,
RELAY_DOMAIN,
} from "./constants.js";
import cron from "node-cron";
import fetch from "node-fetch";
import { get as getDHT } from "./dht.js";
@ -14,6 +8,7 @@ import { Parser } from "xml2js";
import { URL } from "url";
import { errorExit } from "./util.js";
import { pack } from "msgpackr";
import config from "./config.js";
const { createHash } = await import("crypto");
@ -43,7 +38,7 @@ export async function start() {
await overwriteRegistryEntry(
dht.defaultKeyPair,
hashDataKey(REGISTRY_DHT_KEY),
pack(`${RELAY_DOMAIN}:${RELAY_PORT}`)
pack(`${config.str("relay-domain")}:${config.uint("relay-port")}`)
);
cron.schedule("0 * * * *", ipUpdate);
@ -75,6 +70,7 @@ function encodeNumber(num: number): Uint8Array {
}
async function getDomainInfo() {
const relayDomain = config.str("relay-domain");
const parser = new Parser();
const url = new URL("https://freedns.afraid.org/api/");
@ -86,7 +82,9 @@ async function getDomainInfo() {
params.append("style", "xml");
const hash = createHash("sha1");
hash.update(`${AFRAID_USERNAME}|${AFRAID_PASSWORD}`);
hash.update(
`${config.str("afraid-username")}|${config.str("afraid-password")}`
);
params.append("sha", hash.digest().toString("hex"));
@ -101,14 +99,14 @@ async function getDomainInfo() {
let domain = null;
for (const item of json.xml.item) {
if (item.host[0] === RELAY_DOMAIN) {
if (item.host[0] === relayDomain) {
domain = item;
break;
}
}
if (!domain) {
errorExit(`Domain ${RELAY_DOMAIN} not found in afraid.org account`);
errorExit(`Domain ${relayDomain} not found in afraid.org account`);
}
return domain;

18
src/relay.ts
View File

@ -7,18 +7,18 @@ import { relay } from "@hyperswarm/dht-relay";
// @ts-ignore
import Stream from "@hyperswarm/dht-relay/ws";
import { get as getDHT } from "./dht.js";
import { RELAY_DOMAIN, RELAY_PORT } from "./constants.js";
// @ts-ignore
import GLE from "greenlock-express";
// @ts-ignore
import Greenlock from "@root/greenlock";
import path from "path";
import { fileURLToPath } from "url";
import config from "./config.js";
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const config = {
const sslConfig = {
packageRoot: path.dirname(__dirname),
configDir: path.resolve(__dirname, "../", "./data/greenlock.d/"),
cluster: false,
@ -27,14 +27,16 @@ const config = {
};
export async function start() {
const greenlock = Greenlock.create(config);
const relayDomain = config.str("relay-domain");
const relayPort = config.str("relay-port");
const greenlock = Greenlock.create(sslConfig);
await greenlock.add({
subject: RELAY_DOMAIN,
altnames: [RELAY_DOMAIN],
subject: relayDomain,
altnames: [relayDomain],
});
// @ts-ignore
config.greenlock = greenlock;
GLE.init(config).ready(async (GLEServer: any) => {
GLE.init(sslConfig).ready(async (GLEServer: any) => {
let httpsServer = GLEServer.httpsServer();
var httpServer = GLEServer.httpServer();
@ -53,14 +55,14 @@ export async function start() {
relay(dht, new Stream(false, socket));
});
await new Promise((resolve) => {
httpsServer.listen(RELAY_PORT, "0.0.0.0", function () {
httpsServer.listen(relayPort, "0.0.0.0", function () {
console.info("Relay started on ", httpsServer.address());
resolve(null);
});
});
await greenlock.get({
servername: RELAY_DOMAIN,
servername: relayDomain,
});
});
}

20
src/rpc.ts
View File

@ -5,15 +5,6 @@ import { Mutex } from "async-mutex";
import { createRequire } from "module";
import NodeCache from "node-cache";
import { get as getDHT } from "./dht.js";
import {
POCKET_ACCOUNT_PRIVATE_KEY,
POCKET_ACCOUNT_PUBLIC_KEY,
POCKET_APP_ID,
POCKET_APP_KEY,
POCKET_HOST,
POCKET_PORT,
} from "./constant_vars";
import { updateUsePocketGateway, usePocketGateway } from "./constants";
import { Server as JSONServer } from "jayson/promise/index.js";
import { rpcMethods } from "./rpc/index.js";
import {
@ -27,6 +18,7 @@ import {
JSONRPCResponseWithError,
JSONRPCResponseWithResult,
} from "jayson";
import config, { updateUsePocketGateway, usePocketGateway } from "./config.js";
const require = createRequire(import.meta.url);
@ -217,8 +209,10 @@ export async function processRpcRequest(
}
export async function start() {
if (!POCKET_APP_ID || !POCKET_APP_KEY) {
const dispatchURL = new URL(`http://${POCKET_HOST}:${POCKET_PORT}`);
if (!config.str("pocket-app-id") || !config.str("pocket-app-key")) {
const dispatchURL = new URL(
`http://${config.str("pocket-host")}:${config.uint("pocket-port")}`
);
const rpcProvider = new HttpRpcProvider(dispatchURL);
const configuration = new Configuration();
pocketServer = new Pocket([dispatchURL], rpcProvider, configuration);
@ -228,8 +222,8 @@ export async function start() {
if (!usePocketGateway()) {
updateAat(
await unlockAccount(
<string>POCKET_ACCOUNT_PRIVATE_KEY,
<string>POCKET_ACCOUNT_PUBLIC_KEY,
<string>config.str("pocket-account-private-key"),
<string>config.str("pocket-account-public-key"),
"0"
)
);

4
src/rpc/algorand.ts
View File

@ -4,7 +4,7 @@ import minimatch from "minimatch";
import HTTPClient from "algosdk/dist/cjs/src/client/client.js";
import { sprintf } from "sprintf-js";
import { RpcMethodList } from "./index.js";
import { POCKET_APP_ID } from "../constants.js";
import config from "../config.js";
const allowedEndpoints: { [endpoint: string]: ("GET" | "POST")[] } = {
"/v2/teal/compile": ["POST"],
@ -60,7 +60,7 @@ export function proxyRestMethod(
let apiUrl;
try {
apiUrl = sprintf(apiServer, chainId, POCKET_APP_ID);
apiUrl = sprintf(apiServer, chainId, config.str("pocket-app-id"));
} catch (e) {
apiUrl = apiServer;
}

16
src/rpc/common.ts
View File

@ -2,12 +2,8 @@ import { ethers } from "ethers";
import { PocketAAT } from "@pokt-network/pocket-js";
import { maybeMapChainId, reverseMapChainId } from "../util.js";
import { Connection } from "@solana/web3.js";
import {
POCKET_APP_ID,
POCKET_APP_KEY,
usePocketGateway,
} from "../constants.js";
import { getAat, getPocketServer } from "../rpc.js";
import config, { usePocketGateway } from "../config.js";
export const chainNetworks = require("../../networks.json");
@ -20,14 +16,18 @@ const gatewayMethods: {
} = {
default: (chainId: string): RpcProviderMethod => {
const provider = new ethers.providers.JsonRpcProvider({
url: `https://${chainId}.gateway.pokt.network/v1/lb/${POCKET_APP_ID}`,
password: <string>POCKET_APP_KEY,
url: `https://${chainId}.gateway.pokt.network/v1/lb/${config.str(
"pocket-api-id"
)}`,
password: config.str("pocket-api-key"),
});
return provider.send.bind(provider);
},
"sol-mainnet": (chainId: string): RpcProviderMethod => {
const provider = new Connection(
`https://solana-mainnet.gateway.pokt.network/v1/lb/${POCKET_APP_ID}`
`https://solana-mainnet.gateway.pokt.network/v1/lb/${config.str(
"pocket-api-id"
)}`
);
// @ts-ignore

23
src/rpc/handshake.ts
View File

@ -3,13 +3,8 @@ import { RpcMethodList } from "./index.js";
import rand from "random-key";
// @ts-ignore
import SPVNode from "hsd/lib/node/spvnode.js";
import {
HSD_API_KEY,
HSD_HOST,
HSD_NETWORK_TYPE,
HSD_PORT,
HSD_USE_EXTERNAL_NODE,
} from "../constants.js";
import config from "../config.js";
const { NodeClient } = require("hs-client");
let hsdServer: SPVNode;
@ -21,11 +16,7 @@ let clientArgs = {
apiKey: rand.generate(),
};
if (!HSD_USE_EXTERNAL_NODE) {
process.env.HSD_NO_DNS = "true";
process.env.HSD_NO_RS = "true";
process.env.HSD_HTTP_HOST = "127.0.0.1";
process.env.HSD_API_KEY = clientArgs.apiKey;
if (!config.bool("hsd-use-extenal-node")) {
hsdServer = new SPVNode({
config: false,
argv: false,
@ -41,10 +32,10 @@ if (!HSD_USE_EXTERNAL_NODE) {
});
} else {
clientArgs = {
network: HSD_NETWORK_TYPE,
host: HSD_HOST,
port: HSD_PORT,
apiKey: HSD_API_KEY,
network: config.str("hsd-network-type"),
host: config.str("hsd-host"),
port: config.uint("hsd-port"),
apiKey: config.str("hsd-api-key"),
};
}