Changelog

// The external wallet you want to login with
var anyExternalWallet = await PrivateKeyWallet.Generate(client: Client); 
// USING .NET API
// Create the InAppWallet
var wallet = await InAppWallet.Create(
  client: client, 
  authProvider: AuthProvider.Siwe, 
  siweSigner: anyExternalWallet
);
_ = await siweWallet.LoginWithSiwe(chainId: 1);
// USING UNITY API
// Setup auth with SIWE
var siweOptions = new InAppWalletOptions(
  authprovider: AuthProvider.Siwe, 
  siweSigner: anyExternalWallet
);
// Setup connect options with chain ID
var connectOptions = new WalletOptions(
  provider: WalletProvider.InAppWallet, 
  chainId: 421614, 
  inAppWalletOptions: siweOptions
);
// Login with SIWE!
var siweInAppWallet = await ThirdwebManager.Instance.ConnectWallet(connectOptions);
var address = await siweInAppWallet.GetAddress();

// Your main InAppWallet account, already authenticated and connected
InAppWallet mainInAppWallet = ...
// An InAppWallet with a new auth provider to be linked to the main account, not connected
InAppWallet walletToLink = await InAppWallet.Create(
  client: Client, 
  authProvider: AuthProvider.Telegram
);
// Link Account - .NET API
var linkedAccounts = await mainInAppWallet.LinkAccount(
  walletToLink: walletToLink
);
// Link Account - Unity API
var linkedAccounts = await ThirdwebManager.Instance.LinkAccount(
  mainInAppWallet, 
  walletToLink
);
// You can also fetch linked accounts at any time
List<LinkedAccount> linkedAccounts = await mainInAppWallet.GetLinkedAccounts();

The LinkAccount API requires the parameters you typically use to login with a normal InAppWallet. It will authenticate the new wallet and link it directly to the main wallet. This makes it simple to have multiple identities tied a single evm-compatible account.

• Performance and speed improvements for OTP based login methods.
• Added caching for Utils.FetchThirdwebChainDataAsync.
• Added Utils.IsEip155Enforced to check whether a chain enforces EIP 155.
• Added smarter transaction gas fee defaults based on whether chain supports 1559.
• ThirdwebContract.Read and ThirdwebContract.Write can now take in full or partial method signatures:
  • var name = await contract.Read<string>(method: "name", ...)
    still works.
  • var name = await contract.Read<string>(method: "function name() view returns (string)", ...)
    now also works.
  • var name= await contract.Read<string>(method: "name() view returns (string)", ...)
    now also works.
  • var result = await contract.Write(..., method: "claim(address, uint256, address, uint256, (bytes32[], uint256, uint256, address), bytes)", ...)
    now also works.
  • We still recommend using our awesome extensions for common standards such as contract.DropERC20_Claim to make life easier!
• Added support for ERC20 Paymasters.

.NET: https://www.nuget.org/packages/Thirdweb/1.4.0

Unity: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v5.0.0-beta.3

.NET: https://portal.thirdweb.com/dotnet

Unity: https://portal.thirdweb.com/unity/v5

We've added multi-authentication to the thirdweb SDK. Anyone can now link their in-app wallets to additional profiles like Google, Discord, Telegram, and more. Like all our features, we offer both a prebuilt UI and headless interface for linking profiles. When a user links their profile to an existing in-app wallet, that profile can then be used to authenticate to that wallet.

Unified identities come builtin to the React Connect modal. You can link a profile while signed into an in-app wallet by clicking "Manage Wallet" then "Linked Profiles".

If you're not using React or you'd like to build your own UI, we've added two functions and a hook to make it as easy as possible.

To link a new profile to a currently connected wallet, use linkProfile.

import { inAppWallet, linkProfile } from "thirdweb/wallets";
 
const wallet = inAppWallet();
 
await wallet.connect({ strategy: "google" });
const profiles = await linkProfile(wallet, { strategy: "discord" });

This will return all currently linked profiles. To get the linked profiles at any time, use getProfiles.

import { inAppWallet, getProfiles } from "thirdweb/wallets";
 
const wallet = inAppWallet();
wallet.connect({ strategy: "google" });
 
const profiles = getProfiles(wallet);

This will return a profiles array similar to below.

[
  {
    type: "google",
    details: {
      email: "user@gmail.com",
    },
  },
  {
    type: "discord",
    details: {
      email: "user@gmail.com",
    },
  },
];

If you're using React, the useProfiles hook fetches profiles for the currently connected wallet and handles caching / revalidation for you.

import { useProfiles } from "thirdweb/react";
 
const { data: profiles } = useProfiles();

We've added an extension for the Split contract. See all the available functions in our documentation.

We've added an extension for the Vote contract. See more in our documentation.

• Fixed wallet auto-connect in the React Native SDK
• Updated the serializeTransaction interface to include a separate input for signature
• Added fallback option to get address in ethers5 contract adapter
• Added Abstract L2, Fractal, and Mode Testnet pre-defined chains
• Fixed issue with "All Wallets" appearing in Pay
• Added enabled prop to useWalletBalance

Thirdweb's Unreal SDK is a Code Plugin for Unreal Engine that enables developers to create thirdweb Private Key Wallets, In-App Wallets and Smart Wallets for their games and applications. The plugin provides a simple API and blueprints to interact with wallets, login with email or socials as well as create Smart Wallet session keys.

With this plugin, you can keep the onboarding of your users in-client and grant a session key to your thirdweb Engine powered backend to interact with the blockchain, no signature in sight.

It is built using Rust as its core, while integrating Unreal native framework through its Subsystem and Blueprint functionality.

Our Unreal SDK is distributed as an Unreal Marketplace Code Plugin.

Get started by following the documentation here.

• Generate or Create Private Key Wallets - ephemereal guest wallets.
• Create and Login to In-App Wallets - unlocking email and social authentication to create persistent, cross-platform, cross-device and cross-sdk signless embedded wallets.
• Unlock the power of Account Abstraction - unlock the ability to sponsor gas and interact on behalf of users by upgrading any wallet to a Smart Wallet, and using Session Keys to grant scoped access to your backend - fully compatible with thirdweb Engine or other SDKs.
• Rust Core - the plugin's core logic is built from Rust, making it lightning-fast and minimizing the clutter in your Unreal project.
• Compatible with Unreal Engine 5.4 - the plugin is compatible with the latest version of Unreal Engine, allowing you to leverage the latest features and improvements.

Download the Thirdweb Unreal Plugin from the Unreal Marketplace and install it into your Engine.

Grab an API key from https://thirdweb.com/create-api-key and make sure to allowlist a bundle id to use from within unreal.

Integrate your API key from the editor's project settings Thirdweb section. You only need to set your client id and bundle id to get started.

Run Level_Thirdweb to try out some example functionality and explore our code!

Our Plugin is programmed as a subsystem, allowing you to interact with it very easily.

For more information visit https://portal.thirdweb.com/unreal

• [Native] Upgrade MetaMask SDK to 2.1.0 by @ecp4224 in https://github.com/thirdweb-dev/unity-sdk/pull/207
  • Utilizes MetaMask's new ConnectWith functionality to connect and switch to the right network within a single call.
  • Improves network switching behavior and handled errors better.
  • Fixes errors encountered when switching to a MetaMask default chain such as Sepolia.
  • Refactored internal code to use new MetaMaskSDK APIs.
• [Cross-Platform] Added support for new chains.

Release: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v4.20.0

You can now use AuthProvider.Farcaster and AuthProvider.Telegram when creating your InAppWallet with the .NET SDK (v1.3.0+) or related platforms like Godot and Unity (Cross Platform v5.0.0-beta.2+)

It's that simple!

NuGet Release: https://www.nuget.org/packages/Thirdweb

Unity Release: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v5.0.0-beta.2

v5.44.1 of the thirdweb SDK brings a number of bug fixes and improvements across surface areas:

• Fixed wallet info retrieval for adapter wallets
• Added additional account switcher handling for SIWE auth states
• Fixed EIP-6492 signature verification for undeployed accounts
• Updated the pay interface to include optional gas token

Building on our .NET SDK, we've minimized dependencies and reduced the package size by 90%. This beta is the first step toward truly unleashing the potential of blockchain technology in games, offering composable, simple, and clean APIs that can be utilized from anywhere.

• Seamless Integration Across Platforms: Enjoy a consistent experience across WebGL, Desktop, and Mobile without the need for the WebGL Bridge. Develop once, deploy everywhere.

• Chain-Agnostic Interaction: Our APIs are designed to work seamlessly with multiple chains, removing the complexities of state management.

• Stable and Predictable Upgrades: Utilizing our .NET core, the SDK offers a native experience, ensuring stability and predictability with each upgrade.

• Intuitive API Changes:
  • ThirdwebManager.Instance.SDK.GetContract is now ThirdwebManager.Instance.GetContract, returning ThirdwebContract.
  • ThirdwebManager.Instance.SDK.Wallet.Connect is now ThirdwebManager.Instance.ConnectWallet, returning IThirdwebWallet.
• Enhanced Wallet Management: Effortlessly manage multiple wallet connections and track the active wallet.
• Streamlined Setup: The prefab setup is now more intuitive, making it easier for developers to integrate and get started.

• Lighter and Faster: A cleaner, lighter Unity package with minimal dependencies, significantly enhancing performance.
• Refined Architecture: We've taken control of all layers, excluding the AWS SDK and using Nethereum only for types/encoding. Libraries like Newtonsoft.Json and EDM4U are included to ensure efficiency.

• Uniform Behavior Across Platforms: Enjoy consistent behavior across all platforms—what you see in the editor is what you get in WebGL, Standalone, and Mobile runtime environments.
• Fully Customizable: The SDK can be white-labeled to match your branding needs.

• Universal Compatibility: All chains are supported, and no patches are needed to support newly deployed chains.

Our v5 SDK is still in active development, and we invite you to be part of this journey. For more details, visit our v5 branch readme.

• Unity SDK v5 Documentation: Read the Docs
• .NET SDK Documentation: Read the Docs
• Support and Feedback: Contact Support

This update adds AuthProvider.Discord to the InAppWallet list of default auth methods you can use.

var wallet = await InAppWallet.Create(
  client: client, 
  authprovider: AuthProvider.Discord
);

It also comes with a new and improvement OAuth flow that streamlines the experience across all target platforms and includes speed improvements.

We've also updated the Godot integration example to showcase additional OAuth methods.

These features will also be part of the Unity SDK v5 initial release and will be supported across all runtime platforms.

