171 lines
5.0 KiB
JavaScript
171 lines
5.0 KiB
JavaScript
const debug = require("debug")("provider:wrapper"); // eslint-disable-line no-unused-vars
|
|
const ProviderError = require("./error");
|
|
|
|
function make1193ProviderRequest(provider) {
|
|
/*
|
|
NOTE: If truffle switches to use WebSockets instead of HTTP requests in the future
|
|
then we will need to keep separate requestId counters for .request and .send
|
|
methods to avoid collision while generating requestIds on parallel requests.
|
|
*/
|
|
let requestId = 0;
|
|
const modifiedRequest = async function ({ method, params }) {
|
|
return await new Promise((accept, reject) => {
|
|
provider.send(
|
|
{
|
|
jsonrpc: "2.0",
|
|
id: ++requestId,
|
|
method,
|
|
params
|
|
},
|
|
(error, response) => {
|
|
if (error) {
|
|
return reject(error);
|
|
}
|
|
if (response.error) {
|
|
const error = new Error(response.error.message);
|
|
error.code = response.error.code;
|
|
if (response.error.data) {
|
|
error.data = response.error.data;
|
|
}
|
|
return reject(error);
|
|
}
|
|
const { result: res } = response;
|
|
accept(res);
|
|
}
|
|
);
|
|
});
|
|
};
|
|
return modifiedRequest.bind(provider);
|
|
}
|
|
|
|
module.exports = {
|
|
/*
|
|
* Web3.js Transport Wrapper
|
|
*
|
|
* Wraps an underlying web3 provider's RPC transport methods (send/sendAsync)
|
|
* for Truffle-specific purposes, mainly for logging / request verbosity.
|
|
*/
|
|
wrap: function (provider, options) {
|
|
/* wrapping should be idempotent */
|
|
if (provider._alreadyWrapped) return provider;
|
|
|
|
/* setup options defaults */
|
|
options = options || {};
|
|
// custom logger
|
|
options.logger = options.logger || console;
|
|
// to see what web3 is sending and receiving.
|
|
options.verbose = options.verbose || options.verboseRpc || false;
|
|
|
|
/* create wrapper functions for before/after send/sendAsync */
|
|
const preHook = this.preHook(options);
|
|
const postHook = this.postHook(options);
|
|
|
|
const originalSend = provider.send.bind(provider);
|
|
|
|
/* overwrite method */
|
|
provider.send = this.send(originalSend, preHook, postHook);
|
|
// overwrite sendAsync only when sendAsync is used.
|
|
if (provider.sendAsync) {
|
|
const originalSendAsync = provider.sendAsync.bind(provider);
|
|
provider.sendAsync = this.send(originalSendAsync, preHook, postHook);
|
|
}
|
|
|
|
// EIP-1193 provider wrapping
|
|
if (provider.request === undefined && provider.send !== undefined) {
|
|
provider.request = make1193ProviderRequest(provider);
|
|
}
|
|
|
|
/* mark as wrapped */
|
|
provider._alreadyWrapped = true;
|
|
|
|
return provider;
|
|
},
|
|
|
|
/*
|
|
* Transport Hook Generators
|
|
*
|
|
* Used to wrap underlying web3.js behavior before/after sending request
|
|
* payloads to the RPC.
|
|
*
|
|
* Transport hooks may be used to perform additional operations before/after
|
|
* sending, and/or to modify request/response data.
|
|
*
|
|
* Each generator accepts an `options` argument and uses it to construct
|
|
* and return a function.
|
|
*
|
|
* Returned functions accept relevant arguments and return potentially new
|
|
* versions of those arguments (for payload/result/error overrides)
|
|
*/
|
|
|
|
// before send/sendAsync
|
|
preHook: function (options) {
|
|
return function (payload) {
|
|
if (options.verbose) {
|
|
// for request payload debugging
|
|
options.logger.log(
|
|
" > " + JSON.stringify(payload, null, 2).split("\n").join("\n > ")
|
|
);
|
|
}
|
|
|
|
if (options.events) {
|
|
options.events.emit("rpc:request", { payload });
|
|
}
|
|
return payload;
|
|
};
|
|
},
|
|
|
|
// after send/sendAsync
|
|
postHook: function (options) {
|
|
return function (payload, error, result) {
|
|
// web3 websocket providers return false and web3 http providers
|
|
// return null when no error has occurred...kind of obnoxious
|
|
if (error) {
|
|
error = new ProviderError(error.message, {
|
|
...options,
|
|
underlyingError: error
|
|
});
|
|
}
|
|
|
|
if (result && options.verbose) {
|
|
options.logger.log(
|
|
" < " + JSON.stringify(result, null, 2).split("\n").join("\n < ")
|
|
);
|
|
}
|
|
|
|
if (options.events) {
|
|
options.events.emit(
|
|
"rpc:result",
|
|
error ? { payload, error } : { payload, result }
|
|
);
|
|
}
|
|
|
|
return [payload, error, result];
|
|
};
|
|
},
|
|
|
|
/*
|
|
* Transport Method Generators
|
|
*
|
|
* Generate wrapped versions of `send`/`sendAsync`, given original method and
|
|
* transport hooks.
|
|
*
|
|
* Pre-condition: originals are bound correctly (`send.bind(provider)`)
|
|
*
|
|
* Return the wrapped function matching the original function's signature.
|
|
*/
|
|
send: function (originalSend, preHook, postHook) {
|
|
return function (payload, callback) {
|
|
payload = preHook(payload);
|
|
|
|
originalSend(payload, function (error, result) {
|
|
const modified = postHook(payload, error, result);
|
|
payload = modified[0];
|
|
error = modified[1];
|
|
result = modified[2];
|
|
|
|
callback(error, result);
|
|
});
|
|
};
|
|
}
|
|
};
|