thirdweb 5.105.33 → 5.105.34-nightly-7f116577aba529e21a48163b295b091f9d6008f7-20250816000350

package/src/tokens/get-entrypoint-erc20.ts

@@ -0,0 +1,121 @@
+import type { AbiConstructor } from "abitype";
+import { getContract } from "../contract/contract.js";
+import { getDeployedInfraContractFromMetadata } from "../contract/deployment/utils/infra.js";
+import { computeDeployAddress } from "../extensions/tokens/__generated__/ContractFactory/read/computeDeployAddress.js";
+import { computeProxyAddress } from "../extensions/tokens/__generated__/ContractFactory/read/computeProxyAddress.js";
+import { encodeAbiParameters } from "../utils/abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "../utils/abi/normalizeFunctionParams.js";
+import {
+  fetchBytecodeFromCompilerMetadata,
+  fetchDeployMetadata,
+} from "../utils/any-evm/deploy-metadata.js";
+import { isContractDeployed } from "../utils/bytecode/is-contract-deployed.js";
+import { padHex, toHex } from "../utils/encoding/hex.js";
+import { withCache } from "../utils/promise/withCache.js";
+import type { ClientAndChain } from "../utils/types.js";
+import {
+  CONTRACT_DEPLOY,
+  CONTRACT_FACTORY_DEPLOY_URL,
+  ENTRYPOINT_DEPLOY_URL,
+  MANAGER_ADDRESS,
+  OWNER_ADDRESS,
+  PROXY_DEPLOY,
+} from "./constants.js";
+
+export async function getDeployedEntrypointERC20(options: ClientAndChain) {
+  const cacheKey = `${options.chain.id}-${ENTRYPOINT_DEPLOY_URL}-${JSON.stringify(options.client)}`;
+
+  return withCache(
+    async () => {
+      // 1. Get deployed contract factory
+      const contractFactory = await getDeployedContractFactory(options);
+
+      if (!contractFactory) {
+        throw new Error(
+          `Contract factory not found on chain: ${options.chain.id}`,
+        );
+      }
+
+      // 2. Fetch metadata and encode args for entrypoint implementation
+      const contractMetadata = await fetchDeployMetadata({
+        client: options.client,
+        uri: ENTRYPOINT_DEPLOY_URL,
+      });
+      const bytecode = await fetchBytecodeFromCompilerMetadata({
+        chain: options.chain,
+        client: options.client,
+        compilerMetadata: contractMetadata,
+      });
+      const constructorAbi = contractMetadata.abi.find(
+        (abi) => abi.type === "constructor",
+      ) as AbiConstructor | undefined;
+      const encodedArgs = encodeAbiParameters(
+        constructorAbi?.inputs ?? [],
+        normalizeFunctionParams(constructorAbi, {}),
+      );
+
+      // 3. Compute entrypoint implementation address
+      const entrypointImplAddress = await computeDeployAddress({
+        contract: contractFactory,
+        deployType: CONTRACT_DEPLOY.CREATE2,
+        bytecode,
+        constructorArgs: encodedArgs,
+        salt: padHex(toHex("ERC20_ENTRYPOINT:1"), { size: 32 }),
+      });
+
+      // 4. Compute entrypoint proxy address
+      const entrypointProxyAddress = await computeProxyAddress({
+        contract: contractFactory,
+        implementation: entrypointImplAddress,
+        data: "0x",
+        salt: padHex(toHex("ERC20_ENTRYPOINT_PROXY:1"), { size: 32 }),
+        deployType: PROXY_DEPLOY.ERC1967,
+      });
+      const entrypointProxy = getContract({
+        ...options,
+        address: entrypointProxyAddress,
+      });
+
+      const isDeployed = await isContractDeployed(entrypointProxy);
+
+      if (!isDeployed) {
+        throw new Error(
+          `Entrypoint is not deployed yet on chain: ${options.chain.id}`,
+        );
+      }
+
+      return entrypointProxy;
+    },
+    {
+      cacheKey,
+      cacheTime: 24 * 60 * 60 * 1000, // 1 day
+    },
+  );
+}
+
+export async function getDeployedContractFactory(options: ClientAndChain) {
+  const cacheKey = `${options.chain.id}-${CONTRACT_FACTORY_DEPLOY_URL}-${JSON.stringify(options.client)}`;
+  return withCache(
+    async () => {
+      const contractMetadata = await fetchDeployMetadata({
+        client: options.client,
+        uri: CONTRACT_FACTORY_DEPLOY_URL,
+      });
+
+      return getDeployedInfraContractFromMetadata({
+        chain: options.chain,
+        client: options.client,
+        constructorParams: {
+          owner: OWNER_ADDRESS,
+          manager: MANAGER_ADDRESS,
+        },
+        contractMetadata,
+        salt: "THIRDWEB_CONTRACT_FACTORY:1",
+      });
+    },
+    {
+      cacheKey,
+      cacheTime: 24 * 60 * 60 * 1000, // 1 day
+    },
+  );
+}

