thirdweb 5.38.1-nightly-c82c524e139d7960794e08bca838a1a1b78a3532-20240725000333 → 5.39.0

package/src/extensions/modular/__generated__/SimpleMetadataERC721/read/getExtensionConfig.ts

@@ -0,0 +1,122 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0x7c173ecc" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    name: "config",
+    type: "tuple",
+    internalType: "struct IExtensionConfig.ExtensionConfig",
+    components: [
+      {
+        name: "registerInstallationCallback",
+        type: "bool",
+        internalType: "bool",
+      },
+      {
+        name: "requiredInterfaces",
+        type: "bytes4[]",
+        internalType: "bytes4[]",
+      },
+      {
+        name: "supportedInterfaces",
+        type: "bytes4[]",
+        internalType: "bytes4[]",
+      },
+      {
+        name: "callbackFunctions",
+        type: "tuple[]",
+        internalType: "struct IExtensionConfig.CallbackFunction[]",
+        components: [
+          {
+            name: "selector",
+            type: "bytes4",
+            internalType: "bytes4",
+          },
+        ],
+      },
+      {
+        name: "fallbackFunctions",
+        type: "tuple[]",
+        internalType: "struct IExtensionConfig.FallbackFunction[]",
+        components: [
+          {
+            name: "selector",
+            type: "bytes4",
+            internalType: "bytes4",
+          },
+          {
+            name: "permissionBits",
+            type: "uint256",
+            internalType: "uint256",
+          },
+        ],
+      },
+    ],
+  },
+] as const;
+
+/**
+ * Checks if the `getExtensionConfig` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `getExtensionConfig` method is supported.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { isGetExtensionConfigSupported } from "thirdweb/extensions/modular";
+ *
+ * const supported = await isGetExtensionConfigSupported(contract);
+ * ```
+ */
+export async function isGetExtensionConfigSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the getExtensionConfig function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { decodeGetExtensionConfigResult } from "thirdweb/extensions/modular";
+ * const result = decodeGetExtensionConfigResult("...");
+ * ```
+ */
+export function decodeGetExtensionConfigResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "getExtensionConfig" function on the contract.
+ * @param options - The options for the getExtensionConfig function.
+ * @returns The parsed result of the function call.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { getExtensionConfig } from "thirdweb/extensions/modular";
+ *
+ * const result = await getExtensionConfig({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function getExtensionConfig(options: BaseTransactionOptions) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}

package/src/extensions/modular/__generated__/SimpleMetadataERC721/read/onTokenURI.ts

@@ -0,0 +1,134 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "onTokenURI" function.
+ */
+export type OnTokenURIParams = {
+  id: AbiParameterToPrimitiveType<{
+    name: "_id";
+    type: "uint256";
+    internalType: "uint256";
+  }>;
+};
+
+export const FN_SELECTOR = "0xcfc0cb96" as const;
+const FN_INPUTS = [
+  {
+    name: "_id",
+    type: "uint256",
+    internalType: "uint256",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    name: "uri",
+    type: "string",
+    internalType: "string",
+  },
+] as const;
+
+/**
+ * Checks if the `onTokenURI` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `onTokenURI` method is supported.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { isOnTokenURISupported } from "thirdweb/extensions/modular";
+ *
+ * const supported = await isOnTokenURISupported(contract);
+ * ```
+ */
+export async function isOnTokenURISupported(contract: ThirdwebContract<any>) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "onTokenURI" function.
+ * @param options - The options for the onTokenURI function.
+ * @returns The encoded ABI parameters.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { encodeOnTokenURIParams } "thirdweb/extensions/modular";
+ * const result = encodeOnTokenURIParams({
+ *  id: ...,
+ * });
+ * ```
+ */
+export function encodeOnTokenURIParams(options: OnTokenURIParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.id]);
+}
+
+/**
+ * Encodes the "onTokenURI" function into a Hex string with its parameters.
+ * @param options - The options for the onTokenURI function.
+ * @returns The encoded hexadecimal string.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { encodeOnTokenURI } "thirdweb/extensions/modular";
+ * const result = encodeOnTokenURI({
+ *  id: ...,
+ * });
+ * ```
+ */
+export function encodeOnTokenURI(options: OnTokenURIParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeOnTokenURIParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the onTokenURI function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { decodeOnTokenURIResult } from "thirdweb/extensions/modular";
+ * const result = decodeOnTokenURIResult("...");
+ * ```
+ */
+export function decodeOnTokenURIResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "onTokenURI" function on the contract.
+ * @param options - The options for the onTokenURI function.
+ * @returns The parsed result of the function call.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { onTokenURI } from "thirdweb/extensions/modular";
+ *
+ * const result = await onTokenURI({
+ *  contract,
+ *  id: ...,
+ * });
+ *
+ * ```
+ */
+export async function onTokenURI(
+  options: BaseTransactionOptions<OnTokenURIParams>,
+) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.id],
+  });
+}

