@koyofinance/react-query-typechain
Version:
281 lines (270 loc) • 11.5 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
TransactionStatus: () => TransactionStatus,
isTransactionFailedError: () => isTransactionFailedError,
isTransactionReplacedError: () => isTransactionReplacedError,
makeSmartContractEventsQueryKey: () => makeSmartContractEventsQueryKey,
makeSmartContractEventsUseQueryOptions: () => makeSmartContractEventsUseQueryOptions,
makeSmartContractReadCallQueryKey: () => makeSmartContractReadCallQueryKey,
makeSmartContractReadCallUseQueryOptions: () => makeSmartContractReadCallUseQueryOptions,
matchSmartContractReadCallQuery: () => matchSmartContractReadCallQuery,
useSmartContractEvents: () => useSmartContractEvents,
useSmartContractReadCall: () => useSmartContractReadCall,
useSmartContractReadCalls: () => useSmartContractReadCalls,
useSmartContractTransaction: () => useSmartContractTransaction
});
module.exports = __toCommonJS(src_exports);
// src/base/TransactionError.ts
var import_utils = require("ethers/lib/utils");
function isTransactionReplacedError(error) {
if (error.code === import_utils.Logger.errors.TRANSACTION_REPLACED) {
return true;
}
return false;
}
__name(isTransactionReplacedError, "isTransactionReplacedError");
function isTransactionFailedError(error) {
if (error?.message?.includes("-32000")) {
return true;
}
return false;
}
__name(isTransactionFailedError, "isTransactionFailedError");
// src/base/TransactionStatus.ts
var TransactionStatus;
(function(TransactionStatus2) {
TransactionStatus2["SUBMITTED"] = "submitted";
TransactionStatus2["REPRICED"] = "repriced";
TransactionStatus2["CANCELLED"] = "cancelled";
TransactionStatus2["MINED"] = "mined";
})(TransactionStatus || (TransactionStatus = {}));
// src/utils/matchSmartContractReadCallQuery/matchSmartContractReadCallQuery.ts
var import_lodash = __toESM(require("lodash.isequal"));
// src/hooks/useSmartContractReadCall/useSmartContractReadCall.ts
var import_react_query = require("react-query");
var IDENTITY_FN = /* @__PURE__ */ __name((v) => v, "IDENTITY_FN");
function useSmartContractReadCall(contract, methodName, options) {
const queryOptions = makeSmartContractReadCallUseQueryOptions(contract, methodName, options);
const queryResult = (0, import_react_query.useQuery)(queryOptions);
return queryResult;
}
__name(useSmartContractReadCall, "useSmartContractReadCall");
function makeSmartContractReadCallUseQueryOptions(contract, methodName, options) {
const { enabled = true, callArgs, staleTime, select, keepPreviousData } = options || {};
const queryKey = makeSmartContractReadCallQueryKey(contract?.address, methodName, callArgs);
const queryFn = /* @__PURE__ */ __name(async () => {
const finalArgs = callArgs || [];
const result = await contract?.callStatic?.[methodName](...finalArgs);
return result;
}, "queryFn");
const queryOptions = {
queryKey,
queryFn,
onError: () => {
console.error(`Error calling ${methodName} on ${contract?.address} with arguments:`, callArgs);
},
select: select || IDENTITY_FN,
keepPreviousData,
staleTime,
enabled: Boolean(contract) && enabled
};
return queryOptions;
}
__name(makeSmartContractReadCallUseQueryOptions, "makeSmartContractReadCallUseQueryOptions");
function makeSmartContractReadCallQueryKey(contractAddress, methodName, callArgs) {
return [
"contractCall",
methodName,
contractAddress,
{
callArgs
}
];
}
__name(makeSmartContractReadCallQueryKey, "makeSmartContractReadCallQueryKey");
// src/utils/matchSmartContractReadCallQuery/matchSmartContractReadCallQuery.ts
function matchSmartContractReadCallQuery(query, contractAddress, methodName, callArgs) {
const match = (0, import_lodash.default)(query.queryKey, makeSmartContractReadCallQueryKey(contractAddress, methodName, callArgs));
return match;
}
__name(matchSmartContractReadCallQuery, "matchSmartContractReadCallQuery");
// src/hooks/useSmartContractEvents/useSmartContractEvents.ts
var import_react_query2 = require("react-query");
function useSmartContractEvents(contract, filterName, options) {
const queryOptions = makeSmartContractEventsUseQueryOptions(contract, filterName, options);
const queryResult = (0, import_react_query2.useQuery)(queryOptions);
return queryResult;
}
__name(useSmartContractEvents, "useSmartContractEvents");
function makeSmartContractEventsUseQueryOptions(contract, filterName, options) {
const { enabled = true, staleTime, cacheTime, refetchOnWindowFocus, callArgs, fromBlock, toBlock } = options || {};
const queryKey = makeSmartContractEventsQueryKey(contract, filterName, callArgs, fromBlock, toBlock);
const queryFn = /* @__PURE__ */ __name(async () => {
const finalContract = contract;
const finalArgs = callArgs || [];
const eventFilter = finalContract.filters[filterName](...finalArgs);
const result = await finalContract.queryFilter(eventFilter, fromBlock, toBlock);
return result;
}, "queryFn");
return {
queryKey,
queryFn,
onError: () => {
console.error(`Error calling ${filterName} on: ${contract?.address} with arguments:`, callArgs);
},
enabled: Boolean(contract) && enabled,
staleTime,
cacheTime,
refetchOnWindowFocus
};
}
__name(makeSmartContractEventsUseQueryOptions, "makeSmartContractEventsUseQueryOptions");
function makeSmartContractEventsQueryKey(contract, filterName, callArgs, fromBlock, toBlock) {
return [
"contractQueryFilter",
filterName,
contract?.address,
fromBlock,
toBlock,
callArgs
];
}
__name(makeSmartContractEventsQueryKey, "makeSmartContractEventsQueryKey");
// src/hooks/useSmartContractReadCalls/useSmartContractReadCalls.ts
var import_lodash2 = __toESM(require("lodash.isplainobject"));
var import_lodash3 = __toESM(require("lodash.zip"));
var import_react_query3 = require("react-query");
function useSmartContractReadCalls(contracts, methodName, options1) {
let optionsArray = [];
if (!options1 || (0, import_lodash2.default)(options1)) {
optionsArray = contracts.map(() => options1);
} else if (options1 && Array.isArray(options1)) {
optionsArray = options1;
}
const queryOptions = (0, import_lodash3.default)(contracts, optionsArray).map(([contract, options]) => makeSmartContractReadCallUseQueryOptions(contract, methodName, options));
const queryResult = (0, import_react_query3.useQueries)(queryOptions);
return queryResult;
}
__name(useSmartContractReadCalls, "useSmartContractReadCalls");
// src/hooks/useSmartContractTransaction/useSmartContractTransaction.ts
var import_react_query4 = require("react-query");
// src/utils/isOverridesObject.ts
var import_lodash4 = __toESM(require("lodash.isplainobject"));
function isOverridesObject(obj) {
if ((0, import_lodash4.default)(obj)) {
const overrides = obj;
if ("gasPrice" in overrides || "gasLimit" in overrides || "value" in overrides || "nonce" in overrides) {
return true;
}
}
return false;
}
__name(isOverridesObject, "isOverridesObject");
// src/hooks/useSmartContractTransaction/useSmartContractTransaction.ts
function useSmartContractTransaction(contract, methodName, signer, options = {}) {
const { onTransactionMined, onTransactionSubmitted, onError, setGasLimit, blockConfirmations = 1 } = options;
return (0, import_react_query4.useMutation)({
mutationFn: async (args) => {
if (!signer) {
console.warn(`Tried to call ${methodName} without a signer.`);
return void 0;
}
if (!contract) {
console.warn(`Tried to call ${methodName} without contract instance.`);
return void 0;
}
const connected = contract.connect(signer);
let finalCallArgs = args;
if (setGasLimit) {
const gasEstimate = await fetchGasEstimate(connected, methodName, args);
const gasLimit = setGasLimit(gasEstimate);
const lastItem = args[args.length - 1];
if (isOverridesObject(lastItem)) {
const argsWithoutOverrides = args.slice(0, args.length - 1);
const newOverrides = {
...lastItem,
gasLimit
};
finalCallArgs = [
...argsWithoutOverrides,
newOverrides
];
} else {
finalCallArgs = [
...args,
{
gasLimit
}
];
}
}
const transaction = await connected[methodName](...finalCallArgs);
void onTransactionSubmitted?.(transaction, args);
return transaction.wait(blockConfirmations);
},
onError: async (error, variables) => {
if (isTransactionFailedError(error)) {
if (process.env.NODE_ENV === "development" && error.message.includes("Nonce too high.")) {
console.error("Nonces don't match. Try resetting your metamask account. Click the account icon -> Settings -> Advanced -> Reset Account");
}
}
if (isTransactionReplacedError(error)) {
if (error.reason === "cancelled") {
return onTransactionMined?.(error.receipt, variables, TransactionStatus.CANCELLED);
}
if (error.reason === "repriced") {
return onTransactionMined?.(error.receipt, variables, TransactionStatus.REPRICED);
}
}
console.error(`Error calling ${methodName} on: ${contract?.address} with arguments:`, variables, error);
await onError?.(error);
},
onSuccess: async (txReceipt, vars) => {
return onTransactionMined?.(txReceipt, vars, TransactionStatus.MINED);
}
});
}
__name(useSmartContractTransaction, "useSmartContractTransaction");
async function fetchGasEstimate(connected, methodName, args) {
return connected.estimateGas[methodName](...args);
}
__name(fetchGasEstimate, "fetchGasEstimate");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
TransactionStatus,
isTransactionFailedError,
isTransactionReplacedError,
makeSmartContractEventsQueryKey,
makeSmartContractEventsUseQueryOptions,
makeSmartContractReadCallQueryKey,
makeSmartContractReadCallUseQueryOptions,
matchSmartContractReadCallQuery,
useSmartContractEvents,
useSmartContractReadCall,
useSmartContractReadCalls,
useSmartContractTransaction
});
//# sourceMappingURL=index.js.map