NuGet Package: https://www.nuget.org/packages/Thirdweb
.NET SDK Source: https://github.com/thirdweb-dev/thirdweb-dotnet
.NET SDK Documentation: https://portal.thirdweb.com/dotnet

Godot Integration: https://github.com/thirdweb-example/godot-starter

We're excited to announce the public beta for Engine v2 with a redesigned worker architecture that dramatically increases transaction processing capacity by up to 700x.

Nonces are now assigned in parallel to send a batch of transactions from a single backend wallet at once. This update sends dramatically more transactions per block than Engine v1 (see benchmarks below).

Engine v2 introduces multiple mechanisms to recover if the onchain and Engine wallet nonces differ. It also recycles unused nonces instead of immediately cancelling them, reducing gas used during failed transactions.

API calls are more performant to send transactions (< 40ms server latency) or read transaction status (< 10ms server latency). This speedup means increased throughput with fewer server resources.

With these improvements, Engine v2 is able to send significantly more transactions per second.

Here's a benchmark on B3 Sepolia with 2s block times on a single Starter Cloud-Hosted Engine:

• Engine v2 received 1500 transactions in 10s. Nearly all transactions were sent within 2s and filled up a block (700+ tx/sec)!
• Engine v1 received 250 transactions in 7.7s. Two transactions sent per block (1 tx/sec).

Note: Your results may differ based on chain, transaction type, and sustained load. Some chains and RPC providers may impose additional throughput limits.

• Scale your dApp without worrying about infrastructure limitations.
• Handle traffic spikes and sustained high-volume transactions.
• Optimize gas usage to reduce operational costs.
• Build new use cases that require high-scale transactions.
• Avoid managing nonce synchronization and RPC errors in your backend.

• Cloud-hosted Engine
  • Contact support@thirdweb.com to be upgraded.
  • Developers will be able to upgrade to v2 from the dashboard soon.
• Self-Hosted
  • Pull the latest v2.0.0-beta-rc* image from Docker Hub.

Please share any feedback or contact support for technical issues with Engine v2. We are continuing to test Engine v2 internally and encourage developers to treat Engine as pre-release software.

There are no breaking changes to existing documented interfaces to APIs or webhooks. Pending queued transactions will continue to be processed after the upgrade.

The team is continuing to test Engine on internal production environments.

Engine v2 will be released to the stable release channel after more bugfixes and incorporating customer feedback.

Stay tuned for a technical deep dive on our throughput breakthrough. Your feedback is invaluable as we refine Engine!

thirdweb Engine is an open-source server for your app to read, write, and deploy contracts at production scale.

Self-host for free or get a cloud-hosted Engine for $99/month.

• [Native] Added support for Discord Login.
• [Cross-Platform] Added support for new chains.

Discord has been added to Prefab_ConnectWallet and can be tested in Scene_Prefabs

Discord login also utilizes a brand new internal flow that should allow you to login faster than you otherwise would with different providers.

As of version 5.44.0, the thirdweb SDK supports Telegram with in-app wallets! Use Telegram like any other auth method.

import { inAppWallet } from "thirdweb";
 
const wallet = inAppWallet();
 
await wallet.connect({
  strategy: "telegram",
});

The CreateDirectListingButton makes it easy to list an NFT on your thirdweb Marketplace contract. Pair it with the BuyDirectListingButton and you can build an entire Marketplace UI in seconds.

import { CreateDirectListingButton } from "thirdweb/react";
 
<CreateDirectListingButton
  contractAddress="0x..." // contract address for the marketplace-v3
  chain={...} // the chain which the marketplace contract is deployed on
 
  // These props below are the same props for `createListing`
  // to get the full list, check the docs link above
  tokenId={0n}
  assetContractAddress="0x..." // The NFT contract address whose NFT(s) you want to sell
  pricePerToken={"0.1"} // sell for 0.1 <native token>
>
  Sell NFT
</CreateDirectListingButton>

We've added more language options to our built-in Connect UI localization. Just specify the language identifier on whatever component you're using.

import { ConnectEmbed } from "react";
 
<ConnectEmbed client={client} locale="ja_JP" />;

• Fixed an issue with ethers5adapter transaction result nonces
• Improved error messages when connection management hooks are used outside ThirdwebProvider
• Fixed autoConnect for wallets that are connected from the "All wallets" screen
• Temporarily disabled login via the CLI
• Fixed an issue with OTP validation in React Native Connect UI
• Added Handling for gas free chains where baseFeePerGas is 0
• Fixed occasional iFrame error when logging in with OAuth

This update comes with a couple additions and changes that should make your developer experience slightly better.

Added SmartWallet.GetAllAdmins and SmartWallet.GetAllActiveSigners helper functions, to respectively get all the admins that might have been added using SmartWallet.AddAdmin and all the temporary signers that were added using SmartWallet.CreateSessionKey and are still unexpired.

GetAllAdmins returns a List<string> of all your admins.

GetAllActiveSigners returns permissions similar to the inputs of CreateSessionKey

SignerPermissions
{
    string Signer // the signer address
    List<string> ApprovedTargets // contracts signer is allowed to interact with
    BigInteger NativeTokenLimitPerTransaction // wei
    BigInteger StartTimestamp // unix
    BigInteger EndTimestamp // unix
}

Furthermore, these functions now throw when called directly on the Smart Wallet, to make sure signatures are 1271 compatible and not confuse developers by forwarding these calls down to the personal wallet acting as a signer.

Functions: SmartWallet.EthSign, SmartWallet.RecoverAddressFromEthSign and SmartWallet.PersonalSign(byte[])

As we begun implementing the .NET SDK on different platforms, we ran into an issue when integrating external wallet types on such platforms - EIP-712.

We've added a utility to remedy this: Utils.ToJsonExternalWalletFriendly<TMessage, TDomain>(TypedData typedData, TMessage message)

This method will convert any typed data parameters into correct and verifiable formats, specially in cases of EIP-1271 Smart Wallet type signatures. If you're implementing an external wallet, we recommend using this util in your IThirdwebWallet.SignTypedDataV4<TMessage,TDomain> overrides.

This has been confirmed to work with MetaMask (native and extension) and WalletConnect.

Thirdweb.Pay specific constants have been removed.

Previously, adding using Thirdweb and using Thirdweb.Pay made it annoying to accesss Thirdweb.Constants - this is no longer the case.

• [WebGL] Added support for Coinbase Smart Wallets
  • Simply use the existing WalletProvider.Coinbase in WebGL to test it out!
  • If you do not have a Coinbase wallet browser extension, you will be prompted to create a Coinbase Smart Wallet.
  • Note that to test this locally you must add a CORS header, see our WebGL Build Instructions for example code.
• [WebGL] Updated bridge.
• [Cross-Platform] Added support for new chains.

Release: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v4.18.0

This patch introduces the ability to call static ThirdwebContract methods as extensions.

For instance ThirdwebContract.Read, ThirdwebContract.Write and ThirdwebContract.Prepare can now be used directly on the ThirdwebContract object.

// Previously
var contract = await ThirdwebContract.Create(...);
var result = await ThirdwebContract.Read<string>(contract, ...);
// In 1.0.2
var contract = await ThirdwebContract.Create(...);
var result = await contract.Read<string>(...);
// Note, both patterns are supported, no migration required

Furthermore, the IThirdwebWallet interface now supports Disconnect directly, so you no longer have to cast to InAppWallet to explicitly call disconnect and clear your local sessions.

Finally, SmartWallet.GetPersonalAccount is now SmartWallet.GetPersonalWallet - this function is used as a simple way to access the IThirdwebWallet acting as the signer for your smart account.

We are excited to announce a significant update designed to bring greater transparency and control to your managed engine instances. At the heart of this update is a suite of new features aimed at giving you deeper insights into the performance and health of your engine instances.

Starting today, you will be able to see the load on your engine instance broken down by status code. This granular view allows you to understand how your traffic is distributed across different types of responses. Whether it’s a successful request or an error, you can now pinpoint exactly where traffic spikes happen. This information is crucial for optimizing performance and ensuring that your services are running smoothly.

In addition to load monitoring, you can now track the error rate over time. This feature provides a historical view of how errors are occurring within your instance. By analyzing error trends, you can identify patterns and potential issues before they become critical. This proactive approach helps maintain a high level of service reliability and reduces downtime.

Finally, we’ve introduced a comprehensive health check feature. This tool gives you a real-time snapshot of your instance’s health. health checks help you stay informed about any potential problems and allow for timely interventions to keep your instances running at peak performance.

These new features are part of our ongoing commitment to providing you with the best tools and insights to manage your infrastructure effectively. We believe that transparency is key to operational excellence, and with these enhancements, you are better equipped to monitor, diagnose, and optimize your managed engine instances.

Explore these new features today and take control of your engine instances with clarity and confidence.

We've kicked off a total overhaul of our v5 documentation. In the coming weeks, we'll continue to add content to make building with thirdweb easier than ever. Check out the TypeScript, React, and React Native docs and let us know your thoughts!

We're continuing to add prebuilt components to our Connect UI to make building fully functional apps easier than ever. Today we released the BuyDirectListingButton to buy any token listed via our Marketplace V3 contract.

import { BuyDirectListingButton } from "thirdweb/react";
 
<BuyDirectListingButton
  contractAddress="0x..." // contract address of the marketplace v3
  chain={...} // the chain which the marketplace contract is deployed on
  client={...} // thirdweb client
  listingId={100n} // the listingId or the item you want to buy
  quantity={1n} // optional - see the docs to learn more
>
  Buy NFT
</BuyDirectListingButton>

We've added the useChainMetadata hook to the React SDK to fetch metadata for any chain including name, icon, available faucets, block explorers, and more.

import { useChainMetadata } from "thirdweb/react";
 
const { data: chainMetadata } = useChainMetadata(
  defineChain(11155111),
);
 
console.log("Name:", chainMetadata.name); // Sepolia
console.log("Faucets:", chainMetadata.faucets); // ["https://thirdweb.com/sepolia/faucet"]
console.log("Explorers:", chainMetadata.explorers); // ["https://sepolia.etherscan.io/"]

• Fixed the Connect UI modal when using more than 4 in-app wallet social auth options
• Fixed a bug with passkey, email, and phone number in-app wallet login
• Added ERC20 approval handling in the ClaimButton
• Added the parseAbiParams utility function

We've added Farcaster as an authentication option for in-app wallets. Use the same syntax you'd use for Google, Facebook, Apple, or Discord login.