package/src/tokens/is-router-enabled.ts

@@ -0,0 +1,48 @@
+import { ZERO_ADDRESS } from "../constants/addresses.js";
+import { getContract } from "../contract/contract.js";
+import { getPoolRouter } from "../extensions/tokens/__generated__/ERC20Entrypoint/read/getPoolRouter.js";
+import { getAdapter } from "../extensions/tokens/__generated__/PoolRouter/read/getAdapter.js";
+import type { ClientAndChain } from "../utils/types.js";
+import { getDeployedEntrypointERC20 } from "./get-entrypoint-erc20.js";
+
+export async function isPoolRouterEnabled(
+  options: ClientAndChain,
+): Promise<boolean> {
+  const entrypoint = await getDeployedEntrypointERC20(options);
+  if (!entrypoint) {
+    return false;
+  }
+
+  const poolRouterAddress = await getPoolRouter({
+    contract: entrypoint,
+  });
+  if (poolRouterAddress === ZERO_ADDRESS) {
+    return false;
+  }
+
+  const poolRouterContract = getContract({
+    address: poolRouterAddress,
+    chain: options.chain,
+    client: options.client,
+  });
+
+  const [v3Adapter, v4Adapter] = await Promise.all([
+    getAdapter({
+      contract: poolRouterContract,
+      adapterType: 1,
+    }),
+    getAdapter({
+      contract: poolRouterContract,
+      adapterType: 2,
+    }),
+  ]);
+
+  if (
+    v3Adapter.rewardLocker === ZERO_ADDRESS &&
+    v4Adapter.rewardLocker === ZERO_ADDRESS
+  ) {
+    return false;
+  }
+
+  return true;
+}

package/src/tokens/token-utils.test.ts

@@ -0,0 +1,46 @@
+import { isHex } from "viem/utils";
+import { describe, expect, it } from "vitest";
+
+import { generateSalt, SaltFlag } from "./token-utils.js";
+
+// Helper to validate the generated salt meets core guarantees
+function assertValidSalt(out: string, expectedFlagHex: string) {
+  // should be valid hex
+  console.log("out", out);
+  expect(isHex(out)).toBe(true);
+  // 0x prefix + 64 hex chars → 32 bytes
+  expect(out.length).toBe(66);
+  // first byte must match the expected flag
+  expect(out.slice(0, 4).toLowerCase()).toBe(expectedFlagHex.toLowerCase());
+}
+
+describe("generateSalt", () => {
+  it("handles hex shorter than 32 bytes (padding)", () => {
+    const shortHex = "0x123456"; // 3 bytes < 32 bytes
+    const out = generateSalt(shortHex);
+    assertValidSalt(out, "0x01"); // default flag is MIX_SENDER (0x01)
+  });
+
+  it("handles exactly 32-byte hex and overrides explicit flag with salt's flag", () => {
+    const hex32 = `0x20${"aa".repeat(31)}`; // first byte 0x20, total 32 bytes
+    const out = generateSalt(hex32, SaltFlag.BYPASS); // pass a different flag intentionally
+    // even though we requested BYPASS (0x80), the salt's first byte (0x20) wins
+    assertValidSalt(out, "0x20");
+  });
+
+  it("handles hex longer than 32 bytes (hashing)", () => {
+    const longHex = `0x${"ff".repeat(80)}`; // 80 bytes > 32 bytes
+    const out = generateSalt(longHex);
+    assertValidSalt(out, "0x01"); // default flag retained
+  });
+
+  it("handles arbitrary non-hex string (hashed)", () => {
+    const out = generateSalt("hello world");
+    assertValidSalt(out, "0x01");
+  });
+
+  it("respects explicit flag parameter when provided", () => {
+    const out = generateSalt("foobar", SaltFlag.BYPASS);
+    assertValidSalt(out, "0x80");
+  });
+});

