thirdweb 5.56.0-nightly-07b949dd8c07ffdeda40a5549c31ad4b09abbbf1-20240916000437 → 5.56.0

package/src/extensions/thirdweb/write/publish.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+import { FORKED_POLYGON_CHAIN } from "../../../../test/src/chains.js";
+import { TEST_CLIENT } from "../../../../test/src/test-clients.js";
+import { TEST_ACCOUNT_D } from "../../../../test/src/test-wallets.js";
+import { getContract } from "../../../contract/contract.js";
+import { CONTRACT_PUBLISHER_ADDRESS } from "../../../contract/deployment/publisher.js";
+import { parseEventLogs } from "../../../event/actions/parse-logs.js";
+import { download } from "../../../storage/download.js";
+import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import { fetchDeployMetadata } from "../../../utils/any-evm/deploy-metadata.js";
+import { contractPublishedEvent } from "../__generated__/IContractPublisher/events/ContractPublished.js";
+import { getAllPublishedContracts } from "../__generated__/IContractPublisher/read/getAllPublishedContracts.js";
+import { getPublishedContractVersions } from "../__generated__/IContractPublisher/read/getPublishedContractVersions.js";
+import { publishContract } from "./publish.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("publishContract", () => {
+  it("should publish a contract successfully", async () => {
+    const publisherContract = getContract({
+      client: TEST_CLIENT,
+      chain: FORKED_POLYGON_CHAIN,
+      address: CONTRACT_PUBLISHER_ADDRESS,
+    });
+
+    let publishedContracts = await getAllPublishedContracts({
+      contract: publisherContract,
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(publishedContracts.length).toBe(0);
+
+    const catAttackDeployMetadata = await fetchDeployMetadata({
+      client: TEST_CLIENT,
+      uri: "ipfs://QmWcAMvBy49WRrzZeK4EQeVnkdmyb5H4STz4gUQwnt1kzC",
+    });
+
+    const tx = publishContract({
+      contract: publisherContract,
+      account: TEST_ACCOUNT_D,
+      metadata: {
+        ...catAttackDeployMetadata,
+        version: "0.0.1",
+        description: "Cat Attack NFT",
+        changelog: "Initial release",
+      },
+    });
+    const result = await sendAndConfirmTransaction({
+      transaction: tx,
+      account: TEST_ACCOUNT_D,
+    });
+    expect(result.transactionHash.length).toBeGreaterThan(0);
+    const logs = parseEventLogs({
+      events: [contractPublishedEvent()],
+      logs: result.logs,
+    });
+    expect(logs?.[0]?.args.publishedContract.contractId).toBe("CatAttackNFT");
+    expect(logs?.[0]?.args.publishedContract.publishMetadataUri).toBeDefined();
+    const rawMeta = await download({
+      client: TEST_CLIENT,
+      uri: logs?.[0]?.args.publishedContract.publishMetadataUri ?? "",
+    }).then((r) => r.json());
+    expect(rawMeta).toMatchInlineSnapshot(`
+      {
+        "bytecodeUri": "ipfs://QmVyB9qAs7XdZYNGPcNbff43BX1tyZFJkqdfp1eXiNS8AG/0",
+        "changelog": "Initial release",
+        "compilers": {
+          "solc": [
+            {
+              "bytecodeUri": "ipfs://QmVyB9qAs7XdZYNGPcNbff43BX1tyZFJkqdfp1eXiNS8AG/0",
+              "compilerVersion": "",
+              "evmVersion": "",
+              "metadataUri": "ipfs://Qmd2Ef29NzCjomqYXZbWa8ZdF1AESDAS1HDAonmAnTgHPs",
+            },
+          ],
+        },
+        "description": "Cat Attack NFT",
+        "metadataUri": "ipfs://Qmd2Ef29NzCjomqYXZbWa8ZdF1AESDAS1HDAonmAnTgHPs",
+        "name": "CatAttackNFT",
+        "publisher": "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+        "routerType": "none",
+        "version": "0.0.1",
+      }
+    `);
+    const publishedData = await fetchDeployMetadata({
+      client: TEST_CLIENT,
+      uri: logs?.[0]?.args.publishedContract.publishMetadataUri ?? "",
+    });
+    expect(publishedData.abi).toBeDefined();
+    expect(publishedData.bytecode).toBeDefined();
+    expect(publishedData.version).toBe("0.0.1");
+    expect(publishedData.changelog).toBe("Initial release");
+    expect(publishedData.name).toBe("CatAttackNFT");
+    expect(publishedData.description).toBe("Cat Attack NFT");
+    expect(publishedData.publisher).toBe(TEST_ACCOUNT_D.address);
+    expect(publishedData.routerType).toBe("none");
+
+    publishedContracts = await getAllPublishedContracts({
+      contract: publisherContract,
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(publishedContracts.length).toBe(1);
+
+    expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_D,
+        transaction: publishContract({
+          contract: publisherContract,
+          account: TEST_ACCOUNT_D,
+          previousMetadata: publishedData,
+          metadata: {
+            ...publishedData,
+            version: "0.0.1",
+            changelog: "Initial release 2",
+          },
+        }),
+      }),
+    ).rejects.toThrow("Version 0.0.1 is not greater than 0.0.1");
+
+    const tx2 = publishContract({
+      contract: publisherContract,
+      account: TEST_ACCOUNT_D,
+      previousMetadata: publishedData,
+      metadata: {
+        ...publishedData,
+        version: "0.0.2",
+        changelog: "Initial release 2",
+      },
+    });
+    const result2 = await sendAndConfirmTransaction({
+      transaction: tx2,
+      account: TEST_ACCOUNT_D,
+    });
+
+    expect(result2.transactionHash.length).toBeGreaterThan(0);
+    const logs2 = parseEventLogs({
+      events: [contractPublishedEvent()],
+      logs: result2.logs,
+    });
+    expect(logs2?.[0]?.args.publishedContract.contractId).toBe("CatAttackNFT");
+    expect(logs2?.[0]?.args.publishedContract.publishMetadataUri).toBeDefined();
+    const publishedData2 = await fetchDeployMetadata({
+      client: TEST_CLIENT,
+      uri: logs2?.[0]?.args.publishedContract.publishMetadataUri ?? "",
+    });
+    expect(publishedData2.version).toBe("0.0.2");
+
+    publishedContracts = await getAllPublishedContracts({
+      contract: publisherContract,
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(publishedContracts.length).toBe(1);
+
+    const versions = await getPublishedContractVersions({
+      contract: publisherContract,
+      contractId: "CatAttackNFT",
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(versions.length).toEqual(2);
+  }, 120000);
+});

package/src/extensions/thirdweb/write/publish.ts

@@ -0,0 +1,131 @@
+import type { Abi } from "abitype";
+import { encodePacked, keccak256, toFunctionSelector } from "viem/utils";
+import { polygon } from "../../../chains/chain-definitions/polygon.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { ZERO_ADDRESS } from "../../../constants/addresses.js";
+import { getContract } from "../../../contract/contract.js";
+import { CONTRACT_PUBLISHER_ADDRESS } from "../../../contract/deployment/publisher.js";
+import { download } from "../../../storage/download.js";
+import { upload } from "../../../storage/upload.js";
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type {
+  ExtendedMetadata,
+  FetchDeployMetadataResult,
+} from "../../../utils/any-evm/deploy-metadata.js";
+import { ensureBytecodePrefix } from "../../../utils/bytecode/prefix.js";
+import { isIncrementalVersion } from "../../../utils/semver.js";
+import type { Account } from "../../../wallets/interfaces/wallet.js";
+import { isGetInstalledModulesSupported } from "../../modules/__generated__/IModularCore/read/getInstalledModules.js";
+import { publishContract as generatedPublishContract } from "../__generated__/IContractPublisher/write/publishContract.js";
+
+export type PublishContractParams = {
+  account: Account;
+  metadata: FetchDeployMetadataResult & {
+    version: string;
+  };
+  previousMetadata?: FetchDeployMetadataResult;
+};
+
+/**
+ * Publish a contract to the contract publisher.
+ *
+ * @param options - The options for publishing the contract.
+ * @returns The transaction to publish the contract.
+ * @example
+ * ```ts
+ * const tx = publishContract({
+ *   contract,
+ *   account,
+ *   metadata,
+ * });
+ * ```
+ * @extension thirdweb
+ */
+export function publishContract(
+  options: BaseTransactionOptions<PublishContractParams>,
+) {
+  return generatedPublishContract({
+    contract: options.contract,
+    async asyncParams() {
+      const currentVersion = options.previousMetadata?.version;
+      // check if the version is greater than the current version
+      if (
+        currentVersion &&
+        !isIncrementalVersion(currentVersion, options.metadata.version)
+      ) {
+        throw Error(
+          `Version ${options.metadata.version} is not greater than ${currentVersion}`,
+        );
+      }
+      // hash the bytecode
+      const bytecode = await download({
+        client: options.contract.client,
+        uri: options.metadata.bytecodeUri,
+      }).then((r) => r.text());
+      const bytecodeHash = keccak256(
+        encodePacked(["bytes"], [ensureBytecodePrefix(bytecode)]),
+      );
+
+      const abi = options.metadata.abi;
+      const routerType = getRouterType(abi);
+      // not spreading here, we don't want to re-upload the fetched data like bytecode
+      const newMetadata: ExtendedMetadata = {
+        bytecodeUri: options.metadata.bytecodeUri,
+        metadataUri: options.metadata.metadataUri,
+        name: options.metadata.name,
+        version: options.metadata.version,
+        audit: options.metadata.audit,
+        changelog: options.metadata.changelog,
+        compositeAbi: options.metadata.compositeAbi,
+        constructorParams: options.metadata.constructorParams,
+        defaultExtensions: options.metadata.defaultExtensions,
+        defaultModules: options.metadata.defaultModules,
+        deployType: options.metadata.deployType,
+        description: options.metadata.description,
+        displayName: options.metadata.displayName,
+        factoryDeploymentData: options.metadata.factoryDeploymentData,
+        isDeployableViaFactory: options.metadata.isDeployableViaFactory,
+        isDeployableViaProxy: options.metadata.isDeployableViaProxy,
+        logo: options.metadata.logo,
+        networksForDeployment: options.metadata.networksForDeployment,
+        readme: options.metadata.readme,
+        tags: options.metadata.tags,
+        compilers: options.metadata.compilers,
+        publisher: options.account.address,
+        routerType,
+      };
+
+      // upload the new metadata
+      const newMetadataUri = await upload({
+        client: options.contract.client,
+        files: [newMetadata],
+      });
+
+      return {
+        publisher: options.account.address,
+        contractId: options.metadata.name,
+        publishMetadataUri: newMetadataUri,
+        compilerMetadataUri: options.metadata.metadataUri,
+        bytecodeHash,
+        implementation: ZERO_ADDRESS,
+      };
+    },
+  });
+}
+
+export function getContractPublisher(client: ThirdwebClient) {
+  return getContract({
+    client,
+    chain: polygon,
+    address: CONTRACT_PUBLISHER_ADDRESS,
+  });
+}
+
+function getRouterType(abi: Abi) {
+  const fnSelectors = abi
+    .filter((f) => f.type === "function")
+    .map((f) => toFunctionSelector(f));
+  const isModule = isGetInstalledModulesSupported(fnSelectors);
+  // TODO add dynamic detection
+  return isModule ? "modular" : "none";
+}

package/src/react/core/hooks/connection/ConnectButtonProps.ts

@@ -113,6 +113,13 @@ export type PayUIOptions = Prettify<
             status: BuyWithFiatStatus;
           },
     ) => void;
+    /**
+     * Customize the display of the PayEmbed UI.
+     */
+    metadata?: {
+      name?: string;
+      image?: string;
+    };
   } & (FundWalletOptions | DirectPaymentOptions | TranasctionOptions)
 >;
 
