File Manager

Editing File: /home/ubuntu/walnutminds-ecom-frontend-base/node_modules/wagmi/dist/wagmi.cjs.prod.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var querySyncStoragePersister = require('@tanstack/query-sync-storage-persister');
var reactQuery = require('@tanstack/react-query');
var reactQueryPersistClient = require('@tanstack/react-query-persist-client');
var core = require('@wagmi/core');
var React = require('react');
var pkg = require('use-sync-external-store/shim/index.js');
var ethers = require('ethers/lib/ethers');
var withSelector_js = require('use-sync-external-store/shim/with-selector.js');

var React__namespace = /*#__PURE__*/_interopNamespace(React);
var pkg__namespace = /*#__PURE__*/_interopNamespace(pkg);

const useSyncExternalStore = pkg__namespace.useSyncExternalStore;

function isQueryKey(value) {
  return Array.isArray(value);
}

function parseQueryArgs(arg1, arg2, arg3) {
  if (!isQueryKey(arg1)) {
    return arg1;
  }

if (typeof arg2 === 'function') {
    return { ...arg3,
      queryKey: arg1,
      queryFn: arg2
    };
  }

return { ...arg2,
    queryKey: arg1
  };
}
function shouldThrowError(_useErrorBoundary, params) {
  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
  if (typeof _useErrorBoundary === 'function') {
    return _useErrorBoundary(...params);
  }

return !!_useErrorBoundary;
}
function trackResult(result, observer) {
  const trackedResult = {};
  Object.keys(result).forEach(key => {
    Object.defineProperty(trackedResult, key, {
      configurable: false,
      enumerable: true,
      get: () => {
        // @ts-expect-error – aware we are mutating private `trackedProps` property.
        observer.trackedProps.add(key);
        return result[key];
      }
    });
  });
  return trackedResult;
}