To connect via farcaster with your own UI:

import { inAppWallet } from "thirdweb/wallets";
 
const wallet = inAppWallet();
 
await wallet.connect({
  strategy: "farcaster",
  client: CLIENT,
});

To connect using the Connect UI components in React or React Native:

import { inAppWallet } from "thirdweb/wallets";
import { ConnectButton } from "thirdweb/react";
 
<ConnectButton
  wallets={[
    inAppWallet({
      auth: {
        options: ["farcaster", "google", "discord"],
      },
    }),
  ]}
/>;

Or, try Farcaster login in our playground.

• Improved tab styling on the Connect UI "View Assets" page
• Significant performance improvements for wallet connection management
• Added the getApprovalForTransaction extension

Today we are introducing new pre-built contracts created by the recently released modular contracts framework to Explore.

• Token
• Token Drop
• NFT Collection
• NFT Drop
• Open Edition
• Edition
• Edition Drop

Please note these contracts are only available in beta meaning they are only deployable through testnets for a short period of time before we enable it on mainnet.

Why are we making this change?

Modular contracts are a more efficient and improved way of creating and deploying contracts that is highly customizable and upgradeable. All new pre-built modular contracts are deployed with a core and set of extension contracts that enable users to customize their contracts functionality by adding or removing extensions later.

Modular contracts are how we will be offering thirdweb contracts to customers for the indefinite future. All legacy or previous existing pre-built contracts will be replaced with the new modular contracts in the coming year — and soon we are making it easier for contract developers and partners to contribute to the entire ecosystem.

For users who want to create custom core contracts or extensions outside of pre-builts, we recommend reading our Write and Deploy Modular Contracts guide.

We encourage all of our contract users to try out the new pre-built contracts or build your own and provide feedback. Please let us know how we can improve the contract development experience for you!

Get Started with pre-builts

Navigate to the Modular Contracts collection on Explore

Choose the modular contract you want to deploy

Fill out contract parameters and deploy the contract

Configure your contract's functions post-deployment through Explorer

Navigate to the Manage tab to manage your contract's extensions

FAQs

• What will happen to my non-modular contracts that I previously deployed?
  • Those contracts will still be available through the dashboard
• Do I need to update my existing contracts to use the new modular contracts?
  • To use the modular contracts, you must deploy the modular contract version of your previous contract. Existing contracts will still be supported through dashboard.
• I cannot find the ______ button on the new modular contract version of the contract. What do I do?
  • We are currently implementing custom UIs for each contract that will be available in the next update. For now you can interact with the contract using Explorer. Hang tight!

We've enabled a way to refresh metadata / ABI from the contract page.

Navigate to the sources tab on your contract page, and click the "Refresh Contract Data" button as shown below:

This will clear any cached metadata and fetch the contract ABI / functions again.

The Pay Embed now directly supports three separate use cases or "modes".

"Fund wallets" allows any connect wallet to buy tokens with their wallet's existing funds or credit card.

import { PayEmbed } from "thirdweb/react";
 
<PayEmbed
  client={client}
  payOptions={{
    mode: "fund_wallet",
  }}
/>;

"Direct payment" allows any wallet to accept payments via crypto or credit card.

import { PayEmbed } from "thirdweb/react";
 
<PayEmbed
  client={client}
  payOptions={{
    mode: "direct_payment",
    paymentInfo: {
      sellerAddress: "0x...",
      chain: base,
      amount: "0.1",
    },
    metadata: {
      name: "Black Hoodie (Size L)",
      image: "https://example.com/image.png",
    },
  }}
/>;

"Transaction" lets users pay for a specified transaction using credit card or crypto on any chain.

import { PayEmbed } from "thirdweb/react";
 
<PayEmbed
  client={client}
  payOptions={{
    mode: "transaction",
    transaction: claimTo({
      contract,
      tokenId: 0n,
      to: toAddress,
    }),
    metadata: nft?.metadata,
  }}
/>;

You can also configure the TransactionButton component to show metadata to personalize the transaction payment flow.

import { TransactionButton } from "thirdweb/react";
 
<TransactionButton
  transaction={() => {
    return transfer({
      contract,
      amount: 10n,
      to: toAddress,
    });
  }}
  payModal={{
    metadata: {
      name: "Buy me a coffee",
      image: "https://example.com/image.png",
    },
  }}
/>;

Our default social login uses a popup to prompt the user to complete OAuth sign-in. This can cause issues on certain browsers or embedded experiences such as telegram. For these cases, we've added the ability to use a redirect rather than popup window when authenticating users.

import { inAppWallet } from "thirdweb/wallets";
 
const wallet = inAppWallet({
  auth: {
    mode: "redirect",
  },
});

• NFTInput and NFTMetadata types are now available

Users can now change their wallet in the ConnectEmbed "Sign In" auth step

Version 5.40 of the thirdweb TypeScript SDK brings 2 new modes for Pay that enable commerce use cases and facilitate transactions payments within your apps.

Let your users onramp to any token with credit card or from any wallet.

This is the default behavior and doesn't require any extra input. You can use the prebuilt UI or build your own. Can be configured to onramp to any token, on any chain.

<PayEmbed client={client} />;

Sell physical goods, services or perform onchain actions upon receiving a payment in the token of your choice, while letting your users pay with fiat or crypto.

Define the payment token, amount and receiver address. Get notified of every purchase via webhook to your backend where you can verify and finalize the sale.

<PayEmbed
  client={client}
  payOptions={{
    mode: "direct_payment",
    paymentInfo: {
      sellerAddress: "0x...",
      chain: base,
      amount: "35",
      token: getDefaultToken(base, "USDC"),
    },
    metadata: {
      name: "Black Hoodie (Size L)",
      image: "https://example.com/image.png",
    },
  }}
/>;

Use this mode to sell physical goods, enable services or even trigger onchain actions from your backend using Engine.

Let your users pay for an onchain transaction with fiat, a different wallet, token or chain. Automatically execute the transaction once ready.

Automatically picks up the price, currency, fees and chain from the transaction. Optionally pass metadata to enrich the flow, works with NFT metadata out of the box.

<PayEmbed
  client={client}
  payOptions={{
    mode: "transaction",
    transaction: claimTo({
      contract,
      tokenId: 0n,
      to: toAddress,
    }),
    metadata: nft?.metadata,
  }}
/>;

Use this flow for any onchain transaction that requires the user to be the initiator, great for NFT or token mints, marketplace purchases or other contract calls.

This flow is also available when using the TransactionButton and the useSendTransaction hook.

Learn more in the pay documentation.

Happy building! 🛠️

The thirdweb React SDK components are some of the most used across all of web3. We're working to expand our component library to include more capabilities you can already do with the TS SDK. With version 5.39, we've added the ClaimButton component for claiming airdropped ERC20, ERC721, or ERC1155 tokens.

We've improved our RPC caching significantly, allowing major speed-ups across all apps on v5.39 and above with no necessary changes.

• Fixes gas effectiveGasPrice values on XDC networks
• Fixes gas estimation on Arbitrum Sepolia
• Allows overriding nonce for smart contracts
• Fixes thirdweb domain overrides
• Fixes gas estimation on Polygon Amoy
• Minor styling improvements on the Connect UI Send Funds page
• Fixes CLI bun detection

Long story short, you can now do things like this

var contract = ThirdwebManager.Instance.SDK.GetContract("0xEBB8a39D865465F289fa349A67B3391d8f910da9");
var tx = await contract.Prepare("approve", "0x29433d52FA37cDa73D31c759F466be1Cb1764812", 0);
Debug.Log($"Transaction input before preparing: {tx}");
// This step is optional if you don't care about visualizing the input, tx.Send will do it for you
_ = await tx.Popuate();
Debug.Log($"Transaction input after preparing: {tx}");
// You may update the input if you want
var increasedGasLimit = tx.Input.Gas.Value * 10 / 9;
_ = tx.SetGasLimit(increasedGasLimit.ToString());
var hash = await tx.Send();
Debug.Log($"Transaction hash: {hash}");
// or you can wait for the transaction to be mined if you don't care about the hash
// var receipt = await tx.SendAndWaitForTransactionResult();
// Debug.Log($"Transaction receipt: {receipt}");

• [Cross-Platform] General improvements and cleanup of the low-level Transaction builder class, typically created from Contract.Prepare.
  • Added Transaction.Populate - a way for you to prepare a transaction by populating all its fields without sending it.
  • Added Transaction.GetGasFees to get EIP-1559 max fee per gas and max priority fee per gas.
  • Contract.Prepare will now return fully populated Transaction including Data cross platform, instantly.
  • Fixed edge case where if a chain did not support EIP-1559, and no max fee/max priority fee were explicitly set but a gas price was explicitly set, the gas price would be recalculated and overriden.
• [Cross-Platform] Added Wallet.GetNonce - a simple way to get the connected wallet's nonce, defaults to pending blockTag but can be overriden.
• [Cross-Platform] Removed the Contract.Prepare variant that takes in a from address override to avoid confusion and simplify syntax.
• [Cross-Platform] Added support for new chains.
• [WebGL] Updated bridge.

Release: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v4.17.0

We've dramatically improved our in-app wallet authentication and generation, it's now more than twice as fast! This will make way for several new in-app wallet features to drop soon

We've added 30 new preset chains. You can directly import any of these chains with their preset configurations from thirdweb/chains.

• Astria
• Blast Sepolia
• Celo
• Cronos
• Degen
• Fantom Testnet
• Fantom
• Frame Testnet
• Gnosis Chiado Testnet
• Gnosis
• GodWoken
• GodWoken Testnet
• Hokum Testnet
• Localhost
• Loot Chain
• Manta Pacific
• Manta Pacific Testnet
• Moonbeam
• Palm Testnet
• Palm
• Polygon zkEVM Testnet
• Polygon zkEVM
• Rari Testnet
• Rari Chain
• Scroll Alpha Testnet
• Scroll Sepolia Testnet
• Scroll
• Xai Sepolia
• Xai
• zkCandy Sepolia

We've added extensions for the Lens contracts. Check out all out extensions here.

• Adds getRoleHash for retrieving the hashed representation of a given Permissions extension role
• Fixes deterministic deploys that use a specified version with prepareDeterministicDeployTransaction

Fixes implementations resolution of proxied contracts

You can now create in-app wallets via Discord! To get started, specify Discord as an auth option on your inAppWallet when using the Connect UI.

If you'd prefer to build a custom UI, you can connect via Discord directly.

