thirdweb 5.72.0-nightly-f64e0253d7de6fdb6f56ab49315cc4cdcdd75b20-20241127000345 → 5.72.0-nightly-e87eb2ff35eea1b94ab7bdae3585d819879ec53c-20241128000350

package/src/extensions/erc721/__generated__/Multiwrap/write/initialize.ts

@@ -0,0 +1,216 @@
+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 { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "initialize" function.
+ */
+export type InitializeParams = WithOverrides<{
+  defaultAdmin: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "_defaultAdmin";
+  }>;
+  name: AbiParameterToPrimitiveType<{ type: "string"; name: "_name" }>;
+  symbol: AbiParameterToPrimitiveType<{ type: "string"; name: "_symbol" }>;
+  contractURI: AbiParameterToPrimitiveType<{
+    type: "string";
+    name: "_contractURI";
+  }>;
+  trustedForwarders: AbiParameterToPrimitiveType<{
+    type: "address[]";
+    name: "_trustedForwarders";
+  }>;
+  royaltyRecipient: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "_royaltyRecipient";
+  }>;
+  royaltyBps: AbiParameterToPrimitiveType<{
+    type: "uint256";
+    name: "_royaltyBps";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0x754b8fe7" as const;
+const FN_INPUTS = [
+  {
+    type: "address",
+    name: "_defaultAdmin",
+  },
+  {
+    type: "string",
+    name: "_name",
+  },
+  {
+    type: "string",
+    name: "_symbol",
+  },
+  {
+    type: "string",
+    name: "_contractURI",
+  },
+  {
+    type: "address[]",
+    name: "_trustedForwarders",
+  },
+  {
+    type: "address",
+    name: "_royaltyRecipient",
+  },
+  {
+    type: "uint256",
+    name: "_royaltyBps",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `initialize` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `initialize` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isInitializeSupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = isInitializeSupported(["0x..."]);
+ * ```
+ */
+export function isInitializeSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "initialize" function.
+ * @param options - The options for the initialize function.
+ * @returns The encoded ABI parameters.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeInitializeParams } from "thirdweb/extensions/erc721";
+ * const result = encodeInitializeParams({
+ *  defaultAdmin: ...,
+ *  name: ...,
+ *  symbol: ...,
+ *  contractURI: ...,
+ *  trustedForwarders: ...,
+ *  royaltyRecipient: ...,
+ *  royaltyBps: ...,
+ * });
+ * ```
+ */
+export function encodeInitializeParams(options: InitializeParams) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.defaultAdmin,
+    options.name,
+    options.symbol,
+    options.contractURI,
+    options.trustedForwarders,
+    options.royaltyRecipient,
+    options.royaltyBps,
+  ]);
+}
+
+/**
+ * Encodes the "initialize" function into a Hex string with its parameters.
+ * @param options - The options for the initialize function.
+ * @returns The encoded hexadecimal string.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeInitialize } from "thirdweb/extensions/erc721";
+ * const result = encodeInitialize({
+ *  defaultAdmin: ...,
+ *  name: ...,
+ *  symbol: ...,
+ *  contractURI: ...,
+ *  trustedForwarders: ...,
+ *  royaltyRecipient: ...,
+ *  royaltyBps: ...,
+ * });
+ * ```
+ */
+export function encodeInitialize(options: InitializeParams) {
+  // 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 +
+    encodeInitializeParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "initialize" function on the contract.
+ * @param options - The options for the "initialize" function.
+ * @returns A prepared transaction object.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { sendTransaction } from "thirdweb";
+ * import { initialize } from "thirdweb/extensions/erc721";
+ *
+ * const transaction = initialize({
+ *  contract,
+ *  defaultAdmin: ...,
+ *  name: ...,
+ *  symbol: ...,
+ *  contractURI: ...,
+ *  trustedForwarders: ...,
+ *  royaltyRecipient: ...,
+ *  royaltyBps: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function initialize(
+  options: BaseTransactionOptions<
+    | InitializeParams
+    | {
+        asyncParams: () => Promise<InitializeParams>;
+      }
+  >,
+) {
+  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.defaultAdmin,
+        resolvedOptions.name,
+        resolvedOptions.symbol,
+        resolvedOptions.contractURI,
+        resolvedOptions.trustedForwarders,
+        resolvedOptions.royaltyRecipient,
+        resolvedOptions.royaltyBps,
+      ] 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,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+  });
+}

package/src/extensions/erc721/__generated__/Multiwrap/write/unwrap.ts