@@ -145,13 +152,6 @@ export type DirectPaymentOptions = {
    * The payment information
    */
   paymentInfo: PaymentInfo;
-  /**
-   * Customize the display of the PayEmbed UI.
-   */
-  metadata?: {
-    name?: string;
-    image?: string;
-  };
 };
 
 export type TranasctionOptions = {
@@ -160,13 +160,6 @@ export type TranasctionOptions = {
    * The transaction to be executed.
    */
   transaction: PreparedTransaction;
-  /**
-   * Customize the display of the PayEmbed UI.
-   */
-  metadata?: {
-    name?: string;
-    image?: string;
-  };
 };
 
 /**

package/src/react/core/hooks/pay/useBuyWithCryptoStatus.ts

@@ -64,7 +64,13 @@ export function useBuyWithCryptoStatus(params?: BuyWithCryptoTransaction) {
       return getBuyWithCryptoStatus(params);
     },
     enabled: !!params,
-    refetchInterval: 5000,
+    refetchInterval: (query) => {
+      const status = (query.state.data as BuyWithCryptoStatus)?.status;
+      if (status === "COMPLETED" || status === "FAILED") {
+        return false;
+      }
+      return 5000;
+    },
     refetchIntervalInBackground: true,
     retry: true,
   });

package/src/react/core/hooks/pay/useBuyWithFiatStatus.ts

@@ -45,7 +45,23 @@ export function useBuyWithFiatStatus(
       return getBuyWithFiatStatus(params);
     },
     enabled: !!params,
-    refetchInterval: 5000,
+    refetchInterval: (query) => {
+      const data = query.state.data as BuyWithFiatStatus;
+      const status = data?.status;
+      if (
+        status === "ON_RAMP_TRANSFER_FAILED" ||
+        status === "PAYMENT_FAILED" ||
+        status === "CRYPTO_SWAP_COMPLETED" ||
+        // onRampToken and toToken being the same means there is no additional swap step
+        (status === "ON_RAMP_TRANSFER_COMPLETED" &&
+          data?.quote.toToken.chainId === data?.quote.onRampToken.chainId &&
+          data?.quote.toToken.tokenAddress.toLowerCase() ===
+            data?.quote.onRampToken.tokenAddress.toLowerCase())
+      ) {
+        return false;
+      }
+      return 5000;
+    },
     refetchIntervalInBackground: true,
     retry: true,
   });

package/src/react/core/providers/invalidateWalletBalance.test.ts

@@ -25,7 +25,7 @@ describe("invalidateWalletBalance", () => {
     invalidateWalletBalance(queryClient);
 
     expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
-      queryKey: ["walletBalance", undefined] as const,
+      queryKey: ["walletBalance"] as const,
     });
   });
 });

package/src/react/core/providers/invalidateWalletBalance.ts

@@ -7,6 +7,6 @@ export function invalidateWalletBalance(
   return queryClient.invalidateQueries({
     // invalidate any walletBalance queries for this chainId
     // TODO: add wallet address in here if we can get it somehow
-    queryKey: ["walletBalance", chainId] as const,
+    queryKey: chainId ? ["walletBalance", chainId] : ["walletBalance"],
   });
 }

package/src/react/web/ui/ConnectWallet/screens/Buy/BuyScreen.tsx

@@ -1,4 +1,5 @@
 import { IdCardIcon } from "@radix-ui/react-icons";
+import { useQueryClient } from "@tanstack/react-query";
 import { useCallback, useMemo, useState } from "react";
 import { trackPayEvent } from "../../../../../../analytics/track.js";
 import type { Chain } from "../../../../../../chains/types.js";
@@ -24,6 +25,7 @@ import { useWalletBalance } from "../../../../../core/hooks/others/useWalletBala
 import { useBuyWithCryptoQuote } from "../../../../../core/hooks/pay/useBuyWithCryptoQuote.js";
 import { useBuyWithFiatQuote } from "../../../../../core/hooks/pay/useBuyWithFiatQuote.js";
 import { useActiveAccount } from "../../../../../core/hooks/wallets/useActiveAccount.js";
+import { invalidateWalletBalance } from "../../../../../core/providers/invalidateWalletBalance.js";
 import type { SupportedTokens } from "../../../../../core/utils/defaultTokens.js";
 import { LoadingScreen } from "../../../../wallets/shared/LoadingScreen.js";
 import type { PayEmbedConnectOptions } from "../../../PayEmbed.js";
@@ -226,14 +228,17 @@ function BuyScreenContent(props: BuyScreenContentProps) {
 
   // screens ----------------------------
 
+  const queryClient = useQueryClient();
+
   const onSwapSuccess = useCallback(
     (_status: BuyWithCryptoStatus) => {
       props.payOptions.onPurchaseSuccess?.({
         type: "crypto",
         status: _status,
       });
+      invalidateWalletBalance(queryClient);
     },
-    [props.payOptions.onPurchaseSuccess],
+    [props.payOptions.onPurchaseSuccess, queryClient],
   );
 
   const onFiatSuccess = useCallback(
@@ -242,8 +247,9 @@ function BuyScreenContent(props: BuyScreenContentProps) {
         type: "fiat",
         status: _status,
       });
+      invalidateWalletBalance(queryClient);
     },
-    [props.payOptions.onPurchaseSuccess],
+    [props.payOptions.onPurchaseSuccess, queryClient],
   );
 
   if (screen.id === "connect-payer-wallet") {

package/src/transaction/resolve-method.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import {
+  USDT_CONTRACT,
+  USDT_CONTRACT_WITH_ABI,
+} from "../../test/src/test-contracts.js";
+import { resolveMethod } from "./resolve-method.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("resolveMethod", () => {
+  it("should return parseAbiItem result for function signature", async () => {
+    const result = await resolveMethod(
+      "function transfer(address to, uint256 amount)",
+    )(USDT_CONTRACT);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inputs": [
+          {
+            "name": "to",
+            "type": "address",
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+          },
+        ],
+        "name": "transfer",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+      }
+    `);
+  });
+
+  it("should return parseAbiItem result for abi", async () => {
+    const result = await resolveMethod("transfer")(USDT_CONTRACT_WITH_ABI);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inputs": [
+          {
+            "name": "_to",
+            "type": "address",
+          },
+          {
+            "name": "_value",
+            "type": "uint256",
+          },
+        ],
+        "name": "transfer",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+      }
+    `);
+  });
+
+  it("should return parseAbiItem result for abi", async () => {
+    const result = await resolveMethod("transfer")(USDT_CONTRACT);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "constant": false,
+        "inputs": [
+          {
+            "name": "_to",
+            "type": "address",
+          },
+          {
+            "name": "_value",
+            "type": "uint256",
+          },
+        ],
+        "name": "transfer",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function",
+      }
+    `);
+  });
+});

package/src/transaction/resolve-method.ts

@@ -1,4 +1,5 @@
 import type { Abi, AbiFunction } from "abitype";
+import { parseAbiItem } from "abitype";
 import { resolveContractAbi } from "../contract/actions/resolve-abi.js";
 import type { ThirdwebContract } from "../contract/contract.js";
 
@@ -22,9 +23,19 @@ import type { ThirdwebContract } from "../contract/contract.js";
  * ```
  * @contract
  */
-export function resolveMethod<abiFn extends AbiFunction>(method: string) {
-  return async (contract: ThirdwebContract) => {
-    const resolvedAbi = await resolveContractAbi<Abi>(contract);
+export function resolveMethod<
+  abiFn extends AbiFunction,
+  TAbi extends Abi = Abi,
+>(method: string) {
+  return async (contract: ThirdwebContract<TAbi>) => {
+    if (typeof method === "string" && method.startsWith("function ")) {
+      // we know it will be an abi function so we can cast it
+      return parseAbiItem(method) as AbiFunction;
+    }
+
+    const resolvedAbi = contract.abi?.length
+      ? contract.abi
+      : await resolveContractAbi<Abi>(contract);
     // we try to find the abiFunction in the abi
     const abiFunction = resolvedAbi.find((item) => {
       // if the item is not a function we can ignore it

package/src/utils/any-evm/deploy-metadata.ts

@@ -75,7 +75,7 @@ async function fetchAndParseCompilerMetadata(
 
 // types
 
-type RawCompilerMetadata = {
+export type RawCompilerMetadata = {
   name: string;
   metadataUri: string;
   bytecodeUri: string;
@@ -130,9 +130,10 @@ type ParsedCompilerMetadata = {
 };
 
 export type CompilerMetadata = Prettify<
-  ParsedCompilerMetadata & {
-    bytecode: Hex;
-  }
+  RawCompilerMetadata &
+    ParsedCompilerMetadata & {
+      bytecode: Hex;
+    }
 >;
 
 export type ExtendedMetadata = {
@@ -195,5 +196,18 @@ export type ExtendedMetadata = {
     }
   >;
   compositeAbi?: Abi;
+  compilers?: Record<
+    "solc" | "zksolc",
+    {
+      evmVersion: string;
+      compilerVersion: string;
+      metadataUri: string;
+      bytecodeUri: string;
+    }[]
+  >;
+  externalLinks?: Array<{
+    name: string;
+    url: string;
+  }>;
   [key: string]: unknown;
 };

package/src/utils/arrays.ts

@@ -0,0 +1,23 @@
+/**
+ * @internal
+ */
+export function hasDuplicates<T>(
+  arr: T[],
+  fn: (a: T | undefined, b: T | undefined) => boolean,
+): boolean {
+  if (arr.length === 0 || arr.length === 1) {
+    return false;
+  }
+  if (!fn) {
+    throw new Error("Comparison function required");
+  }
+
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = i + 1; j < arr.length; j++) {
+      if (fn(arr[i], arr[j])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

package/src/utils/semver.ts

@@ -0,0 +1,76 @@
+const MAX_LENGTH = 256;
+const NUMERIC_IDENTIFIER = "0|[1-9]\\d*";
+const MAIN_VERSION_IDENTIFIER = `(${NUMERIC_IDENTIFIER})\\.(${NUMERIC_IDENTIFIER})\\.(${NUMERIC_IDENTIFIER})`;
+const REGEX_MAIN_VERSION = new RegExp(MAIN_VERSION_IDENTIFIER);
+
+/**
+ * @internal
+ */
+export type Semver = {
+  major: number;
+  minor: number;
+  patch: number;
+  versionString: string;
+};
+
+/**
+ * @internal
+ * @param version - The version to convert to a Semver
+ */
+export function toSemver(version: string): Semver {
+  if (version.length > MAX_LENGTH) {
+    throw new Error(`version is longer than ${MAX_LENGTH} characters`);
+  }
+  const matches = version.trim().match(REGEX_MAIN_VERSION);
+  if (!matches || matches?.length !== 4) {
+    throw new Error(
+      `${version} is not a valid semantic version. Should be in the format of major.minor.patch. Ex: 0.4.1`,
+    );
+  }
+  const major = Number(matches[1]);
+  const minor = Number(matches[2]);
+  const patch = Number(matches[3]);
+  const versionString = [major, minor, patch].join(".");
+  return {
+    major,
+    minor,
+    patch,
+    versionString,
+  };
+}
+
+/**
+ * @internal
+ * @param current - The current version
+ * @param next - The next version
+ */
+export function isIncrementalVersion(current: string, next: string) {
+  const currentSemver = toSemver(current);
+  const nextSemver = toSemver(next);
+  if (nextSemver.major > currentSemver.major) {
+    return true;
+  }
+  const eqMajor = nextSemver.major === currentSemver.major;
+  if (eqMajor && nextSemver.minor > currentSemver.minor) {
+    return true;
+  }
+  const eqMinor = nextSemver.minor === currentSemver.minor;
+  return eqMajor && eqMinor && nextSemver.patch > currentSemver.patch;
+}
+
+/**
+ * @internal
+ */
+export function isDowngradeVersion(current: string, next: string) {
+  const currentSemver = toSemver(current);
+  const nextSemver = toSemver(next);
+  if (nextSemver.major < currentSemver.major) {
+    return true;
+  }
+  const eqMajor = nextSemver.major === currentSemver.major;
+  if (eqMajor && nextSemver.minor < currentSemver.minor) {
+    return true;
+  }
+  const eqMinor = nextSemver.minor === currentSemver.minor;
+  return eqMajor && eqMinor && nextSemver.patch < currentSemver.patch;
+}