eulith-web3js-core
Version:
Eulith core web3js SDK (code to access Eulith services via web3js)
227 lines • 27.7 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.EulithWeb3 = void 0;
const web3_1 = __importDefault(require("web3"));
const crypto = require("crypto"); // import crypto doesn't work from (at least some) reactjs browser apps
const Eulith = __importStar(require("../src/index"));
function LogErr_(logger, w, e) {
var _a;
logger === null || logger === void 0 ? void 0 : logger.log(Eulith.Logging.LogLevel.ERROR, `Error while ${w}: ${e.message}; details: ${JSON.stringify((_a = e.response) === null || _a === void 0 ? void 0 : _a.data)}`);
}
/**
* @typedef Eulith.Web3
*
* This can be used to access Eulith-specific APIs, but often all that is needed
* is Eulith.Provider, and that can be used directly with a web3 js object.
*
* @todo For now - extend Web3 the way the python code does. Perhaps do a class for just eulith-specific methods
* or perhaps find a more object oriented path (like we did for AtomicTx)
*
* Also note - this API deviates from the web3js and etherjs patterns in one important respect:
* their sendTransaction API returns a promise which resolves
* <https://web3js.readthedocs.io/en/v1.2.11/web3-eth.html#sendtransaction> 'when the transaction receipt is available.'
* (oversimplifying, PromiEvent)
*
* This causes a number of problems when using the Eulith atomic transactions, because we NEVER generate those transaction receipts.
* and by default, web3js keeps a waiter around polling (at least on http and in some ways as bad with websocket/etc). It causes
* false positive errors to be reported from various channels (e.g. automation tests). And wastes resources.
*
* So we follow the web3.py pattern, and return a Promise<HASH TAG> instead (eulith_send_and_sign_transaction).
*
* Then, the caller may poll wait with the that hash
* await ew3.eth.getTransactionReceipt(txHash)
* to get the receipt.
*
* Another 'deviation' to report/note, is that the python API has the (exposed in the API) concept of 'signing middleware'.
* EVEN IF this makes sense in the python implementation (I doubt), I propose changing the public API instead to take a
* 'signer' object. And have that 'signer' object ONLY be used in the context of a new proposed method - eulith_send_and_sign_transaction
* - and have that do the signing, INSTEAD of the hooking of eth.send_transaction.
*
* The current behavior of the python code is quite idiosyncratic, and confusing, with respect to WHEN the send_transaction calls
* are intercepted and signed (in context of an atomic transaction changes things, as does from/to address/presence of signature etc).
*
* Perhaps better to have an explicit method eulith_send_and_sign_transaction so you know you are signing (seems like the API flows
* require the caller to know / understand this anyhow).
*
*/
class EulithWeb3 extends web3_1.default {
/**
* @constructor
* @param provider - this is a web3js provider, plus supports eulith apis
* @param disable_transaction_polling defaults true
* @param signer - modifies the behavior of a number of eulith apis (not web3.eth apis) - to include the signers address - but mostly for eulith_send_and_sign_transaction
*
* @todo discuss with Moh/Kristian if it might be cleaner to make ISigner a parameter to those APIs? So this subtlty is clear
*/
constructor({ provider, signer, disable_transaction_polling }) {
super();
if (provider == null) {
throw new Error("Cannot construct Eulith.Web3 without a Eulith.Provider");
}
if (disable_transaction_polling == null) {
disable_transaction_polling = true;
}
if (disable_transaction_polling == true) {
this.eth.transactionPollingTimeout = 0;
}
this.logger_ = provider.logger;
if (signer) {
this.signer_ = Eulith.Signing.SigningService.assure(signer, provider);
provider = provider.cloneWithSigner(this.signer_);
}
this.setProvider(provider);
if (this.signer_ == null) {
this.providerForAPIsRequiringAuthAddressField_ = provider;
}
else {
this.providerForAPIsRequiringAuthAddressField_ = provider.cloneWithURLAdditions({
auth_address: this.signer_.address
});
}
}
/**
* The signer is an optional property of a web3 object, so this can return null
*/
get signer() {
return this.signer_;
}
/**
* Fetch the logger associate dwith this web3 object.
*/
get logger() {
return this.logger_;
}
/**
* @todo CONSIDER DEPRECATING
*
* delegate to this.eth.sendTransaction, but just return the transaction hash;
*
* to get the txReceipt, CALL
* const txReceipt: TransactionReceipt = await ew3.eth.getTransactionReceipt(txHash);
* @param transactionConfig
* @returns
*
* This method is PERHAPS not useful, since there is probably no point in ever sending unsigned transactions
* (besides our use in transactions, which could be done differently, and certainly doesnt require this to be public)
*/
eulith_send_unsigned_transaction(transactionConfig, extraURLQueryParams) {
return __awaiter(this, void 0, void 0, function* () {
let p = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
const txRes = this.eth
.sendTransaction(transactionConfig)
.once("transactionHash", (transactionHash) => {
resolve(transactionHash);
})
.once("error", (error) => {
reject(error);
})
.catch((reason) => reject(reason));
}));
return p;
});
}
/*
* @todo DOCUMENT
* @todo consider migrating to Swaps module...
*/
// def eulith_swap_quote(self, params: Eulith.SwapRequest) -> (float, List[TxParams]):
eulith_swap_quote(params) {
var _a;
return __awaiter(this, void 0, void 0, function* () {
const wireFormatParams = {
sell_token: params.sellToken.address,
buy_token: params.buyToken.address,
sell_amount: params.sellAmount
};
if (params.recipient) {
wireFormatParams["recipient"] = params.recipient;
}
if (params.routeThrough) {
wireFormatParams["route_through"] = params.routeThrough;
}
if (params.liquiditySource) {
wireFormatParams["liquidity_source"] = params.liquiditySource;
}
if (params.slippageTolerance) {
wireFormatParams["slippage_tolerance"] = params.slippageTolerance;
}
const result = yield this.providerForAPIsRequiringAuthAddressField_.request({
method: "eulith_swap",
params: [wireFormatParams]
});
return [(_a = result.price) !== null && _a !== void 0 ? _a : 0.0, result.txs];
});
}
/**
* Send a series of transactions (eulith_send_and_sign_transaction), and wait for each to be confirmed,
* returning the transaction receipts of each.
*
* At any point, one of them could fail, with some having gone on to completion. This process aborts at that time
* and offers no clues about how many were processed (could include the completed ones in a special exception)
*
* @param txs
* @returns
*/
eulith_send_multi_transaction(txs) {
return __awaiter(this, void 0, void 0, function* () {
let results = [];
if (this.signer_ == null) {
throw new Error("This API requires a valid signer provided to the EulithWeb3 object");
}
// accumulate all the promises, and wait all at once
let promises = [];
for (const tx of txs) {
const txHash = yield this.provider.signAndSendTransaction(tx, this.signer);
const txReceipt = yield this.eth.getTransactionReceipt(txHash);
results.push(txReceipt);
}
return results;
});
}
/**
* Returns the provider object associated with this transaction.
*
* @todo NOTE due to quirks of how we implement signing, and cloning etc, this might not be the same
* provider, but instead one derieved from - the original one provided in the constructor.
*/
get provider() {
return this.providerForAPIsRequiringAuthAddressField_;
}
}
exports.EulithWeb3 = EulithWeb3;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web3.js","sourceRoot":"","sources":["../../src/web3.ts"],"names":[],"mappings":"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","sourcesContent":["import Web3 from \"web3\";\nimport { TransactionConfig, TransactionReceipt } from \"web3-eth\";\nimport { AxiosError } from \"axios\";\nconst crypto = require(\"crypto\"); // import crypto doesn't work from (at least some) reactjs browser apps\n\nimport * as Eulith from \"../src/index\";\n\nfunction LogErr_(logger: Eulith.Logging.ILogger, w: string, e: AxiosError): void {\n    logger?.log(\n        Eulith.Logging.LogLevel.ERROR,\n        `Error while ${w}: ${e.message}; details: ${JSON.stringify(e.response?.data)}`\n    );\n}\n\n/**\n *  @typedef Eulith.Web3\n *\n *  This can be used to access Eulith-specific APIs, but often all that is needed\n *  is Eulith.Provider, and that can be used directly with a web3 js object.\n *\n *  @todo For now - extend Web3 the way the python code does. Perhaps do a class for just eulith-specific methods\n *  or perhaps find a more object oriented path (like we did for AtomicTx)\n *\n *  Also note - this API deviates from the web3js and etherjs patterns in one important respect:\n *  their sendTransaction API returns a promise which resolves\n *      <https://web3js.readthedocs.io/en/v1.2.11/web3-eth.html#sendtransaction> 'when the transaction receipt is available.'\n *      (oversimplifying, PromiEvent)\n *\n *  This causes a number of problems when using the Eulith atomic transactions, because we NEVER generate those transaction receipts.\n *  and by default, web3js keeps a waiter around polling (at least on http and in some ways as bad with websocket/etc). It causes\n *  false positive errors to be reported from various channels (e.g. automation tests). And wastes resources.\n *\n *  So we follow the web3.py pattern, and return a Promise<HASH TAG> instead (eulith_send_and_sign_transaction).\n *\n *  Then, the caller may poll wait with the that hash\n *      await ew3.eth.getTransactionReceipt(txHash)\n *  to get the receipt.\n *\n *  Another 'deviation' to report/note, is that the python API has the (exposed in the API) concept of 'signing middleware'.\n *  EVEN IF this makes sense in the python implementation (I doubt), I propose changing the public API instead to take a\n *  'signer' object. And have that 'signer' object ONLY be used in the context of a new proposed method - eulith_send_and_sign_transaction\n *  - and have that do the signing, INSTEAD of the hooking of eth.send_transaction.\n *\n *  The current behavior of the python code is quite idiosyncratic, and confusing, with respect to WHEN the send_transaction calls\n *  are intercepted and signed (in context of an atomic transaction changes things, as does from/to address/presence of signature etc).\n *\n *  Perhaps better to have an explicit method eulith_send_and_sign_transaction so you know you are signing (seems like the API flows\n *  require the caller to know / understand this anyhow).\n *\n */\nexport class EulithWeb3 extends Web3 {\n    /**\n     * @constructor\n     * @param provider - this is a web3js provider, plus supports eulith apis\n     * @param disable_transaction_polling defaults true\n     * @param signer - modifies the behavior of a number of eulith apis (not web3.eth apis) - to include the signers address - but mostly for eulith_send_and_sign_transaction\n     *\n     * @todo discuss with Moh/Kristian if it might be cleaner to make ISigner a parameter to those APIs? So this subtlty is clear\n     */\n    public constructor({\n        provider,\n        signer,\n        disable_transaction_polling\n    }: {\n        provider: Eulith.Provider;\n        signer?: Eulith.Signing.ICryptographicSigner | Eulith.Signing.SigningService;\n        disable_transaction_polling?: boolean;\n    }) {\n        super();\n\n        if (provider == null) {\n            throw new Error(\"Cannot construct Eulith.Web3 without a Eulith.Provider\");\n        }\n\n        if (disable_transaction_polling == null) {\n            disable_transaction_polling = true;\n        }\n        if (disable_transaction_polling == true) {\n            this.eth.transactionPollingTimeout = 0;\n        }\n\n        this.logger_ = provider.logger;\n\n        if (signer) {\n            this.signer_ = Eulith.Signing.SigningService.assure(signer, provider);\n            provider = provider.cloneWithSigner(this.signer_);\n        }\n        this.setProvider(provider);\n\n        if (this.signer_ == null) {\n            this.providerForAPIsRequiringAuthAddressField_ = provider;\n        } else {\n            this.providerForAPIsRequiringAuthAddressField_ = provider.cloneWithURLAdditions({\n                auth_address: this.signer_.address\n            });\n        }\n    }\n\n    /**\n     *  The signer is an optional property of a web3 object, so this can return null\n     */\n    public get signer(): Eulith.Signing.SigningService | undefined {\n        return this.signer_;\n    }\n\n    /**\n     *  Fetch the logger associate dwith this web3 object.\n     */\n    public get logger(): Eulith.Logging.ILogger {\n        return this.logger_;\n    }\n\n    /**\n     *  @todo CONSIDER DEPRECATING\n     *\n     *  delegate to this.eth.sendTransaction, but just return the transaction hash;\n     *\n     *  to get the txReceipt, CALL\n     *      const txReceipt: TransactionReceipt = await ew3.eth.getTransactionReceipt(txHash);\n     * @param transactionConfig\n     * @returns\n     *\n     *  This method is PERHAPS not useful, since there is probably no point in ever sending unsigned transactions\n     *  (besides our use in transactions, which could be done differently, and certainly doesnt require this to be public)\n     */\n    public async eulith_send_unsigned_transaction(\n        transactionConfig: TransactionConfig,\n        extraURLQueryParams?: { [key: string]: string }\n    ): Promise<string> {\n        let p = new Promise<string>(async (resolve, reject) => {\n            const txRes = this.eth\n                .sendTransaction(transactionConfig)\n                .once(\"transactionHash\", (transactionHash: string) => {\n                    resolve(transactionHash);\n                })\n                .once(\"error\", (error: Error) => {\n                    reject(error);\n                })\n                .catch((reason) => reject(reason));\n        });\n        return p;\n    }\n\n    /*\n     *  @todo DOCUMENT\n     *  @todo consider migrating to Swaps module...\n     */\n    // def eulith_swap_quote(self, params: Eulith.SwapRequest) -> (float, List[TxParams]):\n    public async eulith_swap_quote(params: Eulith.Swaps.Request): Promise<[number, TransactionConfig[]]> {\n        const wireFormatParams = {\n            sell_token: params.sellToken.address,\n            buy_token: params.buyToken.address,\n            sell_amount: params.sellAmount\n        };\n        if (params.recipient) {\n            wireFormatParams[\"recipient\"] = params.recipient;\n        }\n        if (params.routeThrough) {\n            wireFormatParams[\"route_through\"] = params.routeThrough;\n        }\n        if (params.liquiditySource) {\n            wireFormatParams[\"liquidity_source\"] = params.liquiditySource;\n        }\n        if (params.slippageTolerance) {\n            wireFormatParams[\"slippage_tolerance\"] = params.slippageTolerance;\n        }\n        const result = await this.providerForAPIsRequiringAuthAddressField_.request({\n            method: \"eulith_swap\",\n            params: [wireFormatParams]\n        });\n        return [result.price ?? 0.0, result.txs];\n    }\n\n    /**\n     *  Send a series of transactions (eulith_send_and_sign_transaction), and wait for each to be confirmed,\n     *  returning the transaction receipts of each.\n     *\n     *  At any point, one of them could fail, with some having gone on to completion. This process aborts at that time\n     *  and offers no clues about how many were processed (could include the completed ones in a special exception)\n     *\n     * @param txs\n     * @returns\n     */\n    async eulith_send_multi_transaction(txs: TransactionConfig[]): Promise<TransactionReceipt[]> {\n        let results = [];\n        if (this.signer_ == null) {\n            throw new Error(\"This API requires a valid signer provided to the EulithWeb3 object\");\n        }\n        // accumulate all the promises, and wait all at once\n        let promises = [];\n        for (const tx of txs) {\n            const txHash: string = await this.provider.signAndSendTransaction(tx, this.signer);\n            const txReceipt: TransactionReceipt = await this.eth.getTransactionReceipt(txHash);\n            results.push(txReceipt);\n        }\n        return results;\n    }\n\n    /**\n     *  Returns the provider object associated with this transaction.\n     *\n     *  @todo NOTE due to quirks of how we implement signing, and cloning etc, this might not be the same\n     *        provider, but instead one derieved from - the original one provided in the constructor.\n     */\n    public get provider(): Eulith.Provider {\n        return this.providerForAPIsRequiringAuthAddressField_;\n    }\n\n    private signer_?: Eulith.Signing.SigningService;\n    private logger_: Eulith.Logging.ILogger;\n\n    // Some APIs need a special URL set (include auth_address), so redirect those through this web3js instance\n    private providerForAPIsRequiringAuthAddressField_: Eulith.Provider;\n}\n"]}