function useBaseQuery(options, Observer) {
  const queryClient = reactQuery.useQueryClient({
    context: options.context
  });
  const isRestoring = reactQuery.useIsRestoring();
  const errorResetBoundary = reactQuery.useQueryErrorResetBoundary();
  const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options

defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic'; // Include callbacks in batch renders

if (defaultedOptions.onError) {
    defaultedOptions.onError = reactQuery.notifyManager.batchCalls(defaultedOptions.onError);
  }

if (defaultedOptions.onSuccess) {
    defaultedOptions.onSuccess = reactQuery.notifyManager.batchCalls(defaultedOptions.onSuccess);
  }

if (defaultedOptions.onSettled) {
    defaultedOptions.onSettled = reactQuery.notifyManager.batchCalls(defaultedOptions.onSettled);
  }

if (defaultedOptions.suspense) {
    // Always set stale time when using suspense to prevent
    // fetching again when directly mounting after suspending
    if (typeof defaultedOptions.staleTime !== 'number') {
      defaultedOptions.staleTime = 1000;
    }
  }

if (defaultedOptions.suspense || defaultedOptions.useErrorBoundary) {
    // Prevent retrying failed query if the error boundary has not been reset yet
    if (!errorResetBoundary.isReset()) {
      defaultedOptions.retryOnMount = false;
    }
  }

const [observer] = React__namespace.useState(() => new Observer(queryClient, defaultedOptions));
  const result = observer.getOptimisticResult(defaultedOptions);
  useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(reactQuery.notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
  React__namespace.useEffect(() => {
    errorResetBoundary.clearReset();
  }, [errorResetBoundary]);
  React__namespace.useEffect(() => {
    // Do not notify on updates because of changes in the options because
    // these changes should already be reflected in the optimistic result.
    observer.setOptions(defaultedOptions, {
      listeners: false
    });
  }, [defaultedOptions, observer]); // Handle suspense

if (defaultedOptions.suspense && result.isLoading && result.isFetching && !isRestoring) {
    throw observer.fetchOptimistic(defaultedOptions).then(_ref => {
      var _defaultedOptions$onS, _defaultedOptions$onS2;

let {
        data
      } = _ref;
      (_defaultedOptions$onS = defaultedOptions.onSuccess) === null || _defaultedOptions$onS === void 0 ? void 0 : _defaultedOptions$onS.call(defaultedOptions, data);
      (_defaultedOptions$onS2 = defaultedOptions.onSettled) === null || _defaultedOptions$onS2 === void 0 ? void 0 : _defaultedOptions$onS2.call(defaultedOptions, data, null);
    }).catch(error => {
      var _defaultedOptions$onE, _defaultedOptions$onS3;

errorResetBoundary.clearReset();
      (_defaultedOptions$onE = defaultedOptions.onError) === null || _defaultedOptions$onE === void 0 ? void 0 : _defaultedOptions$onE.call(defaultedOptions, error);
      (_defaultedOptions$onS3 = defaultedOptions.onSettled) === null || _defaultedOptions$onS3 === void 0 ? void 0 : _defaultedOptions$onS3.call(defaultedOptions, undefined, error);
    });
  } // Handle error boundary

if (result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(defaultedOptions.useErrorBoundary, [result.error, observer.getCurrentQuery()])) {
    throw result.error;
  }

const status = result.status === 'loading' && result.fetchStatus === 'idle' ? 'idle' : result.status;
  const isIdle = status === 'idle';
  const isLoading = status === 'loading' && result.fetchStatus === 'fetching';
  return { ...result,
    defaultedOptions,
    isIdle,
    isLoading,
    observer,
    status
  };
}

function useInfiniteQuery(arg1, arg2, arg3) {
  const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
  const baseQuery = useBaseQuery(parsedOptions, reactQuery.InfiniteQueryObserver);
  const result = {
    data: baseQuery.data,
    error: baseQuery.error,
    fetchNextPage: baseQuery.fetchNextPage,
    fetchStatus: baseQuery.fetchStatus,
    hasNextPage: baseQuery.hasNextPage,
    isError: baseQuery.isError,
    isFetched: baseQuery.isFetched,
    isFetching: baseQuery.isFetching,
    isFetchingNextPage: baseQuery.isFetchingNextPage,
    isIdle: baseQuery.isIdle,
    isLoading: baseQuery.isLoading,
    isRefetching: baseQuery.isRefetching,
    isSuccess: baseQuery.isSuccess,
    refetch: baseQuery.refetch,
    status: baseQuery.status,
    internal: {
      dataUpdatedAt: baseQuery.dataUpdatedAt,
      errorUpdatedAt: baseQuery.errorUpdatedAt,
      failureCount: baseQuery.failureCount,
      isFetchedAfterMount: baseQuery.isFetchedAfterMount,
      isLoadingError: baseQuery.isLoadingError,
      isPaused: baseQuery.isPaused,
      isPlaceholderData: baseQuery.isPlaceholderData,
      isPreviousData: baseQuery.isPreviousData,
      isRefetchError: baseQuery.isRefetchError,
      isStale: baseQuery.isStale,
      remove: baseQuery.remove
    }
  }; // Handle result property usage tracking

return !baseQuery.defaultedOptions.notifyOnChangeProps ? trackResult(result, baseQuery.observer) : result;
}

function useQuery(arg1, arg2, arg3) {
  const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
  const baseQuery = useBaseQuery(parsedOptions, reactQuery.QueryObserver);
  const result = {
    data: baseQuery.data,
    error: baseQuery.error,
    fetchStatus: baseQuery.fetchStatus,
    isError: baseQuery.isError,
    isFetched: baseQuery.isFetched,
    isFetching: baseQuery.isFetching,
    isIdle: baseQuery.isIdle,
    isLoading: baseQuery.isLoading,
    isRefetching: baseQuery.isRefetching,
    isSuccess: baseQuery.isSuccess,
    refetch: baseQuery.refetch,
    status: baseQuery.status,
    internal: {
      dataUpdatedAt: baseQuery.dataUpdatedAt,
      errorUpdatedAt: baseQuery.errorUpdatedAt,
      failureCount: baseQuery.failureCount,
      isFetchedAfterMount: baseQuery.isFetchedAfterMount,
      isLoadingError: baseQuery.isLoadingError,
      isPaused: baseQuery.isPaused,
      isPlaceholderData: baseQuery.isPlaceholderData,
      isPreviousData: baseQuery.isPreviousData,
      isRefetchError: baseQuery.isRefetchError,
      isStale: baseQuery.isStale,
      remove: baseQuery.remove
    }
  }; // Handle result property usage tracking

return !baseQuery.defaultedOptions.notifyOnChangeProps ? trackResult(result, baseQuery.observer) : result;
}

function useProvider() {
  let {
    chainId
  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return withSelector_js.useSyncExternalStoreWithSelector(cb => core.watchProvider({
    chainId
  }, cb), () => core.getProvider({
    chainId
  }), () => core.getProvider({
    chainId
  }), x => x, (a, b) => a.network.chainId === b.network.chainId);
}

function useWebSocketProvider() {
  let {
    chainId
  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return withSelector_js.useSyncExternalStoreWithSelector(cb => core.watchWebSocketProvider({
    chainId
  }, cb), () => core.getWebSocketProvider({
    chainId
  }), () => core.getWebSocketProvider({
    chainId
  }), x => x, (a, b) => (a === null || a === void 0 ? void 0 : a.network.chainId) === (b === null || b === void 0 ? void 0 : b.network.chainId));
}

function useForceUpdate() {
  const [, forceUpdate] = React__namespace.useReducer(x => x + 1, 0);
  return forceUpdate;
}

const queryKey$f = _ref => {
  let {
    chainId
  } = _ref;
  return [{
    entity: 'blockNumber',
    chainId
  }];
};

const queryFn$f = _ref2 => {
  let {
    queryKey: [{
      chainId
    }]
  } = _ref2;
  return core.fetchBlockNumber({
    chainId
  });
};

const listener = blockNumber => {
      // Just to be safe in case the provider implementation
      // calls the event callback after .off() has been called
      if (watch) queryClient.setQueryData(queryKey$f({
        chainId
      }), blockNumber);
      if (onBlock) onBlock(blockNumber);
    };

const queryKey$e = _ref => {
  let {
    chainId,
    formatUnits
  } = _ref;
  return [{
    entity: 'feeData',
    chainId,
    formatUnits
  }];
};

const queryFn$e = _ref2 => {
  let {
    queryKey: [{
      chainId,
      formatUnits
    }]
  } = _ref2;
  return core.fetchFeeData({
    chainId,
    formatUnits
  });
};

const isPlainObject = obj => typeof obj === 'object' && !Array.isArray(obj);

function useSyncExternalStoreWithTracked(subscribe, getSnapshot) {
  let getServerSnapshot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : getSnapshot;
  let isEqual = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : (a, b) => core.deepEqual(a, b);
  const trackedKeys = React__namespace.useRef([]);
  const result = withSelector_js.useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, x => x, (a, b) => {
    if (isPlainObject(a) && isPlainObject(b)) {
      for (const key of trackedKeys.current) {
        const equal = isEqual(a[key], b[key]);
        if (!equal) return false;
      }

return true;
    }

return isEqual(a, b);
  });

if (isPlainObject(result)) {
    const trackedResult = { ...result
    };
    Object.defineProperties(trackedResult, Object.entries(trackedResult).reduce((res, _ref) => {
      let [key, value] = _ref;
      return { ...res,
        [key]: {
          configurable: false,
          enumerable: true,
          get: () => {
            if (!trackedKeys.current.includes(key)) {
              trackedKeys.current.push(key);
            }

return value;
          }
        }
      };
    }, {}));
    return trackedResult;
  }

return result;
}

const queryKey$d = () => [{
  entity: 'signer'
}];

const queryFn$d = () => core.fetchSigner();

const findAndReplace = (cacheRef, _ref) => {
  let {
    find,
    replace
  } = _ref;

if (cacheRef && find(cacheRef)) {
    return replace(cacheRef);
  }

if (typeof cacheRef !== 'object') {
    return cacheRef;
  }

if (Array.isArray(cacheRef)) {
    return cacheRef.map(item => findAndReplace(item, {
      find,
      replace
    }));
  }

if (cacheRef instanceof Object) {
    return Object.entries(cacheRef).reduce((curr, _ref2) => {
      let [key, value] = _ref2;
      return { ...curr,
        [key]: findAndReplace(value, {
          find,
          replace
        })
      };
    }, {});
  }

return cacheRef;
};

function deserialize(cachedString) {
  const cache = JSON.parse(cachedString);
  const deserializedCacheWithBigNumbers = findAndReplace(cache, {
    find: data => data.type === 'BigNumber',
    replace: data => ethers.BigNumber.from(data.hex)
  });
  return deserializedCacheWithBigNumbers;
}

/**
 * @function getReferenceKey
 *
 * @description
 * get the reference key for the circular value
 *
 * @param keys the keys to build the reference key from
 * @param cutoff the maximum number of keys to include
 * @returns the reference key
 */
function getReferenceKey(keys, cutoff) {
  return keys.slice(0, cutoff).join('.') || '.';
}
/**
 * @function getCutoff
 *
 * @description
 * faster `Array.prototype.indexOf` implementation build for slicing / splicing
 *
 * @param array the array to match the value in
 * @param value the value to match
 * @returns the matching index, or -1
 */

function getCutoff(array, value) {
  const {
    length
  } = array;

for (let index = 0; index < length; ++index) {
    if (array[index] === value) {
      return index + 1;
    }
  }

return 0;
}

/**
 * @function createReplacer
 *
 * @description
 * create a replacer method that handles circular values
 *
 * @param [replacer] a custom replacer to use for non-circular values
 * @param [circularReplacer] a custom replacer to use for circular methods
 * @returns the value to stringify
 */
function createReplacer(replacer, circularReplacer) {
  const hasReplacer = typeof replacer === 'function';
  const hasCircularReplacer = typeof circularReplacer === 'function';
  const cache = [];
  const keys = [];
  return function replace(key, value) {
    if (typeof value === 'object') {
      if (cache.length) {
        const thisCutoff = getCutoff(cache, this);

if (thisCutoff === 0) {
          cache[cache.length] = this;
        } else {
          cache.splice(thisCutoff);
          keys.splice(thisCutoff);
        }

keys[keys.length] = key;
        const valueCutoff = getCutoff(cache, value);

if (valueCutoff !== 0) {
          return hasCircularReplacer ? circularReplacer.call(this, key, value, getReferenceKey(keys, valueCutoff)) : "[ref=".concat(getReferenceKey(keys, valueCutoff), "]");
        }
      } else {
        cache[0] = value;
        keys[0] = key;
      }
    }

return hasReplacer ? replacer.call(this, key, value) : value;
  };
}
/**
 * @function stringify
 *
 * @description
 * stringifier that handles circular values
 * Forked from https://github.com/planttheidea/fast-stringify
 *
 * @param value to stringify
 * @param [replacer] a custom replacer function for handling standard values
 * @param [indent] the number of spaces to indent the output by
 * @param [circularReplacer] a custom replacer function for handling circular values
 * @returns the stringified output
 */

function serialize(value, replacer, indent, circularReplacer) {
  return JSON.stringify(value, createReplacer(replacer, circularReplacer), indent !== null && indent !== void 0 ? indent : undefined);
}

const unsubscribe = subscribe(state => state.status, (status, prevStatus) => {
      if (!!onConnect && status === 'connected') {
        const {
          address,
          connector
        } = core.getAccount();
        onConnect({
          address,
          connector,
          isReconnected: prevStatus === 'reconnecting'
        });
      }

if (!!onDisconnect && prevStatus !== 'connecting' && status === 'disconnected') onDisconnect();
    });
    return unsubscribe;
  }, [onConnect, onDisconnect, subscribe]);
  return account;
}