package/src/tokens/token-utils.ts

@@ -0,0 +1,157 @@
+import { type Hex, keccak256 } from "viem";
+import { isHex, toBytes } from "viem/utils";
+import type { ThirdwebClient } from "../client/client.js";
+import { NATIVE_TOKEN_ADDRESS } from "../constants/addresses.js";
+import { encodeInitialize } from "../extensions/tokens/__generated__/ERC20Asset/write/initialize.js";
+import { upload } from "../storage/upload.js";
+import { encodeAbiParameters } from "../utils/abi/encodeAbiParameters.js";
+import { toUnits } from "../utils/units.js";
+import {
+  DEFAULT_DEVELOPER_REWARD_BPS,
+  DEFAULT_MAX_SUPPLY_ERC20,
+  DEFAULT_POOL_INITIAL_TICK,
+} from "./constants.js";
+import type { PoolConfig, TokenParams } from "./types.js";
+
+export const SaltFlag = {
+  /** Mix in msg.sender */
+  MIX_SENDER: 0x01,
+  /** Mix in block.chainid */
+  MIX_CHAIN_ID: 0x02,
+  /** Mix in block.number */
+  MIX_BLOCK_NUMBER: 0x04,
+  /** Mix in contractInitData */
+  MIX_CONTRACT_INIT_DATA: 0x08,
+  /** Mix in hookInitData */
+  MIX_HOOK_INIT_DATA: 0x10,
+  /** Mix in creator address */
+  MIX_CREATOR: 0x20,
+  /** Bypass mode – disable all transformations */
+  BYPASS: 0x80,
+} as const;
+
+export type SaltFlagType = (typeof SaltFlag)[keyof typeof SaltFlag];
+
+export async function encodeInitParams(options: {
+  client: ThirdwebClient;
+  params: TokenParams;
+  creator: string;
+}): Promise<Hex> {
+  const { client, params, creator } = options;
+
+  const contractURI =
+    options.params.contractURI ||
+    (await upload({
+      client,
+      files: [
+        {
+          description: params.description,
+          external_link: params.external_link,
+          image: params.image,
+          name: params.name,
+          social_urls: params.social_urls,
+          symbol: params.symbol,
+        },
+      ],
+    })) ||
+    "";
+
+  return encodeInitialize({
+    contractURI,
+    owner: creator,
+    name: params.name,
+    symbol: params.symbol || params.name,
+    maxSupply: toUnits(
+      params.maxSupply.toString() || DEFAULT_MAX_SUPPLY_ERC20.toString(),
+      18,
+    ),
+  });
+}
+
+export function encodePoolConfig(poolConfig: PoolConfig): Hex {
+  const POOL_PARAMS = [
+    {
+      name: "amount",
+      type: "uint256",
+    },
+    {
+      name: "currency",
+      type: "address",
+    },
+    {
+      name: "initialTick",
+      type: "int24",
+    },
+    {
+      name: "developerRewardBps",
+      type: "uint16",
+    },
+  ] as const;
+
+  return encodeAbiParameters(POOL_PARAMS, [
+    toUnits(poolConfig.amount.toString(), 18),
+    poolConfig.currency || NATIVE_TOKEN_ADDRESS,
+    poolConfig.initialTick || DEFAULT_POOL_INITIAL_TICK,
+    poolConfig.developerRewardBps || DEFAULT_DEVELOPER_REWARD_BPS,
+  ]);
+}
+
+export function generateSalt(
+  salt: Hex | string,
+  flags: SaltFlagType = SaltFlag.MIX_SENDER,
+): Hex {
+  /*
+   * The salt layout follows the on-chain convention documented in the `guardSalt` Solidity helper.
+   *   [0x00] – 1 byte  : flags (bits 0-7)
+   *   [0x01-0x1F] – 31 bytes : user-provided entropy
+   *
+   * This helper makes it easy to prepare a salt off-chain that can be passed to
+   * the contract. It guarantees the returned value is always 32 bytes (66 hex
+   * chars including the `0x` prefix) and allows callers to optionally pass a
+   * custom salt and/or explicit flag byte.
+   */
+
+  let flagByte: number = flags;
+
+  // If the salt is already a valid 32-byte hex string, we can use it as is and extract the flag byte
+  if (salt && isHex(salt)) {
+    const hex = salt.replace(/^0x/i, "");
+    if (hex.length === 64) {
+      flagByte = parseInt(hex.slice(0, 2), 16) as SaltFlagType;
+      salt = `0x${hex.slice(2)}` as Hex;
+    } else if (hex.length < 64) {
+      // If the salt is less than 31 bytes, we need to pad it with zeros (first 2 bytes are the flag byte)
+      salt = `0x${hex.padStart(62, "0")}` as Hex;
+    } else if (hex.length > 64) {
+      // If the salt is greater than 32 bytes, we need to keccak256 it.
+      // first 2 bytes are the flag byte, and truncate to 31 bytes
+      salt = `0x${keccak256(toBytes(hex)).slice(4)}` as Hex;
+    }
+  } else if (salt && !isHex(salt)) {
+    // 31 bytes of salt data
+    salt = `0x${keccak256(toBytes(salt)).slice(4)}` as Hex;
+  }
+
+  // If the flag byte is not a valid 8-bit unsigned integer, throw an error
+  if (flagByte < 0 || flagByte > 0xff) {
+    throw new Error("flags must be an 8-bit unsigned integer (0-255)");
+  }
+
+  const saltData = salt.replace(/^0x/i, "");
+  if (saltData.length !== 62) {
+    // 31 bytes * 2 hex chars
+    throw new Error(
+      "salt data (excluding flag byte) cannot exceed 31 bytes (62 hex characters)",
+    );
+  }
+
+  const result =
+    `0x${flagByte.toString(16).padStart(2, "0")}${saltData}` as Hex;
+
+  // Final sanity check – should always be 32 bytes / 66 hex chars (including 0x)
+  if (result.length !== 66) {
+    throw new Error("generated salt must be 32 bytes");
+  }
+
+  return result;
+}

