thirdweb 5.55.1-nightly-b2a2c9784a33394dffbcd32bbd28b2c612a4e603-20240915000420 → 5.56.0-nightly-a5e605c65e360a9d3d2e553d6783e58582b50a70-20240917000331

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/wallets/useAdminAccount.ts

@@ -0,0 +1,25 @@
+import { useActiveWallet } from "./useActiveWallet.js";
+import { useConnectedWallets } from "./useConnectedWallets.js";
+
+/**
+ * Get the admin wallet for the active wallet
+ * Useful for smart wallets to get the underlying personal account
+ * @returns The admin wallet for the active wallet, or the active wallet if it doesn't have an admin account
+ */
+export function useAdminWallet() {
+  const activeWallet = useActiveWallet();
+  const connectedWallets = useConnectedWallets();
+  const adminAccount = activeWallet?.getAdminAccount?.();
+
+  if (!adminAccount) {
+    // If the active wallet doesn't have an admin account, return the active wallet
+    return activeWallet;
+  }
+
+  // If the active wallet has an admin account, find the admin wallet in connected wallets and return it
+  return connectedWallets.find(
+    (wallet) =>
+      wallet.getAccount()?.address?.toLowerCase() ===
+      adminAccount?.address?.toLowerCase(),
+  );
+}

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