const mutationKey$8 = args => [{
  entity: 'connect',
  ...args
}];

const mutationFn$7 = args => {
  const {
    connector,
    chainId
  } = args;
  if (!connector) throw new Error('connector is required');
  return core.connect({
    connector,
    chainId
  });
};

return mutate({
      chainId: (_args$chainId = args === null || args === void 0 ? void 0 : args.chainId) !== null && _args$chainId !== void 0 ? _args$chainId : chainId,
      connector: (_args$connector = args === null || args === void 0 ? void 0 : args.connector) !== null && _args$connector !== void 0 ? _args$connector : connector
    });
  }, [chainId, connector, mutate]);
  const connectAsync = React__namespace.useCallback(args => {
    var _args$chainId2, _args$connector2;

return mutateAsync({
      chainId: (_args$chainId2 = args === null || args === void 0 ? void 0 : args.chainId) !== null && _args$chainId2 !== void 0 ? _args$chainId2 : chainId,
      connector: (_args$connector2 = args === null || args === void 0 ? void 0 : args.connector) !== null && _args$connector2 !== void 0 ? _args$connector2 : connector
    });
  }, [chainId, connector, mutateAsync]);
  return {
    connect,
    connectAsync,
    connectors: client.connectors,
    data,
    error,
    isError,
    isIdle,
    isLoading,
    isSuccess,
    pendingConnector: variables === null || variables === void 0 ? void 0 : variables.connector,
    reset,
    status,
    variables
  };
}