• Moved the wallet switcher component in the Connect UI
• Improved handling for the minimum buy amount in Pay
• Adds ERC20 paymaster supports to the Pay components
• Improves transaction tab styling
• Fix Disconnect React Native button color in light mode
• Enable sending extra calldata in prepareContractCall

We've added IP Allowlist to enhance your Engine instance security. This feature lets you control which IP addresses can access your Engine API while keeping it accessible from Dashboard .

What it does:

• Restricts API access to specified IP addresses
• Keeps Engine accessible from the Dashboard regardless of IP
• Works with both cloud and self-hosted Engine instances

How to use it:

1. Configure IP Allowlist from the Configuration section in Engine Dashboard or using the API
2. Add or remove IP addresses as needed
3. Save changes to apply the new access rules

For setup details and best practices, see our IP Allowlist documentation. Self-hosting behind a reverse proxy? Check our self-hosting guide.

Last week we launched Ecosystem Wallets, enabling anyone to use the same in-app wallets across unlimited apps and games while controlling individual permissions for each integrator. We're continuing to build on Ecosystem Wallets and released the ability to modify your ecosystem's existing partners today. You can now change domains, bundle IDs, partner names, and wallet control permissions from your ecosystem's dashboard.

A common use case for onchain apps is to securely store the user's wallet address on a backend. To do so we recommend using Auth, which streamlines setting up the Sign in with Ethereum (SIWE) protocol between your app and your backend.

In v5.35 of the connect SDK, we added first class support for Auth in react native.

You can now setup the ConnectButton and ConnectEmbed to automatically show a sign in button to authenticate with your backend using SIWE.

// this auth helper should live server side
const thirdwebAuth = createAuth({
  domain: "localhost:3000",
  client,
});
 
<ConnectButton
  client={client}
  auth={{
    getLoginPayload: async (params) => {
      // here you should call your backend, using generatePayload to return
      // a SIWE compliant login payload to the client
      return thirdwebAuth.generatePayload(params);
    },
    doLogin: async (params) => {
      // here you should call your backend to verify the signed payload passed in params
      // this will verify that the signature matches the intended wallet
      const verifiedPayload =
        await thirdwebAuth.verifyPayload(params);
      setLoggedIn(verifiedPayload.valid);
    },
    isLoggedIn: async () => {
      // here you should ask you backend if the user is logged in
      // can use cookies, storage, or your method of choice
      return loggedIn;
    },
    doLogout: async () => {
      // here you should call your backend to logout the user if needed
      // and delete any local auth tokens
      setLoggedIn(false);
    },
  }}
/>;

And of course you can also use the Auth utility methods to build your own UI flow.

Learn more about setting up Auth in the documentation.

Happy Building! 🛠️

Using Account Abstraction, you can now pay for gas using any ERC20! Just set the erc20Paymaster override to the paymaster of your choice when sending a smart account transaction.

The Connect UI now shows transactions completed during the current session. This is enabled automatically, there's no additional configuration needed! We're working on making this history persistent beyond a single session.

You can now specify a from field when reading contracts with readContract or useReadContract. This is useful for contract methods that may behave differently based on the msg.sender.

• Connect UI components now respect custom RPC passed via the chain prop
• Improved gas buffer when gas estimation fails on Pay transactions

Auth allows any app to authenticate users on the backend through their wallets. With v5.35.0, we're bringing the same Auth capabilities from web to mobile. Use Auth in React Native just like you would in your React apps. Learn more about integrating Auth in the docs.

The Airdrop extension provides helper functions for getting claim conditions and claiming a token for a user, but there was previously no easy utility for determining if a user is eligible for a given drop. Now, you can use the fetchProofs helpers (available on all token types) to get the claim proof for a user if that user is on the allowlist. If the user is not eligible to claim, fetchProofs will return null.

The Pay Embed lets any app add a full-featured on-ramping and swapping UI in a single line of code. We're continuing to build on Pay's feature set by adding a recipientAddress parameter. Apps can now allow users to on-ramp funds to one wallet, while signed in with another.

getOwnedNFTs is one of the most used extensions in the thirdweb SDK. It fetches a user's owned NFTs for a specified contract by determining which methods the contract supports for efficient ownership retrieval. We're now adding support for Zora ERC1155 NFTs to the getOwnedNFTs function. Use the function just like before with any ERC1155 Zora NFT contract.

To continue supporting developers across the globe, we've added support for Vietnamese across our Connect UI components.

The thirdweb SDK is great for quick and easy Account Abstraction implementations, but sometimes you need to directly access UserOps and their inputs. We've added several utility functions to get the unsigned user op, overwrite the call gas limit, and directly sign a user operation.

• Coinbase Wallet connection now properly supports universal links on iOS
• In-app wallet typed-data signatures now properly handle domains with no chain ID
• Connect UI network switcher now shows all search results for an active search query
• useWalletBalance hook type expects an explicit address and chain
• Custom network button now closes the Connect UI modal
• Transaction reverts now properly return the revert error message

We’re thrilled to announce our latest dev tool: a new multi-chain faucet designed to to be self sustained. The faucet supports every EVM testnet, and makes it fun to claim testnet funds. You can claim funds once per testnet chain every 24 hours, ensuring a consistent flow of resources for your projects.

To access it visit: thirdweb.com/<chainId>/faucet
Example: https://thirdweb.com/sepolia/faucet

We’ve also added a playful twist to the claiming process—each time you claim funds, you’ll get to spin the wheel to determine the amount you receive.

What is a Faucet?

A testnet faucet is an essential online service for Web3 app and blockchain developers. It allows you to access free testnet funds, enabling you to experiment with and test your smart contracts and apps on any EVM testnet without the need for real cryptocurrency. This vital resource ensures you can build, test, and iterate without financial constraints.

Easy Refill Process

We invite every person that wants to fund in the crowd funded faucet by sending tokens to the following address:

Faucet Address: 0x9A0c4B4997485F51FF1013F7080464780BA8b67D

How Does the Faucet Work?

Our faucet is powered by the robust thirdweb engine, which provides a multi-chain backend to manage all the transfers. When you request testnet funds, a small amount of tokens is transferred to your account, ensuring you have the necessary resources to continue your development seamlessly.

We are excited to provide this essential tool every developer needs.

We’re thrilled to announce the launch of the Try Demo (READ only Sandbox) feature for thirdweb Engine.

Engine Demo provides users with the opportunity to explore and interact with an Engine instance through the thirdweb Engine Dashboard. This experience requires no additional infrastructure or setup costs, allowing users to quickly and easily evaluate the capabilities of Engine.

Here’s what it can do:

• Perform any READ action
• View transactions table for an overview on the state (i.e., queued, sent, mined, failed, cancelled)
• Use the interactive Explorer to interact with Engine API
• View and manage contract subscriptions, access-tokens, configuration, webhooks and other settings/features which can be configured for Engine.

Next up, enable users to perform transactions using AA, Relayers, or EOA wallets via Engine. Stay tuned!

.NET 1.0.1 patches an issue that was found whereby the main thread would be blocked when using the SDK in Godot.

Feel free to update to the latest version of our package.

It also brings you a chain metadata fetching utility:

var chainData = await Utils.FetchThirdwebChainDataAsync(client, 421614);

This can be helpful to display additional metadata about the chain you're using, as most of the SDK is chain-agnostic at compile time. This also returns native currency metadata which can be useful to display in UI.

We've also added utility to any IThirdwebWallet when it comes to signature recovery. This is typically done server side, when you want to validate a signature's signer matches a specific address.

IThirdwebWallet.RecoverAddressFromEthSign(string message, string signature)
IThirdwebWallet.RecoverAddressFromPersonalSign(string message, string signature)
IThirdwebWallet.RecoverAddressFromTypedDataV4<T, TDomain>(T data, TypedData<TDomain> typedData, string signature)

Note: RecoverAddressFromPersonalSign will use EIP-1271's isValidSignature which is useful in a SmartWallet context, as Smart Wallet PersonalSign signatures are specially wrapped in EIP-712 fashion and verified as such.

thirdweb now offers a collection of free tools that web3 developers (including the thirdweb team!) use daily.

• Wei Converter: Convert between wei, gwei, and ether numeric values. These units are commonly used to represent precise currency amounts, gas and transaction fees, and human-readable currency amounts.
• Hex Converter: Convert between hexadecimal and decimal numeric values. Hex values are commonly used to represent numbers in block and transaction payloads.
• Unix Time Converter: Convert a Unix timestamp from seconds or milliseconds to a human-readable local or UTC time.
• Keccak-256 Converter: Convert a string to a Keccak-256 hash, commonly used in Solidity logic.

Try them out, bookmark the page, and let us know what tools you’d like to see next!

In-app wallets are a great way to onboard anyone to your apps and games, but what happens afterward? They'll likely collect NFTs, tokens, and other on-chain data while using your app, but those assets are stuck inside the app that created the wallet. With v5.X.0 of the thirdweb SDK, you can share in-app wallets across apps and games via Ecosystem Wallets. To learn more about what Ecosystem Wallets are, check out our docs. Below, we'll dive into integrating how to add an ecosystem to an existing app.

Connecting to an ecosystem wallet is just like any other wallet. Pass your ecosystem ID (the ecosystem creator should provide this to you) to the createWallet function.

That's all it takes! You now have an ecosystem wallet you can use throughout the SDK. Check out the docs to learn how you can use this wallet. The simplest usage of this wallet is to pass it to our ConnectButton. The sign-in page will contain the ecosystem's specified branding and login options.

Some ecosystems only allow certain apps to integrate with them. You'll need to specify a "partner ID" for these ecosystems. This will set permissions for your app's wallet usage. The ecosystem creator/owner will provide you with this ID.

We’re flipping the script on thirdweb Pay Fee sharing. Previously set at 30%, developers now earn 70% of all thirdweb Pay fees collected through your application!

Here’s how it works: thirdweb collects a 1% fee per end-user transaction, and 70% of these fees are shared with you and instantly transferred to your wallet.

Example: If a user purchases $100 worth of Polygon through your application, thirdweb charges a total fee of $1.00. Of this, thirdweb collects $0.30 and sends $0.70 to you.

Integrate thirdweb Pay into your application and start earning more today!

We just released prebuilt UI components to make it simple to connect users to your react native applications.

The components come it 2 flavors: ConnectButton and ConnectEmbed

All in one component that handles wallet connection and connected state.

<ConnectButton client={client} />;

