import { Interface, Typed } from "../abi/index.js"; import { resolveAddress } from "../address/index.js"; // import from provider.ts instead of index.ts to prevent circular dep // from EtherscanProvider import { copyRequest, Log } from "../providers/provider.js"; import { defineProperties, isCallException, isHexString, resolveProperties, makeError, assert, assertArgument } from "../utils/index.js"; import { ContractEventPayload, ContractUnknownEventPayload, ContractTransactionResponse, EventLog } from "./wrappers.js"; const BN_0 = BigInt(0); function canCall(value) { return (value && typeof (value.call) === "function"); } function canEstimate(value) { return (value && typeof (value.estimateGas) === "function"); } function canResolve(value) { return (value && typeof (value.resolveName) === "function"); } function canSend(value) { return (value && typeof (value.sendTransaction) === "function"); } class PreparedTopicFilter { #filter; fragment; constructor(contract, fragment, args) { defineProperties(this, { fragment }); if (fragment.inputs.length < args.length) { throw new Error("too many arguments"); } // Recursively descend into args and resolve any addresses const runner = getRunner(contract.runner, "resolveName"); const resolver = canResolve(runner) ? runner : null; this.#filter = (async function () { const resolvedArgs = await Promise.all(fragment.inputs.map((param, index) => { const arg = args[index]; if (arg == null) { return null; } return param.walkAsync(args[index], (type, value) => { if (type === "address") { return resolveAddress(value, resolver); } return value; }); })); return contract.interface.encodeFilterTopics(fragment, resolvedArgs); })(); } getTopicFilter() { return this.#filter; } } // A = Arguments passed in as a tuple // R = The result type of the call (i.e. if only one return type, // the qualified type, otherwise Result) // D = The type the default call will return (i.e. R for view/pure, // TransactionResponse otherwise) //export interface ContractMethod = Array, R = any, D extends R | ContractTransactionResponse = ContractTransactionResponse> { function getRunner(value, feature) { if (value == null) { return null; } if (typeof (value[feature]) === "function") { return value; } if (value.provider && typeof (value.provider[feature]) === "function") { return value.provider; } return null; } function getProvider(value) { if (value == null) { return null; } return value.provider || null; } /** * @_ignore: */ export async function copyOverrides(arg, allowed) { // Create a shallow copy (we'll deep-ify anything needed during normalizing) const overrides = copyRequest(Typed.dereference(arg, "overrides")); assertArgument(overrides.to == null || (allowed || []).indexOf("to") >= 0, "cannot override to", "overrides.to", overrides.to); assertArgument(overrides.data == null || (allowed || []).indexOf("data") >= 0, "cannot override data", "overrides.data", overrides.data); // Resolve any from if (overrides.from) { overrides.from = await resolveAddress(overrides.from); } return overrides; } /** * @_ignore: */ export async function resolveArgs(_runner, inputs, args) { // Recursively descend into args and resolve any addresses const runner = getRunner(_runner, "resolveName"); const resolver = canResolve(runner) ? runner : null; return await Promise.all(inputs.map((param, index) => { return param.walkAsync(args[index], (type, value) => { value = Typed.dereference(value, type); if (type === "address") { return resolveAddress(value, resolver); } return value; }); })); } function buildWrappedFallback(contract) { const populateTransaction = async function (overrides) { // If an overrides was passed in, copy it and normalize the values const tx = (await copyOverrides(overrides, ["data"])); tx.to = await contract.getAddress(); const iface = contract.interface; // Only allow payable contracts to set non-zero value const payable = iface.receive || (iface.fallback && iface.fallback.payable); assertArgument(payable || (tx.value || BN_0) === BN_0, "cannot send value to non-payable contract", "overrides.value", tx.value); // Only allow fallback contracts to set non-empty data assertArgument(iface.fallback || (tx.data || "0x") === "0x", "cannot send data to receive-only contract", "overrides.data", tx.data); return tx; }; const staticCall = async function (overrides) { const runner = getRunner(contract.runner, "call"); assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" }); const tx = await populateTransaction(overrides); try { return await runner.call(tx); } catch (error) { if (isCallException(error) && error.data) { throw contract.interface.makeError(error.data, tx); } throw error; } }; const send = async function (overrides) { const runner = contract.runner; assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" }); const tx = await runner.sendTransaction(await populateTransaction(overrides)); const provider = getProvider(contract.runner); // @TODO: the provider can be null; make a custom dummy provider that will throw a // meaningful error return new ContractTransactionResponse(contract.interface, provider, tx); }; const estimateGas = async function (overrides) { const runner = getRunner(contract.runner, "estimateGas"); assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" }); return await runner.estimateGas(await populateTransaction(overrides)); }; const method = async (overrides) => { return await send(overrides); }; defineProperties(method, { _contract: contract, estimateGas, populateTransaction, send, staticCall }); return method; } function buildWrappedMethod(contract, key) { const getFragment = function (...args) { const fragment = contract.interface.getFunction(key, args); assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", { operation: "fragment" }); return fragment; }; const populateTransaction = async function (...args) { const fragment = getFragment(...args); // If an overrides was passed in, copy it and normalize the values let overrides = {}; if (fragment.inputs.length + 1 === args.length) { overrides = await copyOverrides(args.pop()); } if (fragment.inputs.length !== args.length) { throw new Error("internal error: fragment inputs doesn't match arguments; should not happen"); } const resolvedArgs = await resolveArgs(contract.runner, fragment.inputs, args); return Object.assign({}, overrides, await resolveProperties({ to: contract.getAddress(), data: contract.interface.encodeFunctionData(fragment, resolvedArgs) })); }; const staticCall = async function (...args) { const result = await staticCallResult(...args); if (result.length === 1) { return result[0]; } return result; }; const send = async function (...args) { const runner = contract.runner; assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" }); const tx = await runner.sendTransaction(await populateTransaction(...args)); const provider = getProvider(contract.runner); // @TODO: the provider can be null; make a custom dummy provider that will throw a // meaningful error return new ContractTransactionResponse(contract.interface, provider, tx); }; const estimateGas = async function (...args) { const runner = getRunner(contract.runner, "estimateGas"); assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" }); return await runner.estimateGas(await populateTransaction(...args)); }; const staticCallResult = async function (...args) { const runner = getRunner(contract.runner, "call"); assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" }); const tx = await populateTransaction(...args); let result = "0x"; try { result = await runner.call(tx); } catch (error) { if (isCallException(error) && error.data) { throw contract.interface.makeError(error.data, tx); } throw error; } const fragment = getFragment(...args); return contract.interface.decodeFunctionResult(fragment, result); }; const method = async (...args) => { const fragment = getFragment(...args); if (fragment.constant) { return await staticCall(...args); } return await send(...args); }; defineProperties(method, { name: contract.interface.getFunctionName(key), _contract: contract, _key: key, getFragment, estimateGas, populateTransaction, send, staticCall, staticCallResult, }); // Only works on non-ambiguous keys (refined fragment is always non-ambiguous) Object.defineProperty(method, "fragment", { configurable: false, enumerable: true, get: () => { const fragment = contract.interface.getFunction(key); assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", { operation: "fragment" }); return fragment; } }); return method; } function buildWrappedEvent(contract, key) { const getFragment = function (...args) { const fragment = contract.interface.getEvent(key, args); assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", { operation: "fragment" }); return fragment; }; const method = function (...args) { return new PreparedTopicFilter(contract, getFragment(...args), args); }; defineProperties(method, { name: contract.interface.getEventName(key), _contract: contract, _key: key, getFragment }); // Only works on non-ambiguous keys (refined fragment is always non-ambiguous) Object.defineProperty(method, "fragment", { configurable: false, enumerable: true, get: () => { const fragment = contract.interface.getEvent(key); assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", { operation: "fragment" }); return fragment; } }); return method; } // The combination of TypeScrype, Private Fields and Proxies makes // the world go boom; so we hide variables with some trickery keeping // a symbol attached to each BaseContract which its sub-class (even // via a Proxy) can reach and use to look up its internal values. const internal = Symbol.for("_ethersInternal_contract"); const internalValues = new WeakMap(); function setInternal(contract, values) { internalValues.set(contract[internal], values); } function getInternal(contract) { return internalValues.get(contract[internal]); } function isDeferred(value) { return (value && typeof (value) === "object" && ("getTopicFilter" in value) && (typeof (value.getTopicFilter) === "function") && value.fragment); } async function getSubInfo(contract, event) { let topics; let fragment = null; // Convert named events to topicHash and get the fragment for // events which need deconstructing. if (Array.isArray(event)) { const topicHashify = function (name) { if (isHexString(name, 32)) { return name; } const fragment = contract.interface.getEvent(name); assertArgument(fragment, "unknown fragment", "name", name); return fragment.topicHash; }; // Array of Topics and Names; e.g. `[ "0x1234...89ab", "Transfer(address)" ]` topics = event.map((e) => { if (e == null) { return null; } if (Array.isArray(e)) { return e.map(topicHashify); } return topicHashify(e); }); } else if (event === "*") { topics = [null]; } else if (typeof (event) === "string") { if (isHexString(event, 32)) { // Topic Hash topics = [event]; } else { // Name or Signature; e.g. `"Transfer", `"Transfer(address)"` fragment = contract.interface.getEvent(event); assertArgument(fragment, "unknown fragment", "event", event); topics = [fragment.topicHash]; } } else if (isDeferred(event)) { // Deferred Topic Filter; e.g. `contract.filter.Transfer(from)` topics = await event.getTopicFilter(); } else if ("fragment" in event) { // ContractEvent; e.g. `contract.filter.Transfer` fragment = event.fragment; topics = [fragment.topicHash]; } else { assertArgument(false, "unknown event name", "event", event); } // Normalize topics and sort TopicSets topics = topics.map((t) => { if (t == null) { return null; } if (Array.isArray(t)) { const items = Array.from(new Set(t.map((t) => t.toLowerCase())).values()); if (items.length === 1) { return items[0]; } items.sort(); return items; } return t.toLowerCase(); }); const tag = topics.map((t) => { if (t == null) { return "null"; } if (Array.isArray(t)) { return t.join("|"); } return t; }).join("&"); return { fragment, tag, topics }; } async function hasSub(contract, event) { const { subs } = getInternal(contract); return subs.get((await getSubInfo(contract, event)).tag) || null; } async function getSub(contract, operation, event) { // Make sure our runner can actually subscribe to events const provider = getProvider(contract.runner); assert(provider, "contract runner does not support subscribing", "UNSUPPORTED_OPERATION", { operation }); const { fragment, tag, topics } = await getSubInfo(contract, event); const { addr, subs } = getInternal(contract); let sub = subs.get(tag); if (!sub) { const address = (addr ? addr : contract); const filter = { address, topics }; const listener = (log) => { let foundFragment = fragment; if (foundFragment == null) { try { foundFragment = contract.interface.getEvent(log.topics[0]); } catch (error) { } } // If fragment is null, we do not deconstruct the args to emit if (foundFragment) { const _foundFragment = foundFragment; const args = fragment ? contract.interface.decodeEventLog(fragment, log.data, log.topics) : []; emit(contract, event, args, (listener) => { return new ContractEventPayload(contract, listener, event, _foundFragment, log); }); } else { emit(contract, event, [], (listener) => { return new ContractUnknownEventPayload(contract, listener, event, log); }); } }; let starting = []; const start = () => { if (starting.length) { return; } starting.push(provider.on(filter, listener)); }; const stop = async () => { if (starting.length == 0) { return; } let started = starting; starting = []; await Promise.all(started); provider.off(filter, listener); }; sub = { tag, listeners: [], start, stop }; subs.set(tag, sub); } return sub; } // We use this to ensure one emit resolves before firing the next to // ensure correct ordering (note this cannot throw and just adds the // notice to the event queu using setTimeout). let lastEmit = Promise.resolve(); async function _emit(contract, event, args, payloadFunc) { await lastEmit; const sub = await hasSub(contract, event); if (!sub) { return false; } const count = sub.listeners.length; sub.listeners = sub.listeners.filter(({ listener, once }) => { const passArgs = Array.from(args); if (payloadFunc) { passArgs.push(payloadFunc(once ? null : listener)); } try { listener.call(contract, ...passArgs); } catch (error) { } return !once; }); return (count > 0); } async function emit(contract, event, args, payloadFunc) { try { await lastEmit; } catch (error) { } const resultPromise = _emit(contract, event, args, payloadFunc); lastEmit = resultPromise; return await resultPromise; } const passProperties = ["then"]; export class BaseContract { target; interface; runner; filters; [internal]; fallback; constructor(target, abi, runner, _deployTx) { if (runner == null) { runner = null; } const iface = Interface.from(abi); defineProperties(this, { target, runner, interface: iface }); Object.defineProperty(this, internal, { value: {} }); let addrPromise; let addr = null; let deployTx = null; if (_deployTx) { const provider = getProvider(runner); // @TODO: the provider can be null; make a custom dummy provider that will throw a // meaningful error deployTx = new ContractTransactionResponse(this.interface, provider, _deployTx); } let subs = new Map(); // Resolve the target as the address if (typeof (target) === "string") { if (isHexString(target)) { addr = target; addrPromise = Promise.resolve(target); } else { const resolver = getRunner(runner, "resolveName"); if (!canResolve(resolver)) { throw makeError("contract runner does not support name resolution", "UNSUPPORTED_OPERATION", { operation: "resolveName" }); } addrPromise = resolver.resolveName(target).then((addr) => { if (addr == null) { throw new Error("TODO"); } getInternal(this).addr = addr; return addr; }); } } else { addrPromise = target.getAddress().then((addr) => { if (addr == null) { throw new Error("TODO"); } getInternal(this).addr = addr; return addr; }); } // Set our private values setInternal(this, { addrPromise, addr, deployTx, subs }); // Add the event filters const filters = new Proxy({}, { get: (target, _prop, receiver) => { // Pass important checks (like `then` for Promise) through if (passProperties.indexOf(_prop) >= 0) { return Reflect.get(target, _prop, receiver); } const prop = String(_prop); const result = this.getEvent(prop); if (result) { return result; } throw new Error(`unknown contract event: ${prop}`); }, has: (target, prop) => { // Pass important checks (like `then` for Promise) through if (passProperties.indexOf(prop) >= 0) { return Reflect.has(target, prop); } return Reflect.has(target, prop) || this.interface.hasEvent(String(prop)); } }); defineProperties(this, { filters }); defineProperties(this, { fallback: ((iface.receive || iface.fallback) ? (buildWrappedFallback(this)) : null) }); // Return a Proxy that will respond to functions return new Proxy(this, { get: (target, _prop, receiver) => { if (_prop in target || passProperties.indexOf(_prop) >= 0) { return Reflect.get(target, _prop, receiver); } const prop = String(_prop); const result = target.getFunction(prop); if (result) { return result; } throw new Error(`unknown contract method: ${prop}`); }, has: (target, prop) => { if (prop in target || passProperties.indexOf(prop) >= 0) { return Reflect.has(target, prop); } return target.interface.hasFunction(String(prop)); } }); } connect(runner) { return new BaseContract(this.target, this.interface, runner); } async getAddress() { return await getInternal(this).addrPromise; } async getDeployedCode() { const provider = getProvider(this.runner); assert(provider, "runner does not support .provider", "UNSUPPORTED_OPERATION", { operation: "getDeployedCode" }); const code = await provider.getCode(await this.getAddress()); if (code === "0x") { return null; } return code; } async waitForDeployment() { // We have the deployement transaction; just use that (throws if deployement fails) const deployTx = this.deploymentTransaction(); if (deployTx) { await deployTx.wait(); return this; } // Check for code const code = await this.getDeployedCode(); if (code != null) { return this; } // Make sure we can subscribe to a provider event const provider = getProvider(this.runner); assert(provider != null, "contract runner does not support .provider", "UNSUPPORTED_OPERATION", { operation: "waitForDeployment" }); return new Promise((resolve, reject) => { const checkCode = async () => { try { const code = await this.getDeployedCode(); if (code != null) { return resolve(this); } provider.once("block", checkCode); } catch (error) { reject(error); } }; checkCode(); }); } deploymentTransaction() { return getInternal(this).deployTx; } getFunction(key) { if (typeof (key) !== "string") { key = key.format(); } const func = buildWrappedMethod(this, key); return func; } getEvent(key) { if (typeof (key) !== "string") { key = key.format(); } return buildWrappedEvent(this, key); } async queryTransaction(hash) { // Is this useful? throw new Error("@TODO"); } async queryFilter(event, fromBlock, toBlock) { if (fromBlock == null) { fromBlock = 0; } if (toBlock == null) { toBlock = "latest"; } const { addr, addrPromise } = getInternal(this); const address = (addr ? addr : (await addrPromise)); const { fragment, topics } = await getSubInfo(this, event); const filter = { address, topics, fromBlock, toBlock }; const provider = getProvider(this.runner); assert(provider, "contract runner does not have a provider", "UNSUPPORTED_OPERATION", { operation: "queryFilter" }); return (await provider.getLogs(filter)).map((log) => { let foundFragment = fragment; if (foundFragment == null) { try { foundFragment = this.interface.getEvent(log.topics[0]); } catch (error) { } } if (foundFragment) { return new EventLog(log, this.interface, foundFragment); } else { return new Log(log, provider); } }); } async on(event, listener) { const sub = await getSub(this, "on", event); sub.listeners.push({ listener, once: false }); sub.start(); return this; } async once(event, listener) { const sub = await getSub(this, "once", event); sub.listeners.push({ listener, once: true }); sub.start(); return this; } async emit(event, ...args) { return await emit(this, event, args, null); } async listenerCount(event) { if (event) { const sub = await hasSub(this, event); if (!sub) { return 0; } return sub.listeners.length; } const { subs } = getInternal(this); let total = 0; for (const { listeners } of subs.values()) { total += listeners.length; } return total; } async listeners(event) { if (event) { const sub = await hasSub(this, event); if (!sub) { return []; } return sub.listeners.map(({ listener }) => listener); } const { subs } = getInternal(this); let result = []; for (const { listeners } of subs.values()) { result = result.concat(listeners.map(({ listener }) => listener)); } return result; } async off(event, listener) { const sub = await hasSub(this, event); if (!sub) { return this; } if (listener) { const index = sub.listeners.map(({ listener }) => listener).indexOf(listener); if (index >= 0) { sub.listeners.splice(index, 1); } } if (listener == null || sub.listeners.length === 0) { sub.stop(); getInternal(this).subs.delete(sub.tag); } return this; } async removeAllListeners(event) { if (event) { const sub = await hasSub(this, event); if (!sub) { return this; } sub.stop(); getInternal(this).subs.delete(sub.tag); } else { const { subs } = getInternal(this); for (const { tag, stop } of subs.values()) { stop(); subs.delete(tag); } } return this; } // Alias for "on" async addListener(event, listener) { return await this.on(event, listener); } // Alias for "off" async removeListener(event, listener) { return await this.off(event, listener); } static buildClass(abi) { class CustomContract extends BaseContract { constructor(address, runner = null) { super(address, abi, runner); } } return CustomContract; } ; static from(target, abi, runner) { if (runner == null) { runner = null; } const contract = new this(target, abi, runner); return contract; } } function _ContractBase() { return BaseContract; } export class Contract extends _ContractBase() { } //# sourceMappingURL=contract.js.map