const mutationKey$7 = [{
  entity: 'disconnect'
}];

const mutationFn$6 = () => core.disconnect();

function useDisconnect() {
  let {
    onError,
    onMutate,
    onSettled,
    onSuccess
  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  const {
    error,
    isError,
    isIdle,
    isLoading,
    isSuccess,
    mutate: disconnect,
    mutateAsync: disconnectAsync,
    reset,
    status
  } = reactQuery.useMutation(mutationKey$7, mutationFn$6, { ...(onError ? {
      onError(error, _variables, context) {
        onError(error, context);
      }

} : {}),
    onMutate,
    ...(onSettled ? {
      onSettled(_data, error, _variables, context) {
        onSettled(error, context);
      }

} : {}),
    ...(onSuccess ? {
      onSuccess(_data, _variables, context) {
        onSuccess(context);
      }

} : {})
  });
  return {
    disconnect,
    disconnectAsync,
    error,
    isError,
    isIdle,
    isLoading,
    isSuccess,
    reset,
    status
  };
}

function useNetwork() {
  return useSyncExternalStoreWithTracked(core.watchNetwork, core.getNetwork);
}

const mutationKey$6 = args => [{
  entity: 'signMessage',
  ...args
}];

const mutationFn$5 = args => {
  const {
    message
  } = args;
  if (!message) throw new Error('message is required');
  return core.signMessage({
    message
  });
};

const mutationKey$5 = args => [{
  entity: 'signTypedData',
  ...args
}];

const mutationKey$4 = args => [{
  entity: 'switchNetwork',
  ...args
}];

const mutationFn$3 = args => {
  const {
    chainId
  } = args;
  if (!chainId) throw new Error('chainId is required');
  return core.switchNetwork({
    chainId
  });
};

function useSwitchNetwork() {
  var _client$connector, _client$chains;

let {
    chainId,
    throwForSwitchChainNotSupported,
    onError,
    onMutate,
    onSettled,
    onSuccess
  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  const client = useClient();
  const forceUpdate = useForceUpdate();
  const {
    data,
    error,
    isError,
    isIdle,
    isLoading,
    isSuccess,
    mutate,
    mutateAsync,
    reset,
    status,
    variables
  } = reactQuery.useMutation(mutationKey$4({
    chainId
  }), mutationFn$3, {
    onError,
    onMutate,
    onSettled,
    onSuccess
  });
  const switchNetwork_ = React__namespace.useCallback(chainId_ => mutate({
    chainId: chainId_ !== null && chainId_ !== void 0 ? chainId_ : chainId
  }), [chainId, mutate]);
  const switchNetworkAsync_ = React__namespace.useCallback(chainId_ => mutateAsync({
    chainId: chainId_ !== null && chainId_ !== void 0 ? chainId_ : chainId
  }), [chainId, mutateAsync]); // Trigger update when connector changes since not all connectors support chain switching

React__namespace.useEffect(() => {
    const unwatch = client.subscribe(_ref => {
      let {
        chains,
        connector
      } = _ref;
      return {
        chains,
        connector
      };
    }, forceUpdate);
    return unwatch;
  }, [client, forceUpdate]);
  let switchNetwork;
  let switchNetworkAsync;
  const supportsSwitchChain = !!((_client$connector = client.connector) !== null && _client$connector !== void 0 && _client$connector.switchChain);

if (throwForSwitchChainNotSupported || supportsSwitchChain) {
    switchNetwork = switchNetwork_;
    switchNetworkAsync = switchNetworkAsync_;
  }

return {
    chains: (_client$chains = client.chains) !== null && _client$chains !== void 0 ? _client$chains : [],
    data,
    error,
    isError,
    isIdle,
    isLoading,
    isSuccess,
    pendingChainId: variables === null || variables === void 0 ? void 0 : variables.chainId,
    reset,
    status,
    switchNetwork,
    switchNetworkAsync,
    variables
  };
}

const useContractEvent = _ref => {
  var _ref2;

let {
    addressOrName,
    chainId,
    contractInterface,
    listener,
    eventName,
    signerOrProvider,
    once
  } = _ref;
  const provider = useProvider({
    chainId
  });
  const webSocketProvider = useWebSocketProvider({
    chainId
  });
  const contract = useContract({
    addressOrName,
    contractInterface,
    signerOrProvider: (_ref2 = webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider) !== null && _ref2 !== void 0 ? _ref2 : signerOrProvider
  });
  const listenerRef = React__namespace.useRef(listener);
  listenerRef.current = listener;
  React__namespace.useEffect(() => {
    const handler = function () {
      for (var _len = arguments.length, event = new Array(_len), _key = 0; _key < _len; _key++) {
        event[_key] = arguments[_key];
      }

return listenerRef.current(event);
    };

const contract_ = contract;
    if (once) contract_.once(eventName, handler);else contract_.on(eventName, handler);
    return () => {
      contract_.off(eventName, handler);
    }; // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [contract, eventName]);
};

const queryFn$a = _ref2 => {
  let {
    contractInterface
  } = _ref2;
  return async _ref3 => {
    var _await$readContract;

let {
      queryKey: [{
        addressOrName,
        args,
        chainId,
        functionName,
        overrides
      }]
    } = _ref3;
    return (_await$readContract = await core.readContract({
      addressOrName,
      args,
      chainId,
      contractInterface,
      functionName,
      overrides
    })) !== null && _await$readContract !== void 0 ? _await$readContract : null;
  };
};

return contracts[i] ? core.parseContractResult({
          contractInterface: (_contracts$i = contracts[i]) === null || _contracts$i === void 0 ? void 0 : _contracts$i.contractInterface,
          functionName: (_contracts$i2 = contracts[i]) === null || _contracts$i2 === void 0 ? void 0 : _contracts$i2.functionName,
          data
        }) : data;
      });
      return select ? select(result) : result;
    },
    suspense,
    onError,
    onSettled,
    onSuccess
  });
}

