111 lines
2.5 KiB
TypeScript
111 lines
2.5 KiB
TypeScript
import RpcNetwork from "../network.js";
|
|
import { ClientRPCRequest, RPCResponse } from "@lumeweb/relay-types";
|
|
import { RpcQueryOptions } from "../types.js";
|
|
import b4a from "b4a";
|
|
import { hashQuery, isPromise, validateTimestampedResponse } from "../util.js";
|
|
import RPC from "@lumeweb/rpc";
|
|
import { ERR_INVALID_SIGNATURE } from "../error.js";
|
|
import RpcQueryBase from "./base.js";
|
|
import { query } from "express";
|
|
|
|
export default class SimpleRpcQuery extends RpcQueryBase {
|
|
protected _relay?: string | any;
|
|
protected declare _query: ClientRPCRequest;
|
|
|
|
constructor({
|
|
network,
|
|
relay,
|
|
query,
|
|
options,
|
|
}: {
|
|
network: RpcNetwork;
|
|
relay?: string | any;
|
|
query: ClientRPCRequest;
|
|
options: RpcQueryOptions;
|
|
}) {
|
|
super({ network, query, options });
|
|
this._relay = relay;
|
|
}
|
|
|
|
protected async _run(): Promise<void> {
|
|
await this.queryRelay();
|
|
await this.checkResponses();
|
|
}
|
|
|
|
protected async queryRelay(): Promise<any> {
|
|
let socket = this._relay;
|
|
|
|
if (socket) {
|
|
if (socket === "string") {
|
|
try {
|
|
const relay = this._network.getRelay(socket);
|
|
if (this._network.getRelay(socket)) {
|
|
socket = relay;
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
if (socket === "string") {
|
|
try {
|
|
socket = this._network.swarm.connect(b4a.from(this._relay, "hex"));
|
|
if (isPromise(socket)) {
|
|
socket = await socket;
|
|
}
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
if (!socket) {
|
|
socket = this._network.getAvailableRelay(
|
|
this._query.module,
|
|
this._query.method
|
|
);
|
|
}
|
|
|
|
this._relay = socket;
|
|
|
|
await socket.opened;
|
|
|
|
const rpc = new RPC(socket);
|
|
|
|
if (this._query.bypassCache) {
|
|
delete this._query.bypassCache;
|
|
await this.queryRpc(rpc, {
|
|
module: "rpc",
|
|
method: "clear_cached_item",
|
|
data: hashQuery(this._query),
|
|
});
|
|
}
|
|
|
|
if ("bypassCache" in this._query) {
|
|
delete this._query.bypassCache;
|
|
}
|
|
|
|
try {
|
|
await this.queryRpc(rpc, this._query);
|
|
} catch (e: any) {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
protected async checkResponses() {
|
|
let response: RPCResponse = this._response as RPCResponse;
|
|
|
|
if (this._error) {
|
|
response = { error: this._error };
|
|
}
|
|
|
|
if (
|
|
!response.error &&
|
|
!validateTimestampedResponse(
|
|
b4a.from(this._relay.remotePublicKey, "hex") as Buffer,
|
|
response
|
|
)
|
|
) {
|
|
response = { error: ERR_INVALID_SIGNATURE };
|
|
}
|
|
|
|
this.resolve(response);
|
|
}
|
|
}
|