@@ -0,0 +1,146 @@
+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 { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "unwrap" function.
+ */
+export type UnwrapParams = WithOverrides<{
+  tokenId: AbiParameterToPrimitiveType<{ type: "uint256"; name: "_tokenId" }>;
+  recipient: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "_recipient";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0x7647691d" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "_tokenId",
+  },
+  {
+    type: "address",
+    name: "_recipient",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `unwrap` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `unwrap` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isUnwrapSupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = isUnwrapSupported(["0x..."]);
+ * ```
+ */
+export function isUnwrapSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "unwrap" function.
+ * @param options - The options for the unwrap function.
+ * @returns The encoded ABI parameters.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeUnwrapParams } from "thirdweb/extensions/erc721";
+ * const result = encodeUnwrapParams({
+ *  tokenId: ...,
+ *  recipient: ...,
+ * });
+ * ```
+ */
+export function encodeUnwrapParams(options: UnwrapParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.tokenId, options.recipient]);
+}
+
+/**
+ * Encodes the "unwrap" function into a Hex string with its parameters.
+ * @param options - The options for the unwrap function.
+ * @returns The encoded hexadecimal string.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeUnwrap } from "thirdweb/extensions/erc721";
+ * const result = encodeUnwrap({
+ *  tokenId: ...,
+ *  recipient: ...,
+ * });
+ * ```
+ */
+export function encodeUnwrap(options: UnwrapParams) {
+  // 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 +
+    encodeUnwrapParams(options).slice(2)) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "unwrap" function on the contract.
+ * @param options - The options for the "unwrap" function.
+ * @returns A prepared transaction object.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { sendTransaction } from "thirdweb";
+ * import { unwrap } from "thirdweb/extensions/erc721";
+ *
+ * const transaction = unwrap({
+ *  contract,
+ *  tokenId: ...,
+ *  recipient: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function unwrap(
+  options: BaseTransactionOptions<
+    | UnwrapParams
+    | {
+        asyncParams: () => Promise<UnwrapParams>;
+      }
+  >,
+) {
+  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.tokenId, resolvedOptions.recipient] 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,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+  });
+}

package/src/extensions/erc721/__generated__/Multiwrap/write/wrap.ts

@@ -0,0 +1,197 @@
+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 { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "wrap" function.
+ */
+export type WrapParams = WithOverrides<{
+  tokensToWrap: AbiParameterToPrimitiveType<{
+    type: "tuple[]";
+    name: "_tokensToWrap";
+    components: [
+      { type: "address"; name: "assetContract" },
+      { type: "uint8"; name: "tokenType" },
+      { type: "uint256"; name: "tokenId" },
+      { type: "uint256"; name: "amount" },
+    ];
+  }>;
+  uriForWrappedToken: AbiParameterToPrimitiveType<{
+    type: "string";
+    name: "_uriForWrappedToken";
+  }>;
+  recipient: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "_recipient";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0x29e471dd" as const;
+const FN_INPUTS = [
+  {
+    type: "tuple[]",
+    name: "_tokensToWrap",
+    components: [
+      {
+        type: "address",
+        name: "assetContract",
+      },
+      {
+        type: "uint8",
+        name: "tokenType",
+      },
+      {
+        type: "uint256",
+        name: "tokenId",
+      },
+      {
+        type: "uint256",
+        name: "amount",
+      },
+    ],
+  },
+  {
+    type: "string",
+    name: "_uriForWrappedToken",
+  },
+  {
+    type: "address",
+    name: "_recipient",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "uint256",
+    name: "tokenId",
+  },
+] as const;
+
+/**
+ * Checks if the `wrap` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `wrap` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isWrapSupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = isWrapSupported(["0x..."]);
+ * ```
+ */
+export function isWrapSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "wrap" function.
+ * @param options - The options for the wrap function.
+ * @returns The encoded ABI parameters.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeWrapParams } from "thirdweb/extensions/erc721";
+ * const result = encodeWrapParams({
+ *  tokensToWrap: ...,
+ *  uriForWrappedToken: ...,
+ *  recipient: ...,
+ * });
+ * ```
+ */
+export function encodeWrapParams(options: WrapParams) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.tokensToWrap,
+    options.uriForWrappedToken,
+    options.recipient,
+  ]);
+}
+
+/**
+ * Encodes the "wrap" function into a Hex string with its parameters.
+ * @param options - The options for the wrap function.
+ * @returns The encoded hexadecimal string.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeWrap } from "thirdweb/extensions/erc721";
+ * const result = encodeWrap({
+ *  tokensToWrap: ...,
+ *  uriForWrappedToken: ...,
+ *  recipient: ...,
+ * });
+ * ```
+ */
+export function encodeWrap(options: WrapParams) {
+  // 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 +
+    encodeWrapParams(options).slice(2)) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "wrap" function on the contract.
+ * @param options - The options for the "wrap" function.
+ * @returns A prepared transaction object.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { sendTransaction } from "thirdweb";
+ * import { wrap } from "thirdweb/extensions/erc721";
+ *
+ * const transaction = wrap({
+ *  contract,
+ *  tokensToWrap: ...,
+ *  uriForWrappedToken: ...,
+ *  recipient: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function wrap(
+  options: BaseTransactionOptions<
+    | WrapParams
+    | {
+        asyncParams: () => Promise<WrapParams>;
+      }
+  >,
+) {
+  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.tokensToWrap,
+        resolvedOptions.uriForWrappedToken,
+        resolvedOptions.recipient,
+      ] 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,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+  });
+}