• Sign in button that opens a modal for connection
• Connected wallet button that opens managing the user's wallets
• Supports ENS name and avatar resolution
• Support displaying balance on any chain and any currency
• UI to view all assets with configurable currencies
• UI to send any currency to another wallet
• UI to receive funds
• Can create wallets for your users based on social / email / phone login
• Can connect to 300+ external mobile wallets
• First party support for ERC4337 smart accounts
• Themable and customizable

Check the Documentation for all configuration options.

Connection component only, embeddable into any screen.

<ConnectEmbed client={client} />;

• Great for building custom login screens
• Can create wallets for your users based on social / email / phone login
• Can connect to 300+ external mobile wallets
• First party support for ERC4337 smart accounts
• Themable and customizable

Check the Documentation for all configuration options.

As always you can also build your own connection flow using the useConnect hook for full control over your UI.

You can try this out in our expo-starter repository on Github.

Happy building! 🛠️

We've dramatically improved the performance of onrampping to Base on thirdweb Pay. It is now a one-step flow that takes seconds to process. Try it out in the Pay Playground, and visit the Docs to start building today.

Thirdweb's .NET SDK has been in development for a couple of months now, and we're finally releasing the first major version packed with a ton of features!

If you want to jump straight into the docs, click here.
The NuGet Package is available here.

All internal classes and some external APIs have been reworked to be more generic and target even more platforms and frameworks. These changes allow for maximum customization and will also lay the ground work for our upcoming Unity major release.

Outside of gaming frameworks, we've also drastically improved performance when it comes to both networking and cryptography, respectively implementing throttling, batching and caching techniques as well as better algorithms for encryption and decryption. We've also made sure nothing blocks the main thread — specially useful for single threaded environments.

Finally, we've simplified some external APIs, so you may notice less required parameters and more optional parameters.

We've added a very large amount of extensions that makes interacting with any contract much easier. These extensions simplify the process of interacting with smart contracts by providing a more intuitive and user-friendly API.

// Without extensions
var receiver = await wallet.GetAddress();
var quantity = BigInteger.One;
var currency = Constants.NATIVE_TOKEN_ADDRESS;
var pricePerToken = BigInteger.Zero;
var allowlistProof = new object[] { new byte[] { }, BigInteger.Zero, BigInteger.Zero, Constants.ADDRESS_ZERO };
var data = new byte[] { };
var receipt = await ThirdwebContract.Write(smartAccount, contract, "claim", 0, receiver, quantity, currency, pricePerToken, allowlistProof, data);
// With extensions
var receipt = await contract.DropERC20_Claim(wallet, receiver, amount);
// Can also do read operations and much more
var balance = await contract.ERC20_BalanceOf("0xOwnerAddress");

Contract extensions for common ERC20, ERC721 and ERC1155 have been added.

Contract extensions for thirdweb's TokenERC20, DropERC20, TokenERC721, DropERC721, TokenERC1155, DropERC1155 have been added.

Contract & Wallet extensions to get the native or ERC20 balance has been added.

NFT Extensions to get all 721 or 1155 NFTs from a contract or user address has also been added (supports enumerable contracts too). The returned type is a List of NFT which contains all your NFT details and metadata. Extensions for that type also exist to download the image bytes, rather than going through our storage classes.

Speaking of storage, we've also added UploadRaw for in-memory uploads.

Unlocking OnRamps and Cross-Chain crypto swaps!

Thirdweb Pay is now available in .NET.

Buy With Crypto Example

using Thirdweb.Pay;
// Swap Polygon MATIC to Base ETH
var swapQuoteParams = new BuyWithCryptoQuoteParams(
    fromAddress: walletAddress,
    fromChainId: 137,
    fromTokenAddress: Thirdweb.Constants.NATIVE_TOKEN_ADDRESS,
    toTokenAddress: Thirdweb.Constants.NATIVE_TOKEN_ADDRESS,
    toChainId: 8453,
    toAmount: "0.1"
);
var swapQuote = await ThirdwebPay.GetBuyWithCryptoQuote(client, swapQuoteParams);
Console.WriteLine($"Swap quote: {JsonConvert.SerializeObject(swapQuote, Formatting.Indented)}");
// Initiate swap
var txHash = await ThirdwebPay.BuyWithCrypto(wallet: privateKeyWallet, buyWithCryptoQuote: swapQuote);
Console.WriteLine($"Swap transaction hash: {txHash}");
// Poll for status
var currentSwapStatus = SwapStatus.NONE;
while (currentSwapStatus is not SwapStatus.COMPLETED and not SwapStatus.FAILED)
{
    var swapStatus = await ThirdwebPay.GetBuyWithCryptoStatus(client, txHash);
    currentSwapStatus = Enum.Parse<SwapStatus>(swapStatus.Status);
    Console.WriteLine($"Swap status: {JsonConvert.SerializeObject(swapStatus, Formatting.Indented)}");
    await Task.Delay(5000);
}

Buy With Fiat Example

// Get a Buy with Fiat quote
var fiatQuoteParams = new BuyWithFiatQuoteParams(
    fromCurrencySymbol: "USD",
    toAddress: walletAddress,
    toChainId: "137",
    toTokenAddress: Thirdweb.Constants.NATIVE_TOKEN_ADDRESS,
    toAmount: "20"
);
var fiatOnrampQuote = await ThirdwebPay.GetBuyWithFiatQuote(client, fiatQuoteParams);
Console.WriteLine($"Fiat onramp quote: {JsonConvert.SerializeObject(fiatOnrampQuote, Formatting.Indented)}");
// Get a Buy with Fiat link
var onRampLink = ThirdwebPay.BuyWithFiat(fiatOnrampQuote);
Console.WriteLine($"Fiat onramp link: {onRampLink}");
// Open onramp link to start the process (use your framework's version of this)
var psi = new ProcessStartInfo { FileName = onRampLink, UseShellExecute = true };
_ = Process.Start(psi);
// Poll for status
var currentOnRampStatus = OnRampStatus.NONE;
while (currentOnRampStatus is not OnRampStatus.ON_RAMP_TRANSFER_COMPLETED and not OnRampStatus.ON_RAMP_TRANSFER_FAILED)
{
    var onRampStatus = await ThirdwebPay.GetBuyWithFiatStatus(client, fiatOnrampQuote.IntentId);
    currentOnRampStatus = Enum.Parse<OnRampStatus>(onRampStatus.Status);
    Console.WriteLine($"Fiat onramp status: {JsonConvert.SerializeObject(onRampStatus, Formatting.Indented)}");
    await Task.Delay(5000);
}

InAppWallet now includes additional login methods to support custom authentication features thirdweb offers, including OIDC-compatible auth or your own generic authentication.

Learn more here.

SmartWallet creation no longer requires an AccountFactory - on most chains, you may use thirdweb's default Account Factory.

AWS-related code has been migrated to their REST API, the AWS SDK is no longer a dependency, making our SDK a lot more portable (specially to web frameworks).

Large amount of fixes and improvements that we hope you'll notice as you go!

Unity 5.0!

Always refer to the Portal documentation to get started.

For a deeper insight into every class that is updated frequently, see the Full API Reference.

The source code is available on github, as always!

In-app wallets are one of the most used features in the thirdweb SDK, allowing anyone to create a wallet within your application using their email, phone number, social logins, or passkey. However, these wallets are siloed to the application they were created in unless the user exports their private key to use with another wallet provider. Now, we're changing that by enabling Wallet Connect for all thirdweb wallets so your users can connect to apps across the web3 ecosystem.

This capability will be enabled by default in the Connect UI for all wallets (backwards compatible). For developers creating a custom UI, we expose everything you need to easily establish and manage connections between your users' wallets and other apps.

If using the connect UI, users will see a "Manage Wallet" button when opening their wallet details. When they navigate to the manage wallet screen then "Connect to an app", they can paste a WalletConnect URI to establish a connection between your app and the one the user connects to. Learn where to get a WalletConnect URI here.

To establish a connection with WalletConnect using a custom UI, you first need to create a WalletConnectClient. This client manages your WalletConnect sessions behind the scenes, similar to how a ThirdwebClient manages your RPC connections behind the scenes.

Once you have a WalletConnect client, you can establish a WalletConnectSession between your wallet and another application with a URI (found in the connecting app).

You're now connected to the external app. When a request is made on the app that generated the URI, it will be sent to the wallet that created the WalletConnectClient.

You can view your active sessions at any time using getActiveWalletConnectSessions, and you can disconnect from any sessions with disconnectWalletConnectSession.

You can add custom event handlers to your WalletConnectClient, enabling things like custom approval or transaction UI elements. To set your own handlers, pass an object of each request you'd like to override to createWalletConnectClient. You can even add additional request handlers that aren't accounted for in the defaults.

We also export the default handlers so you can add additional behavior while maintaining the existing handler function.

We can't wait to see the incredible wallet experiences you build!

We're thrilled to announce the launch of Pay Dashboard, a powerful new addition to the thirdweb dashboard. This comprehensive suite of analytics empowers you to understand Crypto and Fiat transactions via thirdweb Pay

• Transaction Volume: Track the total value of transactions processed through thirdweb Pay, including a breakdown of crypto and fiat payments.
• Volume Trends: Gain insights into how your transaction volume fluctuates over time, allowing you to identify growth patterns and optimize your offerings.
• Payment Performance: Analyze successful vs. failed transactions to pinpoint areas for improvement and ensure a seamless user experience.
• Customer Acquisition: Monitor the trend of new customers acquired through thirdweb Pay, helping you measure the effectiveness of your marketing efforts.
• Customer Insights: Identify your top spenders and analyze the wallet addresses of new customers for targeted marketing and loyalty programs.
• Transaction History: Access a detailed log of all transactions processed through thirdweb Pay

Unlock the power of Pay Analytics by going to thirdweb pay dashboard. Select your API key to gain instant access to this wealth of information 🚀

Today, we are excited to launch a collection of updates to the chainlist page that will make your experience of building with 2000+ EVM chains supported by thirdweb much better.

The first big visual change is that you'll be able to see all the enabled services for each chain. You can now easily see this at the front page or use the filters to find thirdweb support by a specific product. We've also conveniently listed chains with full product support at the top so you can easily find chains that are fully supported by thirdweb's entire full stack development tools from front-end to onchain tools.

When you visit any chain page in our chains database, you’ll be able to see a list of all the thirdweb products supported on the chain, metadata, as well as useful links to any faucets & the explorer. If a chain has claimed and verified this page, you’ll also be able to read additional information provided by the chain about what makes their chain a great ecosystem to build on.

