thirdweb 5.53.1-nightly-865c5e3b16af70c3660f30ba8cffc5d6e360a389-20240911000352 → 5.54.0-nightly-c3800d6c0765a9a0b69ac0a4a390d20cec932419-20240912000413

package/src/contract/deployment/utils/clone-factory.ts

@@ -9,7 +9,6 @@ export async function getDeployedCloneFactoryContract(args: ClientAndChain) {
   const forwarder = await getDeployedInfraContract({
     ...args,
     contractId: "Forwarder",
-    constructorParams: [],
   });
   if (!forwarder) {
     return null;
@@ -19,7 +18,7 @@ export async function getDeployedCloneFactoryContract(args: ClientAndChain) {
   const cloneFactory = await getDeployedInfraContract({
     ...args,
     contractId: "TWCloneFactory",
-    constructorParams: [forwarder.address],
+    constructorParams: { _trustedForwarder: forwarder.address },
   });
   if (!cloneFactory) {
     return null;

package/src/contract/deployment/utils/infra.ts

@@ -1,10 +1,17 @@
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
 import { prepareTransaction } from "../../../transaction/prepare-transaction.js";
-import { computePublishedContractAddress } from "../../../utils/any-evm/compute-published-contract-address.js";
-import { computeDeploymentInfoFromContractId } from "../../../utils/any-evm/compute-published-contract-deploy-info.js";
+import { computeContractAddress } from "../../../utils/any-evm/compute-published-contract-address.js";
+import {
+  computeDeploymentInfoFromContractId,
+  computeDeploymentInfoFromMetadata,
+} from "../../../utils/any-evm/compute-published-contract-deploy-info.js";
+import type { FetchDeployMetadataResult } from "../../../utils/any-evm/deploy-metadata.js";
 import { isContractDeployed } from "../../../utils/bytecode/is-contract-deployed.js";
 import type { Prettify } from "../../../utils/type-utils.js";
 import type { ClientAndChain } from "../../../utils/types.js";
 import { type ThirdwebContract, getContract } from "../../contract.js";
+import { fetchPublishedContractMetadata } from "../publisher.js";
 import { computeCreate2FactoryAddress } from "./create-2-factory.js";
 
 export type InfraContractId =
@@ -17,7 +24,7 @@ export type InfraContractId =
 export type GetDeployedInfraParams = Prettify<
   ClientAndChain & {
     contractId: InfraContractId;
-    constructorParams: unknown[];
+    constructorParams?: Record<string, unknown>;
     publisher?: string;
     version?: string;
   }
@@ -29,9 +36,31 @@ export type GetDeployedInfraParams = Prettify<
 export async function getDeployedInfraContract(
   options: GetDeployedInfraParams,
 ): Promise<ThirdwebContract | null> {
-  const address = await computePublishedContractAddress({
-    ...options,
+  const contractMetadata = await fetchPublishedContractMetadata({
+    client: options.client,
+    contractId: options.contractId,
+    publisher: options.publisher,
+    version: options.version,
+  });
+  return getDeployedInfraContractFromMetadata({
+    client: options.client,
+    chain: options.chain,
+    contractMetadata,
+    constructorParams: options.constructorParams,
   });
+}
+
+/**
+ * @internal
+ */
+export async function getDeployedInfraContractFromMetadata(options: {
+  client: ThirdwebClient;
+  chain: Chain;
+  contractMetadata: FetchDeployMetadataResult;
+  constructorParams?: Record<string, unknown>;
+  salt?: string;
+}): Promise<ThirdwebContract | null> {
+  const address = await computeContractAddress(options);
   const factory = getContract({
     ...options,
     address,
@@ -64,3 +93,30 @@ export function prepareInfraContractDeployTransaction(
     },
   });
 }
+
+/**
+ * @internal
+ */
+export function prepareInfraContractDeployTransactionFromMetadata(options: {
+  client: ThirdwebClient;
+  chain: Chain;
+  contractMetadata: FetchDeployMetadataResult;
+  constructorParams?: Record<string, unknown>;
+  salt?: string;
+}) {
+  const { client, chain } = options;
+  return prepareTransaction({
+    client,
+    chain,
+    to: () =>
+      computeCreate2FactoryAddress({
+        client,
+        chain,
+      }),
+    data: async () => {
+      const infraContractInfo =
+        await computeDeploymentInfoFromMetadata(options);
+      return infraContractInfo.initBytecodeWithsalt;
+    },
+  });
+}

package/src/contract/deployment/zksync/zkDeployContract.ts

@@ -4,9 +4,11 @@ import { parseEventLogs } from "../../../event/actions/parse-logs.js";
 import { contractDeployedEvent } from "../../../extensions/zksync/__generated__/ContractDeployer/events/ContractDeployed.js";
 import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
 import { prepareTransaction } from "../../../transaction/prepare-transaction.js";
+import { normalizeFunctionParams } from "../../../utils/abi/normalizeFunctionParams.js";
 import { CONTRACT_DEPLOYER_ADDRESS } from "../../../utils/any-evm/zksync/constants.js";
 import type { Hex } from "../../../utils/encoding/hex.js";
 import type { ClientAndChainAndAccount } from "../../../utils/types.js";
+import { zkDeployContractDeterministic } from "./zkDeployDeterministic.js";
 
 /**
  * @internal
@@ -15,14 +17,23 @@ export async function zkDeployContract(
   options: ClientAndChainAndAccount & {
     abi: Abi;
     bytecode: Hex;
-    params?: unknown[];
+    params?: Record<string, unknown>;
+    salt?: string;
   },
 ) {
+  if (options.salt !== undefined) {
+    // if a salt is provided, use the deterministic deployer
+    return zkDeployContractDeterministic(options);
+  }
+
   const data = encodeDeployData({
     abi: options.abi,
     bytecode: options.bytecode,
     deploymentType: "create",
-    args: options.params,
+    args: normalizeFunctionParams(
+      options.abi.find((abi) => abi.type === "constructor"),
+      options.params,
+    ),
   });
 
   const receipt = await sendAndConfirmTransaction({

package/src/contract/deployment/zksync/zkDeployDeterministic.ts

@@ -1,9 +1,10 @@
-import { type Abi, parseAbi } from "abitype";
+import { type Abi, type AbiConstructor, parseAbi } from "abitype";
 import { hashBytecode } from "viem/zksync";
 import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
 import { prepareContractCall } from "../../../transaction/prepare-contract-call.js";
 import { readContract } from "../../../transaction/read-contract.js";
 import { encodeAbiParameters } from "../../../utils/abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "../../../utils/abi/normalizeFunctionParams.js";
 import { keccakId } from "../../../utils/any-evm/keccak-id.js";
 import { computeDeploymentAddress } from "../../../utils/any-evm/zksync/computeDeploymentAddress.js";
 import {
@@ -25,7 +26,7 @@ export async function zkDeployContractDeterministic(
   options: ClientAndChainAndAccount & {
     abi: Abi;
     bytecode: Hex;
-    params: unknown[];
+    params?: Record<string, unknown>;
     salt?: string;
   },
 ) {
@@ -34,7 +35,7 @@ export async function zkDeployContractDeterministic(
   ) || { inputs: [] };
   const encodedArgs = encodeAbiParameters(
     constructorAbi.inputs,
-    options.params || [],
+    normalizeFunctionParams(constructorAbi as AbiConstructor, options.params),
   );
   const create2FactoryAddress = await zkDeployCreate2Factory({
     client: options.client,

package/src/contract/deployment/zksync/zkDeployProxy.ts

@@ -44,10 +44,11 @@ export async function zkDeployProxy(
     account: options.account,
     abi: twProxyAbi,
     bytecode: twProxyBytecode,
-    params: [
-      implementationAddress,
-      await encode(options.initializeTransaction),
-    ],
+    params: {
+      _logic: implementationAddress,
+      _data: await encode(options.initializeTransaction),
+    },
+    salt: options.salt,
   });
 
   // return address of proxy

package/src/exports/deploys.ts

@@ -19,6 +19,17 @@ export {
   deployERC1155Contract,
 } from "../extensions/prebuilts/deploy-erc1155.js";
 
+export {
+  deploySplitContract,
+  type SplitContractParams,
+  type DeploySplitContractOptions,
+} from "../extensions/prebuilts/deploy-split.js";
+
+export {
+  deployMarketplaceContract,
+  type MarketplaceContractParams,
+} from "../extensions/prebuilts/deploy-marketplace.js";
+
 export {
   deployPublishedContract,
   type DeployPublishedContractOptions,
@@ -35,8 +46,4 @@ export {
   type PrepareDirectDeployTransactionOptions,
 } from "../contract/deployment/deploy-with-abi.js";
 export { computePublishedContractAddress } from "../utils/any-evm/compute-published-contract-address.js";
-export {
-  deploySplitContract,
-  type SplitContractParams,
-  type DeploySplitContractOptions,
-} from "../extensions/prebuilts/deploy-split.js";
+export { getRequiredTransactionCount } from "../extensions/prebuilts/get-required-transactions.js";

package/src/exports/utils.ts

@@ -181,3 +181,5 @@ export { parseAbiParams } from "../utils/contract/parse-abi-params.js";
 // bigint
 // ------------------------------------------------
 export { max, min } from "../utils/bigint.js";
+
+export { toFunctionSelector } from "viem";

package/src/extensions/airdrop/write/airdropERC1155WithSignature.test.ts

@@ -39,7 +39,10 @@ describe
           chain: ANVIL_CHAIN,
           client: TEST_CLIENT,
           contractId: "Airdrop",
-          contractParams: [TEST_ACCOUNT_A.address, ""],
+          contractParams: {
+            defaultAdmin: TEST_ACCOUNT_A.address,
+            contractURI: "",
+          },
         }),
         chain: ANVIL_CHAIN,
         client: TEST_CLIENT,

package/src/extensions/airdrop/write/airdropERC20WithSignature.test.ts

@@ -37,7 +37,10 @@ describe
           chain: ANVIL_CHAIN,
           client: TEST_CLIENT,
           contractId: "Airdrop",
-          contractParams: [TEST_ACCOUNT_A.address, ""],
+          contractParams: {
+            defaultAdmin: TEST_ACCOUNT_A.address,
+            contractURI: "",
+          },
         }),
         chain: ANVIL_CHAIN,
         client: TEST_CLIENT,

package/src/extensions/airdrop/write/airdropERC721WithSignature.test.ts

@@ -39,7 +39,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           chain: ANVIL_CHAIN,
           client: TEST_CLIENT,
           contractId: "Airdrop",
-          contractParams: [TEST_ACCOUNT_A.address, ""],
+          contractParams: {
+            defaultAdmin: TEST_ACCOUNT_A.address,
+            contractURI: "",
+          },
         }),
         chain: ANVIL_CHAIN,
         client: TEST_CLIENT,

package/src/extensions/airdrop/write/claimERC1155.test.ts

@@ -38,7 +38,10 @@ describe.runIf(process.env.TW_SECRET_KEY).skip("claimERC1155", () => {
         client: TEST_CLIENT,
         contractId: "Airdrop",
         publisher: "0xFD78F7E2dF2B8c3D5bff0413c96f3237500898B3",
-        contractParams: [TEST_ACCOUNT_A.address, ""],
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address,
+          contractURI: "",
+        },
       }),
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,

package/src/extensions/airdrop/write/claimERC20.test.ts

@@ -36,7 +36,10 @@ describe.runIf(process.env.TW_SECRET_KEY).skip("claimERC20", () => {
         client: TEST_CLIENT,
         contractId: "Airdrop",
         publisher: "0xFD78F7E2dF2B8c3D5bff0413c96f3237500898B3",
-        contractParams: [TEST_ACCOUNT_A.address, ""],
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address,
+          contractURI: "",
+        },
       }),
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,

package/src/extensions/airdrop/write/claimERC721.test.ts

@@ -38,7 +38,10 @@ describe.runIf(process.env.TW_SECRET_KEY).skip("claimERC721", () => {
         client: TEST_CLIENT,
         contractId: "Airdrop",
         publisher: "0xFD78F7E2dF2B8c3D5bff0413c96f3237500898B3",
-        contractParams: [TEST_ACCOUNT_A.address, ""],
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address,
+          contractURI: "",
+        },
       }),
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,

package/src/extensions/erc1155/write/updateTokenURI.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { ANVIL_CHAIN } from "~test/chains.js";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+import { getContract } from "../../../contract/contract.js";
+import { deployERC1155Contract } from "../../../extensions/prebuilts/deploy-erc1155.js";
+import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import { getNFT } from "../read/getNFT.js";
+import { mintTo } from "./mintTo.js";
+import { updateTokenURI } from "./updateTokenURI.js";
+
+const client = TEST_CLIENT;
+const chain = ANVIL_CHAIN;
+const account = TEST_ACCOUNT_A;
+
+describe.runIf(process.env.TW_SECRET_KEY)("Edition: Update token uri", () => {
+  it("should update token uri", async () => {
+    const address = await deployERC1155Contract({
+      client,
+      chain,
+      account,
+      type: "TokenERC1155",
+      params: {
+        name: "Edition",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const contract = getContract({
+      address,
+      client,
+      chain,
+    });
+    await sendAndConfirmTransaction({
+      transaction: mintTo({
+        contract,
+        nft: { name: "Test1" },
+        to: account.address,
+        supply: 1n,
+      }),
+      account,
+    });
+    await sendAndConfirmTransaction({
+      transaction: updateTokenURI({
+        contract,
+        newMetadata: { name: "Test1 Updated" },
+        tokenId: 0n,
+      }),
+      account,
+    });
+    const nft = await getNFT({ contract, tokenId: 0n });
+    expect(nft.metadata.name).toBe("Test1 Updated");
+  });
+});

package/src/extensions/erc20/write/getApprovalForTransaction.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { ANVIL_CHAIN } from "~test/chains.js";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A, TEST_ACCOUNT_B } from "~test/test-wallets.js";
+import { getContract } from "../../../contract/contract.js";
+import { lazyMint } from "../../../extensions/erc721/write/lazyMint.js";
+import { deployERC20Contract } from "../../../extensions/prebuilts/deploy-erc20.js";
+import { deployERC721Contract } from "../../../extensions/prebuilts/deploy-erc721.js";
+import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import { claimTo } from "../../erc721/drops/write/claimTo.js";
+import { setClaimConditions } from "../../erc721/drops/write/setClaimConditions.js";
+import { getApprovalForTransaction } from "./getApprovalForTransaction.js";
+
+const chain = ANVIL_CHAIN;
+const client = TEST_CLIENT;
+const account = TEST_ACCOUNT_A;
+
+describe.runIf(process.env.TW_SECRET_KEY)(
+  "erc20: getApporvalForTransaction",
+  () => {
+    it("should return an approval tx", async () => {
+      const currencyAddress = await deployERC20Contract({
+        chain,
+        client,
+        account,
+        type: "TokenERC20",
+        params: { name: "erc20token", contractURI: TEST_CONTRACT_URI },
+      });
+      const contract = getContract({
+        address: await deployERC721Contract({
+          client,
+          chain,
+          account,
+          type: "DropERC721",
+          params: { name: "", contractURI: TEST_CONTRACT_URI },
+        }),
+        chain,
+        client,
+      });
+      await sendAndConfirmTransaction({
+        transaction: lazyMint({ contract, nfts: [{ name: "token 0" }] }),
+        account,
+      });
+      await sendAndConfirmTransaction({
+        transaction: setClaimConditions({
+          contract,
+          phases: [
+            {
+              maxClaimableSupply: 100n,
+              maxClaimablePerWallet: 1n,
+              currencyAddress,
+              price: 1,
+              startTime: new Date(),
+            },
+          ],
+        }),
+        account,
+      });
+      const approveTx = await getApprovalForTransaction({
+        transaction: claimTo({
+          contract,
+          to: TEST_ACCOUNT_B.address,
+          quantity: 1n,
+        }),
+        account,
+      });
+      expect(approveTx?.to).toBe(currencyAddress);
+    });
+
+    it("should return NULL", async () => {
+      const contract = getContract({
+        address: await deployERC721Contract({
+          client,
+          chain,
+          account,
+          type: "DropERC721",
+          params: { name: "", contractURI: TEST_CONTRACT_URI },
+        }),
+        chain,
+        client,
+      });
+      await sendAndConfirmTransaction({
+        transaction: lazyMint({ contract, nfts: [{ name: "token 0" }] }),
+        account,
+      });
+      await sendAndConfirmTransaction({
+        transaction: setClaimConditions({
+          contract,
+          phases: [
+            {
+              maxClaimableSupply: 100n,
+              maxClaimablePerWallet: 1n,
+              price: 1,
+              startTime: new Date(),
+            },
+          ],
+        }),
+        account,
+      });
+      const approveTx = await getApprovalForTransaction({
+        transaction: claimTo({
+          contract,
+          to: TEST_ACCOUNT_B.address,
+          quantity: 1n,
+        }),
+        account,
+      });
+      expect(approveTx).toBe(null);
+    });
+  },
+);

package/src/extensions/erc20/write/transferFrom.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import { ANVIL_CHAIN } from "~test/chains.js";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A, TEST_ACCOUNT_B } from "~test/test-wallets.js";
+import { getContract } from "../../../contract/contract.js";
+import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import { deployERC20Contract } from "../../prebuilts/deploy-erc20.js";
+import { balanceOf } from "../__generated__/IERC20/read/balanceOf.js";
+import { approve } from "./approve.js";
+import { mintTo } from "./mintTo.js";
+import { transferFrom } from "./transferFrom.js";
+
+const chain = ANVIL_CHAIN;
+const client = TEST_CLIENT;
+const account = TEST_ACCOUNT_A;
+
+describe.runIf(process.env.TW_SECRET_KEY)("ERC20 transferFrom", () => {
+  it("should work with `amount`", async () => {
+    const contract = getContract({
+      address: await deployERC20Contract({
+        chain,
+        client,
+        account,
+        params: {
+          name: "erc20token",
+          contractURI: TEST_CONTRACT_URI,
+        },
+        type: "TokenERC20",
+      }),
+      client,
+      chain,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: mintTo({ contract, to: account.address, amount: 1000 }),
+      account,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: approve({ contract, amount: 999, spender: account.address }),
+      account,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: transferFrom({
+        contract,
+        amount: 999,
+        to: TEST_ACCOUNT_B.address,
+        from: account.address,
+      }),
+      account,
+    });
+
+    const balance = await balanceOf({
+      contract,
+      address: TEST_ACCOUNT_B.address,
+    });
+    expect(balance).toBe(999n * 10n ** 18n);
+  });
+
+  it("should work with `amountWei`", async () => {
+    const contract = getContract({
+      address: await deployERC20Contract({
+        chain,
+        client,
+        account,
+        params: {
+          name: "erc20token",
+          contractURI: TEST_CONTRACT_URI,
+        },
+        type: "TokenERC20",
+      }),
+      client,
+      chain,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: mintTo({ contract, to: account.address, amount: 1000 }),
+      account,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: approve({ contract, amount: 999, spender: account.address }),
+      account,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: transferFrom({
+        contract,
+        amountWei: 999n * 10n ** 18n,
+        to: TEST_ACCOUNT_B.address,
+        from: account.address,
+      }),
+      account,
+    });
+
+    const balance = await balanceOf({
+      contract,
+      address: TEST_ACCOUNT_B.address,
+    });
+    expect(balance).toBe(999n * 10n ** 18n);
+  });
+});

package/src/extensions/erc4337/account/permissions.test.ts

@@ -34,7 +34,10 @@ describe.runIf(process.env.TW_SECRET_KEY)("Account Permissions", () => {
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,
       contractId: "AccountFactory",
-      constructorParams: [TEST_ACCOUNT_A.address, ENTRYPOINT_ADDRESS_v0_6],
+      constructorParams: {
+        defaultAdmin: TEST_ACCOUNT_A.address,
+        entrypoint: ENTRYPOINT_ADDRESS_v0_6,
+      },
     });
     const transaction = createAccount({
       contract: accountFactoryContract,

package/src/extensions/erc721/drops/write/updateMetadata.test.ts

@@ -53,4 +53,33 @@ describe.runIf(process.env.TW_SECRET_KEY)("updateMetadata ERC721", () => {
     expect(nfts[1]?.metadata.name).toBe("token 1 - updated");
     expect(nfts[2]?.metadata.name).toBe("token 2");
   });
+
+  it("should throw if no nft uploaded", async () => {
+    const address = await deployERC721Contract({
+      client,
+      chain,
+      account,
+      type: "DropERC721",
+      params: {
+        name: "NFT Drop",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const contract = getContract({
+      address,
+      client,
+      chain,
+    });
+    const updateTx = updateMetadata({
+      contract,
+      targetTokenId: 0n,
+      newMetadata: { name: "token 1 - updated" },
+      client,
+    });
+    await expect(
+      sendAndConfirmTransaction({ transaction: updateTx, account }),
+    ).rejects.toThrowError(
+      "No base URI set. Please set a base URI before updating metadata",
+    );
+  });
 });