return mutate({
      addressOrName,
      args: (_overrideConfig$reckl = overrideConfig === null || overrideConfig === void 0 ? void 0 : overrideConfig.recklesslySetUnpreparedArgs) !== null && _overrideConfig$reckl !== void 0 ? _overrideConfig$reckl : args,
      chainId,
      contractInterface,
      functionName,
      mode: overrideConfig ? 'recklesslyUnprepared' : mode,
      overrides: (_overrideConfig$reckl2 = overrideConfig === null || overrideConfig === void 0 ? void 0 : overrideConfig.recklesslySetUnpreparedOverrides) !== null && _overrideConfig$reckl2 !== void 0 ? _overrideConfig$reckl2 : overrides,
      request
    });
  }, [addressOrName, args, chainId, contractInterface, functionName, mode, mutate, overrides, request]);
  const writeAsync = React__namespace.useCallback(overrideConfig => {
    var _overrideConfig$reckl3, _overrideConfig$reckl4;

return mutateAsync({
      addressOrName,
      args: (_overrideConfig$reckl3 = overrideConfig === null || overrideConfig === void 0 ? void 0 : overrideConfig.recklesslySetUnpreparedArgs) !== null && _overrideConfig$reckl3 !== void 0 ? _overrideConfig$reckl3 : args,
      chainId,
      contractInterface,
      functionName,
      mode: overrideConfig ? 'recklesslyUnprepared' : mode,
      overrides: (_overrideConfig$reckl4 = overrideConfig === null || overrideConfig === void 0 ? void 0 : overrideConfig.recklesslySetUnpreparedOverrides) !== null && _overrideConfig$reckl4 !== void 0 ? _overrideConfig$reckl4 : overrides,
      request
    });
  }, [addressOrName, args, chainId, contractInterface, functionName, mode, mutateAsync, overrides, request]);
  return {
    data,
    error,
    isError,
    isIdle,
    isLoading,
    isSuccess,
    reset,
    status,
    variables,
    write: mode === 'prepared' && !request ? undefined : write,
    writeAsync: mode === 'prepared' && !request ? undefined : writeAsync
  };
}