package/src/extensions/modular/__generated__/SimpleMetadataERC721/write/setTokenURI.ts

@@ -0,0 +1,155 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { once } from "../../../../../utils/promise/once.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "setTokenURI" function.
+ */
+export type SetTokenURIParams = WithOverrides<{
+  id: AbiParameterToPrimitiveType<{
+    name: "_id";
+    type: "uint256";
+    internalType: "uint256";
+  }>;
+  uri: AbiParameterToPrimitiveType<{
+    name: "_uri";
+    type: "string";
+    internalType: "string";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0x162094c4" as const;
+const FN_INPUTS = [
+  {
+    name: "_id",
+    type: "uint256",
+    internalType: "uint256",
+  },
+  {
+    name: "_uri",
+    type: "string",
+    internalType: "string",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `setTokenURI` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `setTokenURI` method is supported.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { isSetTokenURISupported } from "thirdweb/extensions/modular";
+ *
+ * const supported = await isSetTokenURISupported(contract);
+ * ```
+ */
+export async function isSetTokenURISupported(contract: ThirdwebContract<any>) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "setTokenURI" function.
+ * @param options - The options for the setTokenURI function.
+ * @returns The encoded ABI parameters.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { encodeSetTokenURIParams } "thirdweb/extensions/modular";
+ * const result = encodeSetTokenURIParams({
+ *  id: ...,
+ *  uri: ...,
+ * });
+ * ```
+ */
+export function encodeSetTokenURIParams(options: SetTokenURIParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.id, options.uri]);
+}
+
+/**
+ * Encodes the "setTokenURI" function into a Hex string with its parameters.
+ * @param options - The options for the setTokenURI function.
+ * @returns The encoded hexadecimal string.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { encodeSetTokenURI } "thirdweb/extensions/modular";
+ * const result = encodeSetTokenURI({
+ *  id: ...,
+ *  uri: ...,
+ * });
+ * ```
+ */
+export function encodeSetTokenURI(options: SetTokenURIParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeSetTokenURIParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "setTokenURI" function on the contract.
+ * @param options - The options for the "setTokenURI" function.
+ * @returns A prepared transaction object.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { setTokenURI } from "thirdweb/extensions/modular";
+ *
+ * const transaction = setTokenURI({
+ *  contract,
+ *  id: ...,
+ *  uri: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function setTokenURI(
+  options: BaseTransactionOptions<
+    | SetTokenURIParams
+    | {
+        asyncParams: () => Promise<SetTokenURIParams>;
+      }
+  >,
+) {
+  const asyncOptions = once(async () => {
+    return "asyncParams" in options ? await options.asyncParams() : options;
+  });
+
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: async () => {
+      const resolvedOptions = await asyncOptions();
+      return [resolvedOptions.id, resolvedOptions.uri] as const;
+    },
+    value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    nonce: async () => (await asyncOptions()).overrides?.nonce,
+    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+  });
+}

package/src/gas/fee-data.ts

@@ -107,7 +107,10 @@ export async function getDefaultGasOverrides(
   // if chain is in the force gas price list, always use gas price
   if (!FORCE_GAS_PRICE_CHAIN_IDS.includes(chain.id)) {
     const feeData = await getDynamicFeeData(client, chain);
-    if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
+    if (
+      feeData.maxFeePerGas !== null &&
+      feeData.maxPriorityFeePerGas !== null
+    ) {
       return {
         maxFeePerGas: feeData.maxFeePerGas,
         maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
@@ -153,12 +156,12 @@ async function getDynamicFeeData(
   if (chainId === 80002 || chainId === 137) {
     // for polygon, get fee data from gas station
     maxPriorityFeePerGas_ = await getPolygonGasPriorityFee(chainId);
-  } else if (maxPriorityFeePerGas) {
+  } else if (maxPriorityFeePerGas !== null) {
     // prioritize fee from eth_maxPriorityFeePerGas
     maxPriorityFeePerGas_ = maxPriorityFeePerGas;
   }
 
-  if (!maxPriorityFeePerGas_) {
+  if (maxPriorityFeePerGas_ == null) {
     // chain does not support eip-1559, return null for both
     return { maxFeePerGas: null, maxPriorityFeePerGas: null };
   }

package/src/react/web/ui/prebuilt/thirdweb/ClaimButton/ClaimButton.test.tsx

@@ -9,7 +9,6 @@ import { getContract } from "../../../../../../contract/contract.js";
 import { deployERC20Contract } from "../../../../../../extensions/prebuilts/deploy-erc20.js";
 import { deployERC721Contract } from "../../../../../../extensions/prebuilts/deploy-erc721.js";
 import { deployERC1155Contract } from "../../../../../../extensions/prebuilts/deploy-erc1155.js";
-import type { Hex } from "../../../../../../utils/encoding/helpers/is-hex.js";
 import {
   ClaimButton,
   getERC20ClaimTo,
@@ -77,7 +76,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("ClaimButton", () => {
       <ClaimButton
         client={client}
         chain={chain}
-        contractAddress={address as Hex}
+        contractAddress={address}
         claimParams={{ quantity: 1n, type: "ERC721" }}
       >
         Claim
@@ -151,7 +150,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("ClaimButton", () => {
       <ClaimButton
         client={client}
         chain={chain}
-        contractAddress={address as Hex}
+        contractAddress={address}
         claimParams={{ quantity: 1n, type: "ERC1155", tokenId: 0n }}
       >
         Claim
@@ -222,7 +221,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("ClaimButton", () => {
       <ClaimButton
         client={client}
         chain={chain}
-        contractAddress={address as Hex}
+        contractAddress={address}
         claimParams={{ quantity: "100", type: "ERC20" }}
       >
         Claim
@@ -259,7 +258,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("ClaimButton", () => {
       <ClaimButton
         client={client}
         chain={chain}
-        contractAddress={address as Hex}
+        contractAddress={address}
         claimParams={{ quantityInWei: 1000000n, type: "ERC20" }}
       >
         Claim

package/src/react/web/ui/prebuilt/thirdweb/ClaimButton/index.tsx

@@ -87,6 +87,7 @@ export function ClaimButton(props: ClaimButtonProps) {
     chain,
   });
   const account = useActiveAccount();
+  // TODO (pay): fetch nft metadata and set it as the payOptions metadata
   return (
     <TransactionButton
       transaction={async () =>

package/src/rpc/rpc.ts

@@ -61,12 +61,10 @@ export function getRpcClient(
   options: RPCOptions,
 ): EIP1193RequestFn<EIP1474Methods> {
   const rpcClientMap = getRpcClientMap(options.client);
-  const chainId = options.chain.id;
+  const rpcUrl = options.chain.rpc;
 
-  if (rpcClientMap.has(options.chain.rpc)) {
-    return rpcClientMap.get(
-      options.chain.rpc,
-    ) as EIP1193RequestFn<EIP1474Methods>;
+  if (rpcClientMap.has(rpcUrl)) {
+    return rpcClientMap.get(rpcUrl) as EIP1193RequestFn<EIP1474Methods>;
   }
 
   const rpcClient: EIP1193RequestFn<EIP1474Methods> = (() => {
@@ -242,6 +240,6 @@ export function getRpcClient(
     };
   })();
 
-  rpcClientMap.set(chainId, rpcClient);
+  rpcClientMap.set(rpcUrl, rpcClient);
   return rpcClient as EIP1193RequestFn<EIP1474Methods>;
 }

package/src/transaction/actions/to-serializable-transaction.test.ts

@@ -4,6 +4,8 @@ import { TEST_WALLET_B } from "../../../test/src/addresses.js";
 import { FORKED_ETHEREUM_CHAIN } from "../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 
+import { arbitrumSepolia } from "../../chains/chain-definitions/arbitrum-sepolia.js";
+import { ZERO_ADDRESS } from "../../constants/addresses.js";
 import { toWei } from "../../utils/units.js";
 import {
   type PreparedTransaction,
@@ -400,4 +402,19 @@ describe("toSerializableTransaction", () => {
       ).not.toThrow();
     });
   });
+
+  test("should respect 0 maxPriorityFeePerGas chains", async () => {
+    const serializableTransaction = await toSerializableTransaction({
+      transaction: prepareTransaction({
+        to: TEST_WALLET_B,
+        chain: arbitrumSepolia,
+        value: toWei("0.000001"),
+        client: TEST_CLIENT,
+      }),
+      from: ZERO_ADDRESS,
+    });
+
+    // gasPrice should be undefined for arbSepolia which has 0 maxPriorityFeePerGas
+    expect(serializableTransaction.gasPrice).toBe(undefined);
+  });
 });

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.38.1-nightly-c82c524e139d7960794e08bca838a1a1b78a3532-20240725000333";
+export const version = "5.39.0";