@multiplatform.one/web3 5.0.27

package/dist/cjs/hooks/useContractWrite.cjs

@@ -0,0 +1,152 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useContractWrite_exports = {};
+__export(useContractWrite_exports, {
+  useContractWrite: () => useContractWrite
+});
+module.exports = __toCommonJS(useContractWrite_exports);
+var import_react = require("react");
+var import_wagmi = require("wagmi");
+function useContractWrite(config) {
+  const {
+    address,
+    abi,
+    functionName,
+    chainId,
+    value,
+    simulate = true,
+    onSuccess,
+    onError
+  } = config;
+  const [status, setStatus] = (0, import_react.useState)("idle");
+  const [currentArgs, setCurrentArgs] = (0, import_react.useState)();
+  const [simulationError, setSimulationError] = (0, import_react.useState)(null);
+  const {
+    error: simError
+  } = (0, import_wagmi.useSimulateContract)({
+    address,
+    abi,
+    functionName,
+    args: currentArgs,
+    chainId,
+    value,
+    query: {
+      enabled: simulate && !!currentArgs
+    }
+  });
+  const {
+    writeContractAsync,
+    data: hash,
+    isPending: isWritePending,
+    reset: resetWrite,
+    error: writeError
+  } = (0, import_wagmi.useWriteContract)();
+  const {
+    data: receipt,
+    isLoading: isWaitingForReceipt,
+    isSuccess: isConfirmed,
+    error: receiptError
+  } = (0, import_wagmi.useWaitForTransactionReceipt)({
+    hash,
+    query: {
+      enabled: !!hash
+    }
+  });
+  const error = writeError || receiptError || null;
+  const isLoading = isWritePending || isWaitingForReceipt;
+  const isPending = status === "pending-signature" || status === "pending-confirmation";
+  const isSuccess = status === "success";
+  const isError = status === "error";
+  const updateStatus = (0, import_react.useCallback)(() => {
+    if (receipt && isConfirmed) {
+      setStatus("success");
+      onSuccess?.(receipt);
+    } else if (error) {
+      setStatus("error");
+      onError?.(error);
+    } else if (hash && isWaitingForReceipt) {
+      setStatus("pending-confirmation");
+    } else if (isWritePending) {
+      setStatus("pending-signature");
+    }
+  }, [receipt, isConfirmed, error, hash, isWaitingForReceipt, isWritePending, onSuccess, onError]);
+  if (receipt && isConfirmed && status !== "success") {
+    updateStatus();
+  } else if (error && status !== "error") {
+    updateStatus();
+  } else if (hash && isWaitingForReceipt && status !== "pending-confirmation") {
+    updateStatus();
+  } else if (isWritePending && status !== "pending-signature") {
+    updateStatus();
+  }
+  const write = (0, import_react.useCallback)(async args => {
+    try {
+      setCurrentArgs(args);
+      setSimulationError(null);
+      if (simulate && simError) {
+        setSimulationError(simError);
+        setStatus("error");
+        onError?.(simError);
+        return void 0;
+      }
+      setStatus("simulating");
+      if (simulate) {
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+      setStatus("pending-signature");
+      const txHash = await writeContractAsync({
+        address,
+        abi,
+        functionName,
+        args,
+        chainId,
+        value
+      });
+      setStatus("pending-confirmation");
+      return txHash;
+    } catch (err) {
+      setStatus("error");
+      onError?.(err);
+      return void 0;
+    }
+  }, [address, abi, functionName, chainId, value, simulate, simError, writeContractAsync, onError]);
+  const reset = (0, import_react.useCallback)(() => {
+    setStatus("idle");
+    setCurrentArgs(void 0);
+    setSimulationError(null);
+    resetWrite();
+  }, [resetWrite]);
+  return {
+    write,
+    reset,
+    status,
+    hash,
+    receipt,
+    isLoading,
+    isPending,
+    isSuccess,
+    isError,
+    error,
+    simulationError
+  };
+}

package/dist/cjs/hooks/useContractWrite.native.js

@@ -0,0 +1,157 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useContractWrite_exports = {};
+__export(useContractWrite_exports, {
+  useContractWrite: () => useContractWrite
+});
+module.exports = __toCommonJS(useContractWrite_exports);
+var import_react = require("react");
+var import_wagmi = require("wagmi");
+function useContractWrite(config) {
+  var {
+    address,
+    abi,
+    functionName,
+    chainId,
+    value,
+    simulate = true,
+    onSuccess,
+    onError
+  } = config;
+  var [status, setStatus] = (0, import_react.useState)("idle");
+  var [currentArgs, setCurrentArgs] = (0, import_react.useState)();
+  var [simulationError, setSimulationError] = (0, import_react.useState)(null);
+  var {
+    error: simError
+  } = (0, import_wagmi.useSimulateContract)({
+    address,
+    abi,
+    functionName,
+    args: currentArgs,
+    chainId,
+    value,
+    query: {
+      enabled: simulate && !!currentArgs
+    }
+  });
+  var {
+    writeContractAsync,
+    data: hash,
+    isPending: isWritePending,
+    reset: resetWrite,
+    error: writeError
+  } = (0, import_wagmi.useWriteContract)();
+  var {
+    data: receipt,
+    isLoading: isWaitingForReceipt,
+    isSuccess: isConfirmed,
+    error: receiptError
+  } = (0, import_wagmi.useWaitForTransactionReceipt)({
+    hash,
+    query: {
+      enabled: !!hash
+    }
+  });
+  var error = writeError || receiptError || null;
+  var isLoading = isWritePending || isWaitingForReceipt;
+  var isPending = status === "pending-signature" || status === "pending-confirmation";
+  var isSuccess = status === "success";
+  var isError = status === "error";
+  var updateStatus = (0, import_react.useCallback)(function () {
+    if (receipt && isConfirmed) {
+      setStatus("success");
+      onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(receipt);
+    } else if (error) {
+      setStatus("error");
+      onError === null || onError === void 0 ? void 0 : onError(error);
+    } else if (hash && isWaitingForReceipt) {
+      setStatus("pending-confirmation");
+    } else if (isWritePending) {
+      setStatus("pending-signature");
+    }
+  }, [receipt, isConfirmed, error, hash, isWaitingForReceipt, isWritePending, onSuccess, onError]);
+  if (receipt && isConfirmed && status !== "success") {
+    updateStatus();
+  } else if (error && status !== "error") {
+    updateStatus();
+  } else if (hash && isWaitingForReceipt && status !== "pending-confirmation") {
+    updateStatus();
+  } else if (isWritePending && status !== "pending-signature") {
+    updateStatus();
+  }
+  var write = (0, import_react.useCallback)(async function (args) {
+    try {
+      setCurrentArgs(args);
+      setSimulationError(null);
+      if (simulate && simError) {
+        setSimulationError(simError);
+        setStatus("error");
+        onError === null || onError === void 0 ? void 0 : onError(simError);
+        return void 0;
+      }
+      setStatus("simulating");
+      if (simulate) {
+        await new Promise(function (resolve) {
+          return setTimeout(resolve, 100);
+        });
+      }
+      setStatus("pending-signature");
+      var txHash = await writeContractAsync({
+        address,
+        abi,
+        functionName,
+        args,
+        chainId,
+        value
+      });
+      setStatus("pending-confirmation");
+      return txHash;
+    } catch (err) {
+      setStatus("error");
+      onError === null || onError === void 0 ? void 0 : onError(err);
+      return void 0;
+    }
+  }, [address, abi, functionName, chainId, value, simulate, simError, writeContractAsync, onError]);
+  var reset = (0, import_react.useCallback)(function () {
+    setStatus("idle");
+    setCurrentArgs(void 0);
+    setSimulationError(null);
+    resetWrite();
+  }, [resetWrite]);
+  return {
+    write,
+    reset,
+    status,
+    hash,
+    receipt,
+    isLoading,
+    isPending,
+    isSuccess,
+    isError,
+    error,
+    simulationError
+  };
+}
+//# sourceMappingURL=useContractWrite.native.js.map

package/dist/cjs/hooks/useContractWrite.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useContractWrite_exports","__export","useContractWrite","module","exports","import_react","require","import_wagmi","config","address","abi","functionName","chainId","simulate","onSuccess","onError","status","setStatus","useState","currentArgs","setCurrentArgs","simulationError","setSimulationError","error","simError","useSimulateContract","args","query","enabled","writeContractAsync","data","hash","isPending","isWritePending","reset","resetWrite","writeError","useWriteContract","receipt","isLoading","isWaitingForReceipt","isSuccess","isConfirmed","receiptError","useWaitForTransactionReceipt","isError","updateStatus","useCallback","write","Promise","resolve","setTimeout","txHash","err"],"sources":["../../../src/hooks/useContractWrite.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/hooks/useContractWrite.spec.cjs

@@ -0,0 +1,207 @@
+var import_react = require("@testing-library/react");
+var import_vitest = require("vitest");
+var import_useContractWrite = require("./useContractWrite.cjs");
+const {
+  mockUseSimulateContract,
+  mockUseWriteContract,
+  mockUseWaitForTransactionReceipt
+} = import_vitest.vi.hoisted(() => ({
+  mockUseSimulateContract: import_vitest.vi.fn(),
+  mockUseWriteContract: import_vitest.vi.fn(),
+  mockUseWaitForTransactionReceipt: import_vitest.vi.fn()
+}));
+import_vitest.vi.mock("wagmi", () => ({
+  useSimulateContract: mockUseSimulateContract,
+  useWriteContract: mockUseWriteContract,
+  useWaitForTransactionReceipt: mockUseWaitForTransactionReceipt
+}));
+const testAbi = [];
+const baseConfig = {
+  address: "0x1234567890abcdef1234567890abcdef12345678",
+  abi: testAbi,
+  functionName: "withdraw"
+};
+(0, import_vitest.describe)("useContractWrite", () => {
+  const mockWriteContractAsync = import_vitest.vi.fn();
+  const mockResetWrite = import_vitest.vi.fn();
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.clearAllMocks();
+    mockUseSimulateContract.mockReturnValue({
+      error: null
+    });
+    mockUseWriteContract.mockReturnValue({
+      writeContractAsync: mockWriteContractAsync,
+      data: void 0,
+      isPending: false,
+      reset: mockResetWrite,
+      error: null
+    });
+    mockUseWaitForTransactionReceipt.mockReturnValue({
+      data: void 0,
+      isLoading: false,
+      isSuccess: false,
+      error: null
+    });
+  });
+  (0, import_vitest.it)("starts with idle status and all false flags", () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)(baseConfig));
+    (0, import_vitest.expect)(result.current.status).toBe("idle");
+    (0, import_vitest.expect)(result.current.isLoading).toBe(false);
+    (0, import_vitest.expect)(result.current.isSuccess).toBe(false);
+    (0, import_vitest.expect)(result.current.isError).toBe(false);
+    (0, import_vitest.expect)(result.current.hash).toBeUndefined();
+    (0, import_vitest.expect)(result.current.receipt).toBeUndefined();
+    (0, import_vitest.expect)(result.current.error).toBeNull();
+    (0, import_vitest.expect)(result.current.simulationError).toBeNull();
+  });
+  (0, import_vitest.it)("write() sets simulating status immediately before the delay", () => {
+    mockWriteContractAsync.mockReturnValue(new Promise(() => {}));
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)(baseConfig));
+    (0, import_react.act)(() => {
+      result.current.write();
+    });
+    (0, import_vitest.expect)(result.current.status).toBe("simulating");
+  });
+  (0, import_vitest.it)("write() ends in pending-confirmation on success", async () => {
+    const txHash = "0xdeadbeef";
+    mockWriteContractAsync.mockResolvedValue(txHash);
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)(baseConfig));
+    await (0, import_react.act)(async () => {
+      await result.current.write();
+    });
+    (0, import_vitest.expect)(result.current.status).toBe("pending-confirmation");
+  });
+  (0, import_vitest.it)("write() returns the transaction hash", async () => {
+    const txHash = "0xdeadbeef";
+    mockWriteContractAsync.mockResolvedValue(txHash);
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)(baseConfig));
+    let returnedHash;
+    await (0, import_react.act)(async () => {
+      returnedHash = await result.current.write();
+    });
+    (0, import_vitest.expect)(returnedHash).toBe(txHash);
+  });
+  (0, import_vitest.it)("write() sets error status when writeContractAsync throws", async () => {
+    mockWriteContractAsync.mockRejectedValue(new Error("user rejected"));
+    const onError = import_vitest.vi.fn();
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)({
+      ...baseConfig,
+      onError
+    }));
+    await (0, import_react.act)(async () => {
+      await result.current.write();
+    });
+    (0, import_vitest.expect)(result.current.status).toBe("error");
+    (0, import_vitest.expect)(onError).toHaveBeenCalledWith(import_vitest.expect.any(Error));
+  });
+  (0, import_vitest.it)("write() aborts early with error when simError is present and simulate=true", async () => {
+    mockUseSimulateContract.mockReturnValue({
+      error: new Error("simulation failed")
+    });
+    const onError = import_vitest.vi.fn();
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)({
+      ...baseConfig,
+      onError
+    }));
+    await (0, import_react.act)(async () => {
+      await result.current.write();
+    });
+    (0, import_vitest.expect)(result.current.status).toBe("error");
+    (0, import_vitest.expect)(result.current.simulationError).toBeInstanceOf(Error);
+    (0, import_vitest.expect)(mockWriteContractAsync).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(onError).toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("write() does NOT abort on simError when simulate=false", async () => {
+    mockUseSimulateContract.mockReturnValue({
+      error: new Error("sim error")
+    });
+    mockWriteContractAsync.mockResolvedValue("0xhash");
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)({
+      ...baseConfig,
+      simulate: false
+    }));
+    await (0, import_react.act)(async () => {
+      await result.current.write();
+    });
+    (0, import_vitest.expect)(mockWriteContractAsync).toHaveBeenCalled();
+    (0, import_vitest.expect)(result.current.simulationError).toBeNull();
+  });
+  (0, import_vitest.it)("reset() returns to idle status and calls wagmi reset", async () => {
+    mockWriteContractAsync.mockRejectedValue(new Error("fail"));
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)(baseConfig));
+    await (0, import_react.act)(async () => {
+      await result.current.write();
+    });
+    (0, import_vitest.expect)(result.current.status).toBe("error");
+    (0, import_react.act)(() => {
+      result.current.reset();
+    });
+    (0, import_vitest.expect)(result.current.status).toBe("idle");
+    (0, import_vitest.expect)(result.current.simulationError).toBeNull();
+    (0, import_vitest.expect)(mockResetWrite).toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("transitions to success status when receipt is confirmed", () => {
+    const receipt = {
+      transactionHash: "0xhash",
+      blockNumber: 100n
+    };
+    mockUseWaitForTransactionReceipt.mockReturnValue({
+      data: receipt,
+      isLoading: false,
+      isSuccess: true,
+      error: null
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)(baseConfig));
+    (0, import_vitest.expect)(result.current.status).toBe("success");
+    (0, import_vitest.expect)(result.current.isSuccess).toBe(true);
+    (0, import_vitest.expect)(result.current.receipt).toBe(receipt);
+  });
+  (0, import_vitest.it)("calls onSuccess callback when receipt is confirmed", () => {
+    const receipt = {
+      transactionHash: "0xhash"
+    };
+    const onSuccess = import_vitest.vi.fn();
+    mockUseWaitForTransactionReceipt.mockReturnValue({
+      data: receipt,
+      isLoading: false,
+      isSuccess: true,
+      error: null
+    });
+    (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)({
+      ...baseConfig,
+      onSuccess
+    }));
+    (0, import_vitest.expect)(onSuccess).toHaveBeenCalledWith(receipt);
+  });
+  (0, import_vitest.it)("isLoading is true when write is pending", () => {
+    mockUseWriteContract.mockReturnValue({
+      writeContractAsync: mockWriteContractAsync,
+      data: void 0,
+      isPending: true,
+      reset: mockResetWrite,
+      error: null
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_useContractWrite.useContractWrite)(baseConfig));
+    (0, import_vitest.expect)(result.current.isLoading).toBe(true);
+  });
+});