package/src/extensions/prebuilts/deploy-erc721.test.ts

@@ -8,8 +8,6 @@ import { deployERC721Contract } from "./deploy-erc721.js";
 
 const account = TEST_ACCOUNT_B;
 
-// skip this test suite if there is no secret key available to test with
-// TODO: remove reliance on secret key during unit tests entirely
 describe.runIf(process.env.TW_SECRET_KEY)("deployERC721", () => {
   it("should deploy ERC721 open edition", async () => {
     const address = await deployERC721Contract({
@@ -21,6 +19,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("deployERC721", () => {
         name: "OE",
       },
     });
+
     expect(address).toBeDefined();
     const deployedName = await name({
       contract: getContract({
@@ -31,4 +30,73 @@ describe.runIf(process.env.TW_SECRET_KEY)("deployERC721", () => {
     });
     expect(deployedName).toBe("OE");
   });
+
+  it("should deploy ERC721 drop", async () => {
+    const address = await deployERC721Contract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account,
+      type: "DropERC721",
+      params: {
+        name: "Drop",
+        symbol: "DRP",
+      },
+    });
+
+    expect(address).toBeDefined();
+    const deployedName = await name({
+      contract: getContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        address,
+      }),
+    });
+    expect(deployedName).toBe("Drop");
+  });
+
+  it("should deploy ERC721 token", async () => {
+    const address = await deployERC721Contract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account,
+      type: "TokenERC721",
+      params: {
+        name: "Token",
+        symbol: "TKN",
+      },
+    });
+
+    expect(address).toBeDefined();
+    const deployedName = await name({
+      contract: getContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        address,
+      }),
+    });
+    expect(deployedName).toBe("Token");
+  });
+
+  it("should deploy ERC721 loyalty card", async () => {
+    const address = await deployERC721Contract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account,
+      type: "LoyaltyCard",
+      params: {
+        name: "Loyalty",
+        symbol: "LOY",
+      },
+    });
+
+    expect(address).toBeDefined();
+    const deployedName = await name({
+      contract: getContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        address,
+      }),
+    });
+    expect(deployedName).toBe("Loyalty");
+  });
 });

package/src/extensions/prebuilts/deploy-erc721.ts

@@ -6,6 +6,7 @@ import { upload } from "../../storage/upload.js";
 import type { FileOrBufferOrString } from "../../storage/upload/types.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import type { ClientAndChainAndAccount } from "../../utils/types.js";
+import { initialize as initLoyaltyCard } from "../erc721/__generated__/LoyaltyCard/write/initialize.js";
 import { initialize as initDropERC721 } from "./__generated__/DropERC721/write/initialize.js";
 import { initialize as initOpenEditionERC721 } from "./__generated__/OpenEditionERC721/write/initialize.js";
 import { initialize as initTokenERC721 } from "./__generated__/TokenERC721/write/initialize.js";
@@ -16,7 +17,8 @@ import { initialize as initTokenERC721 } from "./__generated__/TokenERC721/write
 export type ERC721ContractType =
   | "DropERC721"
   | "TokenERC721"
-  | "OpenEditionERC721";
+  | "OpenEditionERC721"
+  | "LoyaltyCard";
 
 /**
  * @extension DEPLOY
@@ -167,5 +169,19 @@ async function getInitializeTransaction(options: {
         royaltyBps: params.royaltyBps || 0n,
         trustedForwarders: params.trustedForwarders || [],
       });
+    case "LoyaltyCard":
+      return initLoyaltyCard({
+        contract: implementationContract,
+        defaultAdmin: params.defaultAdmin || accountAddress,
+        name: params.name || "",
+        symbol: params.symbol || "",
+        contractURI,
+        royaltyRecipient: params.royaltyRecipient || accountAddress,
+        royaltyBps: params.royaltyBps || 0n,
+        trustedForwarders: params.trustedForwarders || [],
+        saleRecipient: params.saleRecipient || accountAddress,
+        platformFeeBps: params.platformFeeBps || 0n,
+        platformFeeRecipient: params.platformFeeRecipient || accountAddress,
+      });
   }
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.72.0-nightly-f64e0253d7de6fdb6f56ab49315cc4cdcdd75b20-20241127000345";
+export const version = "5.72.0-nightly-e87eb2ff35eea1b94ab7bdae3585d819879ec53c-20241128000350";