Finally, you’ll be able to add specific chains to your favorites. Now, anywhere that you have to select a chain on our dashboard for testing or contract deployment, you’ll see your favorited chains at the top of the list. No longer do you have to manually find your chain every time and override it when you switch browsers!

If you are a chain looking to claim and verify your page to enrich the data for devs or add more developer support, please contact us using this form: https://share.hsforms.com/1o01TyfsZRAao2eCrzuXSVgea58c.

If you are a dev, you can experience the latest and greatest updates on the chainlist page today at thirdweb.com/chainlist!

The Engine v0.9.5 update brings some new features and improvements.

The /contract/write endpoint (docs) now accepts an optional contract ABI which allows calling methods on unverified contracts where the ABI can't be auto-resolved.

The Engine dashboard now supports ngrok URLs to tunnel your locally running Engine instance.

Keypair authentication is used to create short-lived access tokens. Now these tokens accept a bodyHash argument to ensure it can only be used for a specific use case. Read more about keypair authentication

Cloud-hosted Engine users can view their CPU and memory usage under Configuration on the Engine dashboard.

The /transaction/:chain/send-signed-transaction endpoint now supports sending signed transactions on zkSync.

thirdweb Engine is an open-source server for your app to read, write, and deploy contracts at production scale.

Self-host for free or get a cloud-hosted Engine for $99/month.

Smart Wallets on ZkSync Sepolia and Mainnet are now officially supported cross-platform in Unity.

To enable, simply set your Smart Wallet gasless option to true in your ThirdwebManager - and connect to a Smart Wallet of any kind - voila!

No account factory needed, no additional setup, your EOA address is preserved.

Try it out in our latest 4.16.1 release.

The Unity 4.16.0 release brings you an upgrade to the MetaMask SDK which improves the connection flow, network switching functionality as well as the session persistence behavior.

We highly recommend upgrading if you were using WalletProvider.MetaMask in your project and running into such issues on Desktop or Mobile.

We appreciate the Consensys team's efforts for their help integrating this upgrade!

Since 4.15, various improvements were also made, the main one being a substantial improvement to caching behavior in WebGL, speeding up initial requests by 10x or more.

Coinbase Smart Wallet is officially live on mainnet, and you is available out of the box in the Connect SDK.

The easiest way to let your users connect to Coinbase Smart Wallet is using the ConnectButton or ConnectEmbed component. Easy to setup and highly customizable React components. Just drop it into your app and done.

import { createThirdwebClient } from "thirdweb";
import { ConnectButton } from "thirdweb/react";
 
const THIRDWEB_CLIENT = createThirdwebClient({
  clientId: "your_client_id",
});
 
function App() {
  return <ConnectButton client={THIRDWEB_CLIENT} />;
}

You can also build your own UI and craft your login flow straight into your app using React hooks:

import { useConnect } from "thirdweb/react";
import { createWallet } from "thirdweb/wallets";
 
function App() {
  const { connect } = useConnect();
 
  return (
    <>
      <button
        onClick={() =>
          connect(async () => {
            const wallet = createWallet("com.coinbase.wallet", {
              walletConfig: {
                // choices are 'all' | 'smartWalletOnly' | 'eoaOnly'
                options: "smartWalletOnly",
              },
            });
            await wallet.connect({ client });
            return wallet;
          })
        }
      >
        Connect your Smart Wallet
      </button>
    </>
  );
}

You can give it a spin it on our live playground!

Happy building! 🛠️

We've improved our contract verification and import tools to support any EVM chains (L1, L2, L3) with a Blockscout explorer.

Easily verify contracts deployed with the thirdweb deploy CLI on the chain's Blockscout explorer. Go to the thirdweb dashboard and click the 'Verify contract' button under sources.

Contract import on all chains that support blockscout based explorers will now be auto-enabled once added to thirdweb's list of supported chains. As long as a contract is verified on blockscout, thirdweb dashboard will be able to automatically resolve its sources and abi.

Want to integrate Coinbase Smart Wallet and other EIP-5792 wallets into your app? In a previous release, we added built-in support for EIP-5792 to the TypeScript SDK. Now, we're making it even easier with built-in react hooks like useCapabilities, useSendCalls, and useCallsStatus. These hooks cover the most fundamental questions an app must ask:

1. What can the user's wallet do?
2. How can I tell the user's wallet to do something?
3. How do I update my UI when those actions are pending or completed?

The introduction of smart wallets has made it increasingly difficult to know what a user's wallet is capable of. useCapabilities gives your front-end immediate access to which advanced wallet features (think batched transactions or paymasters) a user's currently connected wallet is capable of.

useSendCalls returns a function to send any number of transactions to the user's connected wallet. When the calls are completed, they'll automatically trigger revalidation of all reads from contracts that were interacted with. No more inefficient requests every render and no more cache invalidation struggles! All while using the latest wallet capabilities available.

You can optionally await the confirmed result of send calls.

Add gas sponsorship in a single line.

Once you send a set of calls, you'll likely want to provide users with real-time information on which calls are pending, which are confirmed, and what the final settlement state was. The useCallsStatus hook does this for you with the same built-in efficiency you can expect with all thirdweb React SDK hooks.

Want to try these and other EIP-5792 features for yourself? Check out our demo app here or fork its GitHub repository and start experimenting!

The latest release of the typescript and dotnet connect SDK enable smart accounts with sponsored transactions on zkSync with no extra code.

We made incredibly easy to take advantage of the native account abstraction feature of zkSync chains. You can use the same smart account API already present in the connect SDK with no other changes, we handle the complexity for you.

Here's an example using our in app wallet API, which let's your users connect to their smart account with email, socials, phone or passkey.

const wallet = inAppWallet({
  smartAccount: {
    chain: zkSync,
    sponsorGas: true,
  },
});
 
const account = await wallet.connect({
  client,
  strategy: "google", // or "email", "phone", "passkey"...
});
 
// gasless transaction with native zkSync AA
sendTransaction({ transaction, account });

And here's one using our prebuilt UI component to connect to any wallet with native account abstraction and sponsored transactions enabled:

<ConnectButton
  client={client}
  accountAbstraction={{
    chain: zkSync,
    sponsorGas: true,
  }}
/>;

We're excited to see what you can build with native account abstraction!

Happy building ⚒️

The .NET SDK 0.4.0 brings you an enhanced version of ZkSync AA.

In a recent release, we announced ZkSync (DIY) Account Abstraction support, where you had to deal with the paymaster contract and inputs yourself.

With this release, we bring you an amazing alternative provided by thirdweb infrastructure.

Instantiating a Smart Wallet using the SDK will now automatically have all the paymaster infra ready for you, so all you have to do is send transactions!

Here's how easy it is to achieve:

// Create your smart wallet as usual
var zkSmartWallet = await SmartWallet.Create(
    client: client, 
    personalWallet: privateKeyWallet, 
    chainId: 324, 
    gasless: true
);
Console.WriteLine($"Smart wallet address: {await zkSmartWallet.GetAddress()}");
// This also works with Contract.Prepare or raw ThirdwebTransaction
var zkTxHash = await zkSmartWallet.SendTransaction(
    // simple self-transfer of 0 value
    new ThirdwebTransactionInput() 
    { 
        From = await zkSmartWallet.GetAddress(), 
        To = await zkSmartWallet.GetAddress(), 
    }
);
Console.WriteLine($"Transaction hash: {zkTxHash}");

Smart Wallets created on zksync chains will now... just work!

In previous versions of our SDK, choosing WalletConnect was akin to choosing MetaMask as a WalletProvider when connecting. We wanted to make sure we captured most of the WalletConnect features and have the two connection methods achieve different things, respectively:

• Provide a simple interface for a single MetaMask connection using the native MM SDK, where you can easily customize the prefab, and in WebGL use the browser extension instantly without UI.
• Make WalletConnect the option to support now over 400 wallets using a standalone modal that fits right into your desktop and mobile games.

We've now reached the point where we can gladly say WalletConnect is a stable option for developers who want to support external wallets, perhaps alongside web2 login options thirdweb provides - it has been customized to be fully integrated with the thirdweb Unity SDK, and you can now reach a wider audience easily.

To connect using WalletConnect, as usual, simply call SDK.Wallet.Connect and the magic will happen automatically.

using Thirdweb;
public async void ConnectWallet()
{
    // Reference to your Thirdweb SDK
    var sdk = ThirdwebManager.Instance.SDK;
    // Configure the connection
    var connection = new WalletConnection(
      provider: WalletProvider.WalletConnect,
      chainId: 1
    );
    // Connect the wallet
    string address = await sdk.Wallet.Connect(connection);
}

• Support for additional wallets: you can now connect to 400+ different wallets using their respective deeplinks, cross-platform.
• WalletProvider_WalletConnect now fully utilizes the WalletConnect UI Modal.
• You can customize which wallets to include, this feature was previously only available for WebGL, add the wallet ids to your ThirdwebManager's WalletConnect Options to use this.
• Support for selecting different accounts for wallets that integrate this feature.
• Support for connecting to multiple chains, and switching networks without being prompted until the next request comes in (big UX difference specially on mobile!)
• All issues with reconnection have been fixed, disconnect and reconnect as you please, with any wallet you like!
• All issues with mobile deeplinking and redirection have been fixed.
• UI adapts to screen size and orientation.

Special thanks to the WalletConnect team for help with debugging and integration to get this to the finish line.

• [WebGL] Updated bridge.
• [Native] Improved network switching functionality for the MetaMask WalletProvider.
• [Cross-Platform] Added support for new chains.

Try it out: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v4.14.0

In-app wallets are a great option to quickly onboard users who might not have an existing wallet. The problem is, users eventually need a way to use their existing in-app wallets with wallet providers like Rabby or Rainbow. Starting with version 5.25.0 of the thirdweb React SDK, users can export their in-app wallets' private keys in the Connect Modal.

This option is shown to users by default, but if you don't want to expose the private key export, you can easily disable it by setting the in-app wallet hidePrivateKeyExport option to true.

We just released v5.25.0 of the connect SDK which allows connecting to hundreds of mobile wallets including Metamask, Coinbase wallet, Rainbow, Trust and many more, directly from your react native app.

You can use the same API as the web to connect to any external wallet.

const { connect, isConnecting } = useConnect();
 
const connectMetamask = async () => {
  const wallet = createWallet("io.metamask");
  await connect(async () => {
    await wallet.connect({
      client,
    });
    return wallet;
  });
};