const queryKey$7 = _ref => {
  let {
    address,
    chainId,
    formatUnits
  } = _ref;
  return [{
    entity: 'token',
    address,
    chainId,
    formatUnits
  }];
};

const queryKey$6 = _ref => {
  let {
    chainId,
    name
  } = _ref;
  return [{
    entity: 'ensAddress',
    chainId,
    name
  }];
};

const queryKey$5 = _ref => {
  let {
    addressOrName,
    chainId
  } = _ref;
  return [{
    entity: 'ensAvatar',
    addressOrName,
    chainId
  }];
};

const queryKey$4 = _ref => {
  let {
    address,
    chainId
  } = _ref;
  return [{
    entity: 'ensName',
    address,
    chainId
  }];
};

const queryKey$3 = _ref => {
  let {
    chainId,
    name
  } = _ref;
  return [{
    entity: 'ensResolver',
    chainId,
    name
  }];
};

const mutationKey$1 = args => [{
  entity: 'sendTransaction',
  ...args
}];

const queryKey$2 = _ref => {
  let {
    chainId,
    request
  } = _ref;
  return [{
    entity: 'prepareSendTransaction',
    chainId,
    request
  }];
};

const mutationKey = args => [{
  entity: 'sendTransaction',
  ...args
}];

return mutate({
      chainId,
      mode,
      request: (_args$recklesslySetUn = args === null || args === void 0 ? void 0 : args.recklesslySetUnpreparedRequest) !== null && _args$recklesslySetUn !== void 0 ? _args$recklesslySetUn : request
    });
  }, [chainId, mode, mutate, request]);
  const sendTransactionAsync = React__namespace.useCallback(args => {
    var _args$recklesslySetUn2;

return mutateAsync({
      chainId,
      mode,
      request: (_args$recklesslySetUn2 = args === null || args === void 0 ? void 0 : args.recklesslySetUnpreparedRequest) !== null && _args$recklesslySetUn2 !== void 0 ? _args$recklesslySetUn2 : request
    });
  }, [chainId, mode, mutateAsync, request]);
  return {
    data,
    error,
    isError,
    isIdle,
    isLoading,
    isSuccess,
    reset,
    sendTransaction: mode === 'prepared' && !request ? undefined : sendTransaction,
    sendTransactionAsync: mode === 'prepared' && !request ? undefined : sendTransactionAsync,
    status,
    variables
  };
}