package/src/tokens/types.ts

@@ -0,0 +1,49 @@
+import type { Hex } from "viem";
+import type { FileOrBufferOrString } from "../storage/upload/types.js";
+import type { ClientAndChainAndAccount } from "../utils/types.js";
+
+export type TokenParams = {
+  name: string;
+  description?: string;
+  image?: FileOrBufferOrString;
+  external_link?: string;
+  social_urls?: Record<string, string>;
+  symbol?: string;
+  contractURI?: string;
+  maxSupply: bigint;
+  owner?: string;
+};
+
+export type PoolConfig = {
+  amount: bigint;
+  currency?: string;
+  initialTick?: number;
+  developerRewardBps?: number;
+};
+
+export type DistributeContent = {
+  amount: bigint;
+  recipient: string;
+};
+
+type DistributeConfig = {
+  content: DistributeContent[];
+};
+
+type LaunchConfig =
+  | { kind: "none"; config: undefined }
+  | { kind: "pool"; config: PoolConfig }
+  | { kind: "distribute"; config: DistributeConfig };
+
+export type CreateTokenOptions = ClientAndChainAndAccount & {
+  salt?: Hex;
+  params: TokenParams;
+  launchConfig?: LaunchConfig;
+  developerAddress?: string;
+};
+
+export type CreateTokenByImplementationConfigOptions =
+  ClientAndChainAndAccount &
+    CreateTokenOptions & {
+      implementationAddress: string;
+    };

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.105.33";
+export const version = "5.105.34-nightly-7f116577aba529e21a48163b295b091f9d6008f7-20250816000350";