Any WalletConnect v2 compatible wallet is supported, and we've also added native support for Coinbase Wallet proprietary app communication protocol.

Check out the demo app to see a reference working implementation.

Happy building! 🛠️

A release packed with features you never knew you needed!

Let's start with an example:

// Prepare a transaction directly, or with Contract.Prepare
var tx = await ThirdwebTransaction.Create(
    client: client,
    wallet: privateKeyWallet,
    txInput: new ThirdwebTransactionInput()
    {
        From = await privateKeyWallet.GetAddress(),
        To = await privateKeyWallet.GetAddress(),
        Value = new HexBigInteger(BigInteger.Zero),
    },
    chainId: 300
);
// Set zkSync options
tx.SetZkSyncOptions(
    new ZkSyncOptions(
        // Paymaster contract address
        paymaster: "0xbA226d47Cbb2731CBAA67C916c57d68484AA269F",
        // IPaymasterFlow interface encoded data
        paymasterInput: "0x8c5a344500000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000"
    )
);
// Send as usual, it's now gasless!
var txHash = await ThirdwebTransaction.Send(transaction: tx);
Console.WriteLine($"Transaction hash: {txHash}");

Here, we're interacting with ZkSync Sepolia by setting the chain id to 300, using a simple GaslessPaymaster we funded with a little bit of ETH. We set its contract address in the paymaster field. The second required parameter is paymasterInput which is the encoded function related to your paymaster, with whatever inner input it requires. In this case, it's just the function selector of the IPaymasterFlow.general function, which is plenty for our use case. You could extend this to use a SignatureBasedPaymaster instead and append some signed typed data from an authorized private key to approve each transaction before sending it into your paymaster. Some example paymasters can be found here.

You'll also notice that the internal TransactionInput is now ThirdwebTransactionInput - as we expand support for different transaction types, we'll be using this custom input type and keep adding options to it!

Additional documentation can be found here.

We now support 1559 transaction types in .NET, and prioritize them over legacy type transactions. We'll deal with this in the background if you don't explicitly set gas fees when creating your transaction. If you want to use a legacy type transaction, simply set the Gas Price and we'll respect it.

Here's how you'd override 1559 fees on your transaction object:

_ = transaction.SetMaxFeePerGas(1000000000);
_ = transaction.SetMaxPriorityFeePerGas(1000000000);

Managed ZkSync Paymasters so you don't even have to deal with input? Through creating a SmartWallet? Perhaps!

Maybe a WalletConnectSharp integration, and MAUI starter template to keep Godot's company - stay tuned!

The power of web3 lies in its interoperability! You can now use all of the connect SDK within a wagmi app, or use any wallet connection solution of your choice.

The secret is to use our wallet adapter by calling createWalletAdapter and setting the 'adapted' wallet as the active wallet within the connect SDK.

This works in conjunction with our ethers 5, ethers 6 and viem adapters, which covers most of the wallet connection libraries out there!

Check out this Github repository to learn how to set this up.

Happy building! 🛠️

We just released v5.23.0 of the connect SDK with React Native support!

With this release, you can use almost all of the thirdweb package inside a react native application with the exact same API as web.

The only difference is that you need to install the @thirdweb-dev/react-native-adapter package along with some other peer dependencies.

To get started, follow the installation instructions in our developer portal.

We built a live demo using expo that showcases signing in with google and phone number to create in-app wallets with the smart accounts for gasless transactions.

In this version, you can use in-app and smart wallets to build onchain mobile apps with great UX, interacting with any contract on any EVM chain. External wallets like WalletConnect, Coinbase Wallet and others will be added in the next version.

We'll be adding native UI components for connect, transaction and pay in the upcoming versions as well, but everything can be built right now natively using the SDK functions and hooks.

We're so excited about bringing the best of thirdweb to mobile apps, and can't wait to see what you build with it!

As the .NET SDK moves towards parity with other SDKs, we've integrated a simple way for you to login using OAuth (Google, Facebook, Apple, etc.) with InAppWallets.

With a single API call, you can go through the whole flow and customize it based on the platform you're using.

// Windows console app example
var address = await inAppWallet.LoginWithOauth(
    isMobile: false,
    browserOpenAction: (url) =>
    {
        var psi = new ProcessStartInfo { FileName = url, UseShellExecute = true };
        _ = Process.Start(psi);
    },
);
// Godot standalone example
var address = await ThirdwebManager.Instance.InAppWallet.LoginWithOauth(
        isMobile: OS.GetName() == "Android" || OS.GetName() == "iOS",
        browserOpenAction: (url) => OS.ShellOpen(url),
        mobileRedirectScheme: "thirdweb://"
);

Documentation available here.

We've also updated our Godot Starter Template with a Login with Google example.

Note: this feature in Godot context is only available for Desktop platforms, Mobile coming soon!

Nuget release here.

EIP-5792 simplifies how apps can leverage wallets' full capabilities like batch transactions, sponsored transactions, auxiliary funds, and anything else smart contract accounts are now capable of. We've added built-in support for wallet_sendCalls, wallet_getCapabilities, and wallet_getCallsStatus so app developers can provide the best possible user experience regardless of the wallets their users bring to the app. With v5.22.0 the Connect SDK exposes 3 simple functions to take advantage of the Wallet Call API.

Send any number of transactions via the sendCalls function. You prepare the transactions as if you were using sendTransactions, then pass them as an array to sendCalls.

import { createThirdwebClient } from "thirdweb";
import { mainnet } from "thirdweb/chains";
import { sendCalls } from "thirdweb/wallets/eip5792";
 
const client = createThirdwebClient({ clientId: ... });
 
const USDC_CONTRACT = getContract({
  client,
  chain: mainnet,
  address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
})
 
const send1 = transfer({
  contract: USDC_CONTRACT,
  amount: 100,
  to: "0x33d9B8BEfE81027E2C859EDc84F5636cbb202Ed6",
});
const send2 = transfer({
  contract: USDC_CONTRACT,
  amount: 100,
  to: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709"
});
 
const bundleId = await sendCalls({
  wallet, // get your wallet using createWallet or useActiveWallet
  client,
  calls: [send1, send2],
});

We try to make sendCalls as compatible as possible with all wallets, so you don't need to worry about what type of wallet the user has connected. It currently works with Coinbase Smart Wallet, thirdweb in-app wallets, thirdweb smart wallets, and any third party wallets that currently support EIP-5792. In future releases, we'll add fallback support so the wallet reverts to traditional transactions if it doesn't support EIP-5792. Until then, we recommend wrapping sendCalls in a try block to catch any errors from unsupported wallets.

Sponsor your user's transactions with a single line by adding the thirdweb paymaster URL:

const bundleId = await sendCalls({
  wallet, // get your wallet using createWallet or useActiveWallet
  client,
  calls: [send1, send2],
  capabilities: {
    paymasterService: {
      url: `https://${CHAIN.id}.bundler.thirdweb.com/${client.clientId}`,
    },
  },
});

You'll be able to configure which domains use this paymaster URL in your thirdweb dashboard. For more complicated paymaster logic, you can setup a paymaster proxy based on ERC-7677.

Once you send a set of calls to your wallet, fetch their status using getCallsStatus. This will return a status field of either "CONFIRMED" or "PENDING" and a receipts array containing the completed transaction receipts.

import { createThirdwebClient } from "thirdweb";
import { sendCalls, getCallsStatus } from "thirdweb/wallets/eip5792";
 
const client = createThirdwebClient({ clientId: ... });
 
const bundleId = await sendCalls({ wallet, client, calls });
 
let result;
while (result.status !== "CONFIRMED") {
  result = await getCallsStatus({ wallet, client, bundleId });
}

Knowing what UX a wallet can provide helps you surface the right features to your app's users. getCapabilities returns an object showing the capabilities for different chains the wallet has access to. For thirdweb in-app wallets, this will be the currently connected chain.

import { createWallet } from "thirdweb/wallets";
import { getCapabilities } from "thirdweb/wallets/eip5792";
 
const wallet = createWallet("com.coinbase.wallet");
const capabilities = await getCapabilities({ wallet });

Over the coming weeks we'll release additional improvements / support for EIP-5792 and other standards for making dApp development easier than ever.

We shipped a major update to thirdweb Pay - the ability to pay with a credit or debit card for any transaction.

This means you can eliminate all the barriers between web3 and web2 for your users. Pay allows users to transact with a credit card or any other crypto that already exists in their wallet.

Take a look at the docs and start building 🔨!

We've released a new way to customize the built-in Connect Modal to seamlessly blend in with the rest of your app. Pass an image, alt tag, along with height and/or width to any in-app wallet's metadata field.

import { inAppWallet } from "thirdweb/wallets";
 
const wallet = inAppWallet({
  metadata: {
    image: {
      src: "https://i.ibb.co/JyF66pr/Aperture-Laboratories-Logo-1.png",
      width: 350,
      height: 100,
      alt: "Aperture Laboratories",
    },
  },
});

The logo will then show in the modal when you pass the wallet to the Connect Button. Logo scaling and resizing is handled for you across all devices.

import { ConnectButton } from "thirdweb/react";
 
// ...your page code
 
<ConnectButton client={client} wallets={[wallet]} />;

If you're building a custom authentication UI, you can still access the wallet's metadata through its config.

const config = wallet.getConfig();
const logo = config?.metadata?.image;

We can't wait to see your logo on a Connect Modal soon!

thirdweb CLI now features a --zksync option which can be used to publish and deploy contracts with both solc and zksolc compiler settings.

To use the option, run publish or deploy commands as below:

npx thirdweb publish --zksync
npx thirdweb deploy --zksync

Please note that the ZkSync compilation requires zksync-hardhat plugin setup in the contracts repository. Regular solidity compilation works with both foundry and hardhat. Please follow this post for more information.

Once the publish or deploy link is generated, contracts can be deployed on any chain, including ZkSync, from the same link or publish page.

Feel free to reach out if there are any issues or questions.

We have enabled the following prebuilt contracts for deployment on ZkSync era mainnet and ZkSync era sepolia-testnet:

• VoteERC20
• Split
• Airdrop
• OpenEditionERC721
• Pack
• Multiwrap
• LoyaltyCard
• StakeERC721
• StakeERC1155
• StakeERC20

This is in addition to the Drop, Token, and Marketplace contracts which are already active.

Go ahead and deploy contracts of your choice on ZkSync here.