const queryKey$1 = _ref => {
  let {
    chainId,
    hash
  } = _ref;
  return [{
    entity: 'transaction',
    chainId,
    hash
  }];
};

Object.defineProperty(exports, 'AddChainError', {
  enumerable: true,
  get: function () { return core.AddChainError; }
});
Object.defineProperty(exports, 'ChainDoesNotSupportMulticallError', {
  enumerable: true,
  get: function () { return core.ChainDoesNotSupportMulticallError; }
});
Object.defineProperty(exports, 'ChainMismatchError', {
  enumerable: true,
  get: function () { return core.ChainMismatchError; }
});
Object.defineProperty(exports, 'ChainNotConfiguredError', {
  enumerable: true,
  get: function () { return core.ChainNotConfiguredError; }
});
Object.defineProperty(exports, 'Client', {
  enumerable: true,
  get: function () { return core.Client; }
});
Object.defineProperty(exports, 'Connector', {
  enumerable: true,
  get: function () { return core.Connector; }
});
Object.defineProperty(exports, 'ConnectorAlreadyConnectedError', {
  enumerable: true,
  get: function () { return core.ConnectorAlreadyConnectedError; }
});
Object.defineProperty(exports, 'ConnectorNotFoundError', {
  enumerable: true,
  get: function () { return core.ConnectorNotFoundError; }
});
Object.defineProperty(exports, 'ContractMethodDoesNotExistError', {
  enumerable: true,
  get: function () { return core.ContractMethodDoesNotExistError; }
});
Object.defineProperty(exports, 'ContractMethodNoResultError', {
  enumerable: true,
  get: function () { return core.ContractMethodNoResultError; }
});
Object.defineProperty(exports, 'ContractMethodRevertedError', {
  enumerable: true,
  get: function () { return core.ContractMethodRevertedError; }
});
Object.defineProperty(exports, 'ContractResultDecodeError', {
  enumerable: true,
  get: function () { return core.ContractResultDecodeError; }
});
Object.defineProperty(exports, 'ProviderChainsNotFound', {
  enumerable: true,
  get: function () { return core.ProviderChainsNotFound; }
});
Object.defineProperty(exports, 'ProviderRpcError', {
  enumerable: true,
  get: function () { return core.ProviderRpcError; }
});
Object.defineProperty(exports, 'ResourceUnavailableError', {
  enumerable: true,
  get: function () { return core.ResourceUnavailableError; }
});
Object.defineProperty(exports, 'RpcError', {
  enumerable: true,
  get: function () { return core.RpcError; }
});
Object.defineProperty(exports, 'SwitchChainError', {
  enumerable: true,
  get: function () { return core.SwitchChainError; }
});
Object.defineProperty(exports, 'SwitchChainNotSupportedError', {
  enumerable: true,
  get: function () { return core.SwitchChainNotSupportedError; }
});
Object.defineProperty(exports, 'UserRejectedRequestError', {
  enumerable: true,
  get: function () { return core.UserRejectedRequestError; }
});
Object.defineProperty(exports, 'alchemyRpcUrls', {
  enumerable: true,
  get: function () { return core.alchemyRpcUrls; }
});
Object.defineProperty(exports, 'allChains', {
  enumerable: true,
  get: function () { return core.allChains; }
});
Object.defineProperty(exports, 'chain', {
  enumerable: true,
  get: function () { return core.chain; }
});
Object.defineProperty(exports, 'chainId', {
  enumerable: true,
  get: function () { return core.chainId; }
});
Object.defineProperty(exports, 'configureChains', {
  enumerable: true,
  get: function () { return core.configureChains; }
});
Object.defineProperty(exports, 'createStorage', {
  enumerable: true,
  get: function () { return core.createStorage; }
});
Object.defineProperty(exports, 'deepEqual', {
  enumerable: true,
  get: function () { return core.deepEqual; }
});
Object.defineProperty(exports, 'defaultChains', {
  enumerable: true,
  get: function () { return core.defaultChains; }
});
Object.defineProperty(exports, 'defaultL2Chains', {
  enumerable: true,
  get: function () { return core.defaultL2Chains; }
});
Object.defineProperty(exports, 'erc20ABI', {
  enumerable: true,
  get: function () { return core.erc20ABI; }
});
Object.defineProperty(exports, 'erc721ABI', {
  enumerable: true,
  get: function () { return core.erc721ABI; }
});
Object.defineProperty(exports, 'etherscanBlockExplorers', {
  enumerable: true,
  get: function () { return core.etherscanBlockExplorers; }
});
Object.defineProperty(exports, 'infuraRpcUrls', {
  enumerable: true,
  get: function () { return core.infuraRpcUrls; }
});
Object.defineProperty(exports, 'publicRpcUrls', {
  enumerable: true,
  get: function () { return core.publicRpcUrls; }
});
Object.defineProperty(exports, 'readContracts', {
  enumerable: true,
  get: function () { return core.readContracts; }
});
exports.Context = Context;
exports.WagmiConfig = WagmiConfig;
exports.createClient = createClient;
exports.deserialize = deserialize;
exports.paginatedIndexesConfig = paginatedIndexesConfig;
exports.serialize = serialize;
exports.useAccount = useAccount;
exports.useBalance = useBalance;
exports.useBlockNumber = useBlockNumber;
exports.useClient = useClient;
exports.useConnect = useConnect;
exports.useContract = useContract;
exports.useContractEvent = useContractEvent;
exports.useContractInfiniteReads = useContractInfiniteReads;
exports.useContractRead = useContractRead;
exports.useContractReads = useContractReads;
exports.useContractWrite = useContractWrite;
exports.useDeprecatedContractWrite = useDeprecatedContractWrite;
exports.useDeprecatedSendTransaction = useDeprecatedSendTransaction;
exports.useDisconnect = useDisconnect;
exports.useEnsAddress = useEnsAddress;
exports.useEnsAvatar = useEnsAvatar;
exports.useEnsName = useEnsName;
exports.useEnsResolver = useEnsResolver;
exports.useFeeData = useFeeData;
exports.useInfiniteQuery = useInfiniteQuery;
exports.useNetwork = useNetwork;
exports.usePrepareContractWrite = usePrepareContractWrite;
exports.usePrepareSendTransaction = usePrepareSendTransaction;
exports.useProvider = useProvider;
exports.useQuery = useQuery;
exports.useSendTransaction = useSendTransaction;
exports.useSignMessage = useSignMessage;
exports.useSignTypedData = useSignTypedData;
exports.useSigner = useSigner;
exports.useSwitchNetwork = useSwitchNetwork;
exports.useToken = useToken;
exports.useTransaction = useTransaction;
exports.useWaitForTransaction = useWaitForTransaction;
exports.useWebSocketProvider = useWebSocketProvider;

Back to Directory File Manager