@@ -1120,7 +1120,8 @@ function SwapScreenContent(props: {
 
   function showSwapFlow() {
     if (
-      props.payOptions.mode === "direct_payment" &&
+      (props.payOptions.mode === "direct_payment" ||
+        props.payOptions.mode === "fund_wallet") &&
       !isNotEnoughBalance &&
       !swapRequired
     ) {

package/src/react/web/ui/ConnectWallet/screens/Buy/swap/ConfirmationScreen.tsx

@@ -126,7 +126,7 @@ export function SwapConfirmationScreen(props: {
 
       {/* Send to  */}
       {isDifferentRecipient && (
-        <ConfirmItem label="Seller">
+        <ConfirmItem label="Receiver">
           <Text color="primaryText" size="sm">
             {ensName.data || shortenAddress(receiver)}
           </Text>

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

@@ -23,8 +23,6 @@ export function usePayerSetup() {
       const account = wallet.getAccount();
       const chain = wallet.getChain();
       if (account && chain) {
-        console.log("updated to", account, chain);
-
         setPayer({
           account,
           chain,

package/src/react/web/ui/ConnectWallet/screens/SignatureScreen.tsx

@@ -13,6 +13,7 @@ import { useSiweAuth } from "../../../../core/hooks/auth/useSiweAuth.js";
 import type { ConnectButtonProps } from "../../../../core/hooks/connection/ConnectButtonProps.js";
 import { useActiveAccount } from "../../../../core/hooks/wallets/useActiveAccount.js";
 import { useActiveWallet } from "../../../../core/hooks/wallets/useActiveWallet.js";
+import { useAdminWallet } from "../../../../core/hooks/wallets/useAdminAccount.js";
 import { useDisconnect } from "../../../../core/hooks/wallets/useDisconnect.js";
 import { wait } from "../../../../core/utils/wait.js";
 import { LoadingScreen } from "../../../wallets/shared/LoadingScreen.js";
@@ -46,12 +47,12 @@ export const SignatureScreen: React.FC<{
     connectLocale,
   } = props;
 
-  const activeWallet = useActiveWallet();
+  const wallet = useActiveWallet();
+  const adminWallet = useAdminWallet();
   const activeAccount = useActiveAccount();
-  const siweAuth = useSiweAuth(activeWallet, activeAccount, props.auth);
+  const siweAuth = useSiweAuth(wallet, activeAccount, props.auth);
   const [status, setStatus] = useState<Status>("idle");
   const { disconnect } = useDisconnect();
-  const wallet = useActiveWallet();
   const locale = connectLocale.signatureScreen;
 
   const signIn = useCallback(async () => {
@@ -66,12 +67,15 @@ export const SignatureScreen: React.FC<{
     }
   }, [onDone, siweAuth]);
 
-  // this should not happen
   if (!wallet) {
     return <LoadingScreen />;
   }
 
-  if (wallet.id === "inApp" || wallet.id === "embedded") {
+  if (
+    wallet.id === "inApp" ||
+    wallet.id === "embedded" ||
+    (wallet.id === "smart" && adminWallet?.id === "inApp")
+  ) {
     return (
       <HeadlessSignIn
         signIn={signIn}

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/extensions/convert-erc20-amount.ts

@@ -22,24 +22,30 @@ export async function convertErc20Amount(
     } & AmountOrAmountInWei
   >,
 ): Promise<bigint> {
-  if ("amount" in options) {
-    // for native token, we know decimals are 18
-    if (!options.erc20Address || isNativeTokenAddress(options.erc20Address)) {
-      return toUnits(options.amount.toString(), 18);
+  try {
+    if ("amount" in options) {
+      // for native token, we know decimals are 18
+      if (!options.erc20Address || isNativeTokenAddress(options.erc20Address)) {
+        return toUnits(options.amount.toString(), 18);
+      }
+      // otherwise get the decimals of the currency
+      const currencyContract = getContract({
+        client: options.client,
+        chain: options.chain,
+        address: options.erc20Address,
+      });
+      const { decimals } = await import(
+        "../../extensions/erc20/read/decimals.js"
+      );
+      const currencyDecimals = await decimals({
+        contract: currencyContract,
+      });
+      return toUnits(options.amount.toString(), currencyDecimals);
     }
-    // otherwise get the decimals of the currency
-    const currencyContract = getContract({
-      client: options.client,
-      chain: options.chain,
-      address: options.erc20Address,
-    });
-    const { decimals } = await import(
-      "../../extensions/erc20/read/decimals.js"
+    return options.amountInWei;
+  } catch (e) {
+    throw new Error(
+      `Failed to convert ERC20 amount for token: ${options.erc20Address}: ${e}`,
     );
-    const currencyDecimals = await decimals({
-      contract: currencyContract,
-    });
-    return toUnits(options.amount.toString(), currencyDecimals);
   }
-  return options.amountInWei;
 }

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;
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.55.1-nightly-b2a2c9784a33394dffbcd32bbd28b2c612a4e603-20240915000420";
+export const version = "5.56.0-nightly-a5e605c65e360a9d3d2e553d6783e58582b50a70-20240917000331";

package/src/wallets/in-app/web/lib/in-app-account.ts

@@ -305,7 +305,6 @@ export class IFrameWallet {
         return signedMessage as Hex;
       },
       async signTypedData(_typedData) {
-        console.log("signTypedData", _typedData);
         const parsedTypedData = parseTypedData(_typedData);
         // deleting EIP712 Domain as it results in ambiguous primary type on some cases
         // this happens when going from viem to ethers via the iframe

package/src/wallets/interfaces/wallet.ts

@@ -141,6 +141,12 @@ export type Wallet<TWalletId extends WalletId = WalletId> = {
    * Can be used to execute any pre-connection actions like showing a modal, etc.
    */
   onConnectRequested?: () => Promise<void>;
+
+  /**
+   * Get the admin account of this wallet
+   * This is useful for smart wallets to get the underlying personal account
+   */
+  getAdminAccount?: () => Account | undefined;
 };
 
 /**

package/src/wallets/smart/smart-wallet.ts

@@ -102,6 +102,7 @@ export function smartWallet(
 ): Wallet<"smart"> {
   const emitter = createWalletEmitter<"smart">();
   let account: Account | undefined = undefined;
+  let adminAccount: Account | undefined = undefined;
   let chain: Chain | undefined = undefined;
   let lastConnectOptions: WalletConnectionOption<"smart"> | undefined;
 
@@ -118,6 +119,7 @@ export function smartWallet(
     },
     getConfig: () => createOptions,
     getAccount: () => account,
+    getAdminAccount: () => adminAccount,
     autoConnect: async (options) => {
       const { connectSmartWallet } = await import("./index.js");
       const [connectedAccount, connectedChain] = await connectSmartWallet(
@@ -145,6 +147,7 @@ export function smartWallet(
         createOptions,
       );
       // set the states
+      adminAccount = options.personalAccount;
       lastConnectOptions = options;
       account = connectedAccount;
       chain = connectedChain;