We just released an important update for the connect SDK v5.20.0, adds the ability to sign in with passkeys and revamped the connect react component UI.

You can now create in-app wallets for your users with just a fingerprint! No emails, no passwords.

Passkeys are available out of the box in the connect UI components, along with a new look:

And you can also create your own UI around it with the useConnect() hook:

import { inAppWallet, hasStoredPasskey } from "thirdweb/wallets/in-app";
 
const { connect } = useConnect();
 
const handleLogin = async (email: string, verificationCode: string) => {
	await connect(() => {
		const wallet = inAppWallet();
		const hasPasskey = await hasStoredPasskey(client);
		await wallet.connect({
			client,
			strategy: "passkey",
			type: hasPasskey ? "sign-in" : "sign-up",
		});
		return wallet;
	});
};

You can combine this with gas sponsorship for in-app wallets to create a best in class UX for your onchain apps.

Happy building! 🛠️

In-app wallets got an update in v5.19 of the connect SDK that allows for sponsoring gas and use all the benefits of smart accounts with just 2 extra lines of code!

In-app wallets allow users to login with email/phone/social logins and now accept a smartAccount property which converts the EOA into a smart account, enabling:

• Gas sponsorship
• Atomic batch transactions
• Multiple signers and session keys
• Programmability

To enable it, simply pass the smartAccount property to inAppWallet():

const wallet = inAppWallet({
  smartAccount: {
    chain: base, // the initial chain to connect to
    sponsorGas: true, // whether to sponsor transactinos
  },
});
 
await wallet.connect({
  client,
  strategy: "google",
});

That's it!

Under the hood, the inAppWallet creates a ERC4337 smart account, just like when using smartWallet, but much more convenient!

Note that enabling/disabling this property will result in a different address (smart account vs EOA).

Happy building 🛠️

• [Cross-Platform] Smart Wallet Option Factory Address is now optional in your ThirdwebManager.
  • You may now use Smart Wallets without any setup.
  • ThirdwebManager Smart Wallet Option Gasless now defaults to true.
  • We still recommend deploying your own factory in production, however this makes it easy to prototype cross-chain!
• [Cross-Platform] New Feature - Buy with Fiat
  • OnRamp to crypto tokens using a credit card!
  • US Support (International support coming soon).
  • Multistep Buy with Fiat -> Buy with Crypto support for less liquid tokens, using intent identifiers.
  • Testmode example available in Scene_Pay.

Release: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v4.13.0

The Linea Goerli testnet, supported by Linea, will be discontinued effective May 31, 2024. This significant update will impact thirdweb’s products and services, including the SDK, Paymaster, Embedded Wallet, contracts, and all other offerings relying on the Linea Goerli testnet.

• Contract Deployment: Post-deprecation, it will not be possible to deploy new contracts on Linea Goerli
• Contract Interaction: Existing contracts on Linea Goerli will not be accessible or manageable through the dashboard, SDKs, or any other tools.
• Service Interruptions: Services such as the Embedded wallets, RPC Edge, and the Account abstraction infrastructure including Bundler / Paymaster will cease for Linea Goerli.

Why is Linea Goerli testnet being phased out?

Discover the reasons behind this decision from the official Linea documentation.

What are the alternatives?

We recommend migrating your contracts to Linea Sepolia testnet.

Chain Information:

• Chain ID: 59141
• RPC URL: https://rpc.sepolia.linea.build
• Block explorer:
  • Lineascan
  • Blockscout
• Symbol: ETH

View full chain information on our chainlist.

What will happen to existing contracts?

Contracts currently hosted on Linea Goerli will be unsupported, rendering them inactive and non-interactable.

Deadline for service termination?

All support for Linea Goerli will cease at 12:00 AM PST on May 31, 2024

We recognize the challenges posed by such changes and are prepared to assist you throughout this transition. For any queries or additional information, please feel free to visit our support page and submit a ticket.

As we prioritize support for the latest version of our Connect SDKs, we are updating all of our resources to be compatible with this version. Today, we have the latest Starter templates available to clone directly through the CLI or on GitHub

Starter templates come with Connect SDK pre-installed to save you precious developer time and provide a more efficient experience when developing with thirdweb.

The following starter templates are now updated:

• Next Starter
• Vite Starter
• Node Starter

To get started with our templates in your CLI, run npx thirdweb create --app

If you'd like to have more Starter templates available in different frameworks, please submit a ticket on our feedback board!

Connect TypeScript SDK v5.16.0 makes dealing with smart accounts as easy as regular EOAs, with a new simplified setup and multichain capabilities.

Notable changes:

• factoryAddress is now optional, by default it will use a standard account factory pre-deployed on all chains at 0x85e23b94e7F5E9cC1fF78BCe78cfb15B81f0DF00
• Smart Accounts can now switch chains while maintaining the same account address. Requires an deterministic account factory deployed on that chain.

It now takes only 2 lines of code to convert any EOA to a smart account.

<ConnectButton
  client={client}
  accountAbstraction={{
    chain: sepolia,
    sponsorGas: true,
  }}
/>;

Switching chains will happen automatically as long as you use the default account factory or if you've deployed your own account factory on these chains!

Happy building 🛠

As part of our ongoing efforts to improve our services and streamline our development processes, we are announcing the formal deprecation of our Python and Go SDKs. This decision allows us to better focus our resources on developing and enhancing thirdweb Engine — our production-grade HTTP server to interact with any smart contract on any EVM and an alternative to the former SDKs.

Deprecation Date: June 3, 2024

Affected Products:

• Python SDK
• Go SDK

What This Means for You:

• Deprecation Phase: The Python & Go SDKs will no longer receive any maintenance from our team and will be archived (read-only) on GitHub. We discourage users from continuing to use the SDKs while not maintained.

• Migrate to Engine as soon as possible to continue developing the back end of your web3 applications. Engine supports development on any back end language including Python and Go among many.

We understand that these changes might pose challenges, and we are here to help. Our support team is available to assist you in migrating to Engine — for any issues, please visit our support site.

We appreciate your understanding and are committed to making this transition as smooth as possible.

We just released v5.15.0 of the Typescript Connect SDK, with full support for Coinbase Smart Wallets on Base Sepolia and Base Mainnet.

You can connect to Coinbase Smart Wallets using either:
- the ConnectButton or ConnectEmbed UI components
- the useConnect react hook in your own UI.

Here's an example using the useConnect hook:

const { connect } = useConnect();
 
const connectCoinbase = async () => {
  connect(async () => {
    const cb = createWallet("com.coinbase.wallet");
    // this will trigger the smart wallet connection flow
    await cb.connect({
      client,
      chain,
    });
    return cb;
  });
};

Once connected, you can use the rest of the connect SDK to perform transactions from the connected Coinbase Smart wallet as you would normally, using useSendTransaction or the TransactionButton component for example.

You can configure the behavior to smart wallet or EOA only passing options to createWallet like so:

const cb = createWallet("com.coinbase.wallet", {
  appMetadata: {
    // customize your app metadata
    name: "my app",
  },
  walletConfig: {
    // options are "eoaOnly" | "smartWalletOnly" | "all" (default)
    options: "smartWalletOnly",
  },
  // the supported chains (only base and base sepolia supported)
  chains: [base],
});

Happy building! 🛠

Get up and running with a cloud-hosted Engine instance with one click in < 20 minutes.

Starting today, requesting a cloud-hosted Engine now deploys infrastructure immediately upon payment ($99/month subscription).

And stay tuned for an exciting infrastructure update next week...

thirdweb Engine is an open-source server for your app to read, write, and deploy contracts at production scale.

Self-host for free or get a cloud-hosted Engine for $99/month.

In the latest version of the Connect SDK (v5.12.0) we've made it easier to convert any EOA wallet to a smart account!

You can now pass the accountAbstraction prop directly to useConnect - this will ensure that any wallet connected via this hook will be converted to a smart account.

import { useConnect } from "thirdweb/react";
import { inAppWallet } from "thirdweb/wallets";
import { sepolia } from "thirdweb/chains";
 
const client = createThirdwebClient({
  clientId: "YOUR_CLIENT_ID",
});
const chain = sepolia;
 
function App() {
  // 1. set the `accountAbstraction` configuration
  const { connect } = useConnect({
    client,
    accountAbstraction: {
      chain, // the chain where your smart accounts will be deployed
      factoryAddress: "0x...", // your deployed factory address
      gasless: true, // enable or disable gasless transactions
    },
  });
 
  const connectToSmartAccount = async () => {
    // 2. connect with the admin wallet of the smart account
    connect(async () => {
      const wallet = inAppWallet(); // or any other wallet
      await wallet.connect({
        client,
        chain: sepolia,
        strategy: "google",
      });
      return wallet;
    });
  };
 
  return (
    <button onClick={() => connectToSmartAccount()}>Connect</button>
  );
}

And of course, you can also use the ConnectButton or ConnectEmbed UI components and pass the accountAbstraction prop to achieve the same thing with our prebuilt UI.

import { createThirdwebClient } from "thirdweb";
import { ThirdwebProvider, ConnectButton } from "thirdweb/react";
import { sepolia } from "thirdweb/chains";
 
const client = createThirdwebClient({
  clientId: "YOUR_CLIENT_ID",
});
const chain = sepolia;
 
export default function App() {
  return (
    <ThirdwebProvider>
      <ConnectButton
        client={client}
        accountAbstraction={{
          chain, // chain where your smart accounts will be deployed
          factoryAddress: "0x...", // your deployed factory address
          gasless: true, // enable or disable gasless transactions
        }}
      />
    </ThirdwebProvider>
  );
}

For more resources, check out the documentation.

Sign in with phone number is now available in the thirdweb v5 SDK. You can use the ConnectButton to get a pre-built UI or create a custom UI using the inAppWallet as shown below

import { createThirdwebClient, createWallet } from "thirdweb";
import { preAuthenticate } from "thirdweb/wallets/in-app";
 
const client = createThirdwebClient({ clientId: "..." });
 
const phoneNumber = '+123456789';
 
// Send OTP to given phone number
async function sendOTP() {
  await preAuthenticate({
    strategy: "phone",
    phoneNumber,
    client,
  });
}
 
async function connect() {
  // create a in-app wallet instance
  const wallet = createWallet('inApp');
  // if the OTP is correct, the wallet will be connected else an error will be thrown
  const account = await wallet.connect({
    client,
    strategy: "phone";
    phoneNumber,
    verificationCode: '...' // Pass the OTP entered by the user
  });
 
  console.log('connected to', account);
}