package/src/react/web/ui/PayEmbed-disconnected.test.tsx

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { render, waitFor } from "../../../../test/src/react-render.js";
-import { TEST_CLIENT } from "../../../../test/src/test-clients.js";
-import { PayEmbed } from "./PayEmbed.js";
-
-describe.runIf(process.env.TW_SECRET_KEY)(
-  "PayEmbed: Disconnected state",
-  () => {
-    it("renders a connect wallet button when a wallet is not connected", async () => {
-      const { findByText } = render(<PayEmbed client={TEST_CLIENT} />);
-      waitFor(async () => {
-        const connectWalletButton = await findByText("Connect Wallet");
-        expect(connectWalletButton).toBeInTheDocument();
-      });
-    });
-  },
-);

package/src/react/web/ui/PayEmbed.test.tsx

@@ -1,35 +0,0 @@
-import { userEvent } from "@testing-library/user-event";
-import { describe, expect, it } from "vitest";
-import { render, waitFor } from "../../../../test/src/react-render.js";
-import { TEST_CLIENT } from "../../../../test/src/test-clients.js";
-import { PayEmbed } from "./PayEmbed.js";
-
-describe.runIf(!!process.env.TW_SECRET_KEY)(
-  "PayEmbed - Connected state",
-  () => {
-    it("continue button is disabled if no token amount is set", async () => {
-      const { findByRole } = render(<PayEmbed client={TEST_CLIENT} />, {
-        setConnectedWallet: true,
-      });
-      waitFor(async () => {
-        const connectWalletButton: HTMLElement = await findByRole("button", {
-          name: "Continue",
-        });
-        // continue button is disabled when no amount is entered
-        expect(connectWalletButton).toBeDisabled();
-        // user enters an amount
-        const tokenInput = await findByRole("textbox");
-        await userEvent.type(tokenInput, "1");
-
-        // continue button is enabled
-        expect(connectWalletButton).not.toBeDisabled();
-
-        // user clears the amount
-        await userEvent.clear(tokenInput);
-
-        // continue button is disabled again
-        expect(connectWalletButton).toBeDisabled();
-      });
-    });
-  },
-);

package/src/stories/PayEmbed.stories.ts

@@ -1,42 +0,0 @@
-import type { Meta, StoryObj } from "@storybook/react-vite";
-import { PayEmbed } from "../react/web/ui/PayEmbed.js";
-import { storyClient } from "./utils.js";
-
-const meta = {
-  args: {
-    client: storyClient,
-  },
-  component: PayEmbed,
-  parameters: {
-    layout: "centered",
-  },
-  tags: ["autodocs"],
-  title: "Connect/PayEmbed",
-} satisfies Meta<typeof PayEmbed>;
-
-type Story = StoryObj<typeof meta>;
-
-export const Dark: Story = {
-  args: {
-    theme: "dark",
-  },
-};
-
-export const FiatTestMode: Story = {
-  args: {
-    payOptions: {
-      buyWithFiat: {
-        testMode: true,
-      },
-    },
-    theme: "dark",
-  },
-};
-
-export const Light: Story = {
-  args: {
-    theme: "light",
-  },
-};
-
-export default meta;