Changelog

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.

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);
}

import { createThirdwebClient } from "thirdweb";
import { preAuthenticate } from "thirdweb/wallets/in-app";
import { useConnect } from "thirdweb/react";
 
const client = createThirdwebClient({ clientId: "..." });
 
function Component() {
  const { connect } = useConnect();
  const [phoneNumber, setPhoneNumber] = useState(''); // get phone number from user
  const [otp, setOtp] = useState(''); // get OTP from user
 
  // 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
    await wallet.connect({
      client,
      strategy: "phone";
      phoneNumber,
      verificationCode: otp
    });
 
    // set the wallet as active
    connect(wallet)
  }
 
  // render UI to get OTP and phone number from user
  return <div> ...  </div>
}

You can now use the thirdweb Pay modal UI that comes out of box with ConnectButton simply by using useSendTransaction hook by default.

When sending a transaction with useSendTransaction hook in your react app, it estimates the amount required for executing the transaction and if the user does not have enough funds and thirdweb Pay supports buying token for the given chain - it opens a Pay Modal UI as shown above and prompts the user to Buy the required tokens.

This makes it very easy for the end users to get the required tokens without leaving the app and the app developer also gets a cut of this purchase! See the pricing section for information

The Pay modal is enabled by default when using useSendTransaction normally

const sendTx = useSendTransaction();
 
// later in your code
await sendTx.mutateAsync(tx);

You can also configure the Pay Modal UI as shown below

const sendTx = useSendTransaction({
  payModal: {
    theme: "light",
  },
});

If you want to disable thirdweb Pay modal, you can do it as shown below:

const sendTx = useSendTransaction({
  payModal: false,
});

We are thrilled to share that the latest version of Engine, v0.0.38, has been officially released and is now accessible on our Docker Hub Repository. This update brings enhancements that improve functionality without introducing any breaking changes, ensuring a smooth transition for all users.

• Enhanced Gas Management in Transactions: You can now specify gas-related parameters (gas, maxFeePerGas, and maxPriorityFeePerGas) for a transaction, currently available on end-point POST /contract/:chain/:contractAddress/write. This is an important update towards giving the developers greater control over the costs associated with executing transactions.

{
  "functionName": "transfer",
  "args": ["0x3ecdbf3b911d0e9052b64850693888b008e18373", "2"],
  "txOverrides": {
      "gas": "130000",
      "maxFeePerGas": "1100570",
      "maxPriorityFeePerGas": "1100570"
  }
}

• Deployment Endpoint Enhancement: Publishing a contract with POST /deploy/:chain/:publisher/:contractName should now accurately resolve the deployed contract address in all cases. Deployed addresses are provided in the response (for thirdweb prebuilts and some other contracts) or can be queried with GET /transaction/status/:queueId.

We encourage you to update your Engine Instances to take advantage of these new features and improvements.

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.

• [Cross-Platform] Added support for the thirdweb Engine Relayer
  • This relayer is a service provided by thirdweb for an alternative way to sponsor transactions on behalf of users through Engine.
  • When using Transaction.Send or Transaction.SendAndWaitForTransactionResult you may specify whether to use this gasless feature or not, other higher level APIs will default to the gasless flow if you have the relayer set up.
  • Replaces OpenZeppelin Defender Options.
  • We still recommend using Account Abstraction for gasless sponsorship features through Smart Wallets, however in some cases a relayer is needed!
• [Native] Improved Contract.Write flow.
  • Better gas limit/price/fees estimations when not provided, similar to other APIs.
  • Now uses the gasless relayer by default if it is set up in your ThirdwebManager, similar to other higher level APIs.

Visit our Unity Documentation Portal to learn more!

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

This feature allows your application to use any cryptographic private key to generate access tokens that Engine accepts for a limited duration. No long-lived credentials are transmitted over public internet to minimize the impact of a compromised access token.

This feature is introduced in v0.0.36.
Existing (long-lived) access tokens in Engine remain unchanged.

1. You generate a private and public keypair.
2. You add your public key to Engine.
3. Your backend signs a JWT with your private key.
4. Your backend sends the JWT as the access token to Engine.

Learn more about how to enable and use keypair authentication.

These signed JWTs unblock future work to restrict access tokens by requests (read vs write), endpoint, payload body, and even one-time use.

These improvements enable more secure usage of access tokens to grant prevent misuse of leaked access tokens.

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.

We're thrilled to announce a new addition to our suite of development tools: the thirdweb .NET SDK. This latest innovation extends thirdweb's commitment to simplifying blockchain application development by bringing our powerful, developer-friendly features to the .NET community.

Why .NET for Web3?

.NET is known for its robustness, excellent performance, and broad usage in enterprise applications. By integrating blockchain functionalities into this environment, thirdweb’s .NET SDK empowers you to build secure, scalable, and innovative Web3 applications using familiar tools and languages. It is designed to be lightweight and streamline your development process.

With our focus on gaming, and specifically Unity, we've learned a lot about customer needs and after a lot of iteration, are now able to support multiple platforms through it. Being cross-platform is a key thirdweb feature, and we will continually be supporting different frameworks.

The .NET SDK aims to support Game Engines like GoDot and other .NET applications and abstracts away a lot of the complexities when it comes to infrastructure or low level blockchain interactions.

Key Features of the .NET SDK:

• Simplified Interactions with Smart Contracts: Connecting to and interacting with smart contracts is now more intuitive than ever. With just a few lines of code, you can execute any transaction, and query blockchain data, without needing to deal with ABIs or lower level transaction maniulation.
• In-App Wallets: Unlock the power of seamless user authentication and non-custodial wallet creation. With web2 authentication mechanisms you can create truly seamless and signless login experiences for your users. Offload all the pain of account management to the blockchain, and use this cross-platform, cross-device account as the signer representing your user.
• Account Abstraction: The .NET SDK aims to focus on thirdweb's strongest products, In-App Wallets and Account Abstraction. This is the ultimate pair for any app wanting to gain mainstream adoption, and the availability of such wallet functionality is very limited when it comes to .NET. Few lines of code, login with email or phone, and unlock a signless and gasless experience.
• Comprehensive Developer Resources: We provide extensive documentation and support to get you started quickly and efficiently. Check out our docs and get started!​
• Open Source and Community-Driven: Echoing our commitment to transparency and collaboration, the .NET SDK is open-source. We encourage developers to contribute, suggest improvements, and help us evolve the SDK to meet the community's needs​.

Getting Started with the .NET SDK:

To begin with, installing the SDK is straightforward via NuGet (or adding it to your .csproj if you're using GoDot), a familiar tool for any .NET developer. Here’s a quick snippet to demonstrate how easy it is to query a smart contract using it:

using Thirdweb;
// Initialize your client to unlock thirdweb services
var client = ThirdwebClient.Create(clientId: "myClientId", bundleId: "com.my.bundleid");
// Fetch a contract
var contract = await ThirdwebContract.Create(client, "0x81ebd23aA79bCcF5AaFb9c9c5B0Db4223c39102e", 421614);
// Read from it!
var readResult = await ThirdwebContract.Read<string>(contract, "name");

This simplicity removes the heavy lifting traditionally associated with blockchain integrations, allowing you to focus on creating value for your users.

Join the Revolution!

The release of our .NET SDK marks an exciting step forward in making blockchain technology accessible to a wider range of developers. By reducing complexity and providing familiar tools, we're opening up a world of possibilities for .NET developers eager to explore and innovate in the Web3 space.

What’s Next?

We are committed to continuously improving our tools based on your feedback and the evolving needs of the Web3 ecosystem. Join our developer community, explore our SDKs, and help shape the future of decentralized applications.

Explore More and Connect:

Dive deeper into our documentation and start building today at thirdweb's .NET SDK documentation. Whether you're looking to integrate blockchain features into your existing applications or start a new Web3 project, thirdweb is here to empower your development journey.

Happy Coding!

We have updated our contract deployment process to effectively handle gas-price related issues on certain chains. This removes the need for special handling, and streamlines the deployment flow on more such EVM compatible chains.

Thirdweb supports contract deployment on all EVM compatible chains, as highlighted in this article. However, the process was not so smooth on some chains that have non-standard gas price configurations.

As mentioned in the article, whenever a chain presents with non-standard or extremely high / low values of base fee, which differ from the standard base fee used in keyless transaction for infra deployments, we need to add an exception for that chain and save the custom gas price for that chain.

The latest update removes the need for any custom handling or configuration for chains with non-standard gas price. Instead, we have categorized gas prices into bins. Each bin represents a gas price, and corresponds to a unique address for create2 factory.

This is how it works:

• Check if the common create2 factory (pre EIP-155) is deployed on a chain
• If not, check all gas prices in the bins list to find if a create2 factory was deployed with that configuration and return address
• If no create2 factory found, fetch the gas price for that chain, round it up to the nearest gas bin, and use this rounded-up gas price to construct the create2 factory deployment transaction

In this way, the gas price required for create2 factory's deployment falls into one of the gas price bins, and doesn't need to be hardcoded or custom configured. The solution also takes into account the performance aspects by minimising the number of rpc calls required to check for existing deployments and gas prices.

This truly enables deployment on every EVM, while taking into account minor differences across chains.

Go ahead and deploy contracts on any chain of your choice here.

At thirdweb, we enable a blockchain development world pre-fixed with ‘any.' Last year, we allowed developers to deploy any contract on any EVM chain.

Today, we are adding 'any wallet'—our pre-built components and SDK now support over 350+ wallets. We envision that this improvement will help developers reach more consumers by providing more choices and assisting consumers to discover more wallet options.

1. Install thirdweb v5

npm install thirdweb

2. Instantiate your client.

import { createThirdwebClient } from "thirdweb";
 
const client = createThirdwebClient({
  clientId: "<your_client_id>",
});

3. Create an array of supported wallets.

import { createWallet, embeddedWallet } from "thirdweb/wallets";
 
const wallets = [
  embeddedWallet(),
  createWallet("io.metamask"),
  createWallet("com.coinbase.wallet"),
  createWallet("me.rainbow"),
];

4. Pass in the array to wallets inside of your ConnectButton component

function Example() {
  return (
    <div>
      <ConnectButton client={client} wallets={wallets} />
    </div>
  );
}

Note: If wallets are not specified, the modal will default to showing a few wallets, wallets that are installed in the user’s browser, and an option to see all wallets.

If you’d like to create your own custom wallet connection UI, please refer to our documentation for using the useConnect hook with our supported wallets.

• Custom UI Documentation
• ConnectButton Documentation
• ConnectEmbed Documentation

Which wallets do you support?

See our full list of wallets in our developer documentation.

I don’t see [x] wallet supported. Can you please help add it?

Yes, please raise a GitHub issue and we will be able to assist you.

Is this feature only available in v5 of the SDKs?

This feature is currently only available in v5. For already created applications, we encourage developers to gradually migrate to v5 since it works inter-operably with prior versions of the SDK.

Your feedback is critical to us as we strive to improve our SDKs. If you have any issues, feature requests, or other feedback — we recommend raising an issue on GitHub.

We've made changes to the billing portal that makes it easy to remediate billing-related issues.

• We've improved the first time user experience of adding a credit card on file. Now if your payment method runs into an error, you'll have a more specific and actionable error message.
• When your payment method fails in the middle of a billing cycle, we'll send you in-app and email alerts to ensure your services won't be suddenly interrupted.
• We've also made some stability + bug fixes to the growth trial experiences and billing dashboard overall.

Happy building! 🛠️

thirdweb's new Airdrop contract is available for deployment.

The contract is suitable to use when you want to transfer ERC20 / ERC721 / ERC1155 tokens to a list of recipient addresses, and supports push based, claim based (allowlist), and signature based airdrops.

This contract is an upgrade to the current airdrop contracts. It combines airdrop of the three token types (ERC721/20/1155) into one contract. Moreover, it provides a signature based airdrop option, in addition to currently available push and claim based airdrops.

More details about the contract including source code and usage instructions can be found on the publish page here.

Feel free to reach out if you have any questions.

This changelog serves as a reminder that, as previously announced, Polygon’s Mumbai testnet will be deprecated effective April 8, 2024. This change will affect thirdweb’s product and services including SDK, Paymaster, Embedded Wallet, contracts, and any other products utilizing the Mumbai testnet.

• Unable to deploy contracts After the deprecation date, you will no longer be able to deploy contracts on Mumbai.
• Unable to interact with contracts: Interaction with any contracts deployed to will no longer be supported via dashboard, SDKs, or any other interfaces.
• Disruption to any infrastructure services: Account abstraction infrastructure including Bundler / Paymaster and Embedded Wallets for Mumbai will no longer be supported.

Why is Mumbai being deprecated?

Learn more about the reasons for deprecation from the Introducing the Amoy Testnet for Polygon PoS post.

Which testnet should I use?

We encourage users to deploy any contracts to the new Polygon Amoy Testnet which has improved scalability and lower gas fees

Chain Information:

• Network Name: Polygon Amoy Testnet
• New RPC URL: https://80002.rpc.thirdweb.com
• Chain ID: 80002
• Currency Symbol: MATIC
• Block Explorer URL: https://www.oklink.com/amoy‍
• Faucet: https://faucet.polygon.technology/

What will happen to my deployed contracts?

Contracts deployed to Mumbai will no longer be upheld on the network meaning users cannot interact with the contract. These contracts will be marked as deprecated through thirdweb’s dashboard.

How long do I have till services are completely stopped?

We will be officially stopping support on April 8th 12:00 AM PST

We understand that change can be challenging, and we are here to support you every step of the way. Should you have any questions or need further clarification, please do not hesitate to visit our support site and submit a ticket.

Thank you for your continued support!

Similar to the Email OTP flow, the Phone OTP auth method will send you an OTP as an SMS, resulting in an Embedded Wallet.

// Reference to your Thirdweb SDK
var sdk = ThirdwebManager.Instance.SDK;
 
// Configure the connection
var connection = new WalletConnection(
    provider: WalletProvider.EmbeddedWallet,
    chainId: 1,
    phoneNumber: "+123456789",
    authOptions: new AuthOptions(
        authProvider: AuthProvider.PhoneOTP,
    )
);
 
// Connect the wallet
string address = await sdk.Wallet.Connect(connection);

You may test it out in Scene_Prefabs, the input field has been updated to check for both emails and phone numbers and adapt.
When creating your own UI, we suggest adapting the input field type according to the auth method used, specially for mobile.

This feature is only available on native platforms, WebGL coming soon!

This update brings the unification of all transaction flows and centralizes them around the Transaction class. This means that edge cases, issues with gas on some chains with some APIs, and raw transaction APIs now all should feel smoother and more consistent.

What to expect:

• We will always estimate gas on your behalf if a gas limit is not passed.
• When on a chain that supports EIP-1559, we will always use optimized max and priority fee fetching mechanics and submit the tx as 1559, if a gas price is not explicitly passed (thus overriding our default checks for 1559 support).
• When on a chain that does not support EIP-1559, we will always use optimized gasPrice fetching mechanics and submit the tx as a legacy tx, if a max/priority fee is not explicitly passed (the transaction may still not be legacy with some external wallet providers that may override this).
• Account Abstraction has its own gas pricing flow and will always price User Operations accordingly.
• If relayer options are provided, the transactions will always default to the relayer unless a low level API is used where that can be overridden, such as Transaction.Send. Note that we recommend using Account Abstraction instead of relayers in general.

• [Cross-Platform] Added a utility to copy text to a buffer for cross-platform usage, Utils.CopyToClipboard (used in Prefab_ConnectWallet)
• [Native] Added a utility to fetch legacy gas price Utils.GetLegacyGasPriceAsync.
• [WebGL] Fixed an Account Abstraction edge case where simulation would not account for delegate call overheads in the gas limit.

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

We are thrilled to officially release Connect SDK v5, the latest update to our client-side SDKs. This new version brings a major performance upgrade, simplified installation, and interoperability with other web3 libraries — a highly requested feature from our users.

• Supported Wallets: We now have native support for over 350 wallets when using ConnectButton, ConnectEmbed, or even when building your own custom experience
• Performance Enhancements: This version performs on average 10x faster and bundles 30x lighter than previous versions of the SDK. See benchmarks.
• Single package: Developers only need to install one package to access all web3 tools. Installation is now as simple as npm install thirdweb.
• Pay Support: Support crypto to crypto transactions with the new Pay feature within Connect SDK. See documentation.
• Interoperable: Works side-by-side with other popular libraries and frameworks such as ethers v5, ethers v6, viem, and prior versions of the thirdweb SDK.

1. Install v5 via the CLI

npm install thirdweb@5

2. (Recommended) Obtain a client Id using the thirdweb dashboard and pass the client to methods to get performant RPC on all chains, download/upload to IPFS, and more.

import { createThirdwebClient } from "thirdweb";
 
const client = createThirdwebClient({
  clientId: "<your_client_id>",
});

• Documentation
• Migration Guide
• Source Code
• Next Starter Template
• Vite Starter Template

Is v5 backwards compatible?

v5 is a brand new API but it can be used side-by-side with v4 as it is a a separate package

Can I gradually migrate to v5 instead of all at once?

Yes, v5 is interoperable with prior versions of the SDK and we recommend migrating to the new functions. Please see our migration guide to assist you.

Do you support [x] wallet in the new version?

See our list of supported wallets.

Where can I find [x] feature in the new version?

Most features from v4 are ported to v5 and we are continually adding more in the coming weeks. If you are unable to find the specific functionality, please raise a GitHub issue and we will be able to assist you.

Your feedback is critical to us as we strive to improve our Connect SDKs. If you have an issues, feature requests, or other feedback — we recommend raising an issue on GitHub.

For any other inquiries, please visit our support site.

New Cross-Platform Feature: Buy with Crypto

Simply add using Thirdweb.Pay; at the top of your file to get access to static methods:

• ThirdwebPay.GetBuyWithCryptoQuote: Get a quote for swapping any token pair.
• ThirdwebPay.BuyWithCrypto: Pass said quote into this function to execute the swap and get a transaction hash.
• ThirdwebPay.GetBuyWithCryptoStatus: Get the status of your swap using the transaction hash.
• ThirdwebPay.GetBuyWithCryptoHistory: Additional API to get the swap history of a wallet address.

Buy with Crypto Unity API Reference can be found here.

In addition, a new scene has been added: Scene_Prefabs with a prefab Prefab_BuyWithCrypto to illustrate the basic flow. It is set up for Polygon and will buy 2 WMATIC using the connected wallet's MATIC funds. You may edit the behavior as you please, this prefab serves as an example use case, code can be found in Prefab_BuyWithCrypto.cs

• [Cross-Platform] Wallet.SendRawTransaction no longer waits for the transaction to be mined and returns a tx hash.
• [Cross-Platform] Wallet.ExecuteRawTransaction is a new function that was added this update and will wait for the transaction to be mined.
• [Cross-Platform] Fixed issues with native token transfers using Wallet.Transfer on some chains or some wallets.
• [Cross-Platform] Legacy type transactions are no longer used in mid/high level APIs. They are only used in low level APIs when a gas price is explicitly passed.
• [Native] Fallback gas estimation when Polygon gas station requests fail are now more reliable.
• [Cross-Platform] Improved support for Smart Wallets for all of the above.

This update comes after various reliability improvements and new features which culminated into Unity 4.8.0, and 4.9.0 is the cherry on top!

Documentation Portal: https://portal.thirdweb.com/unity

Developers can now add external links to their published contract. This is to allow linking docs, usage guides, and other useful resources that can be used by a deployer of the contract.

To add resource links to your published contract, click on the Edit button on publish page of the contract (not needed when publishing a contract for the first time). This will display the publish form for the contract.

On the publish form, provide resource links in the resources section as shown below, and proceed with publishing the contract after making these changes.

Once published, the links will get displayed on any contract deployed through the publish page.

Feel free to reach out if you have any questions.

We've heard your feedback and we've delivered! We've cut package sizes and load times around the board, allowing new and existing users to authenticate 20% faster in the latest version of Embedded Wallets for web, available now with no additional effort on your part.

Our embedded wallets implementation sits inside of an iframe which handles the logic behind authentication. This logic has since been updated to use the Connect SDK over the thirdweb SDK v4. As such we were able to reduce our iframe size from 802kb to 684kb.

These improvements mark significant progress on our goal to make any application built on thirdweb more performant and user friendly.

You can get started with the newest version of embedded wallets here.

Cheers!

Engine now supports idempotency keys for write transactions.

Many of you have asked for Engine to prevent duplicate transactions when retrying requests. This feature prevents costly and irreversible errors like transferring funds or minting NFTs more than once.

If an x-idempotency-key header is provided, Engine only submits the transaction if there was not another transaction sent with the idempotency key in the past 24 hours. Subsequent calls with the same idempotency key return the original transaction queueId.

This feature is added to v0.0.29.
Learn more about Preventing Duplicate Transactions.

thirdweb Engine is an open-source server for your web3 app to read, write, and deploy contracts to the blockchain.

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

thirdweb Engine is an open-source server for your web3 app to read, write, and deploy contracts to the blockchain.

The team is working hard to continuously improve stability and developer experience.

• Clear error messages for onchain failures
• Improved reliability during gas spikes
• Higher read/write throughput
• Updated dashboard timeline
• Version indicator with update prompt
• Deploy contracts on behalf of other users
• New endpoints

Engine now return the onchain error from the contract if the call is expected to fail. Bonus: since the transaction is simulated, gas funds are not spent!

Previous: An obscure, low-level error indicating the transaction will fail ("execution reverted").

cannot estimate gas; transaction may fail or may require manual gas limit [ See: https://links.ethers.org/v5-errors-UNPREDICTABLE_GAS_LIMIT ] (error={"reason":"execution reverted","code":"UNPREDICTABLE_GAS_LIMIT","method":"estimateGas","transaction":{"from":"0x4a1677844Da684c840f1780817601fd3DB715286","maxPriorityFeePerGas":{"type":"BigNumber","hex":"0x10c8e0"},"maxFeePerGas":{"type":"BigNumber","hex":"0x10cadc"},"to":"0x9ca57B9341dCB029a5b11163C9a47FB65BA6F4c3","value":{"type":"BigNumber","hex":"0x00"},"data":"0x0075a3170000000000000000000000004a1677844da684c840f1780817601fd3db71528600000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000037697066733a2f2f516d5078364d594d5a7a54466b4e703336787a394832374e58433753334d454a6947476b59636a4d6b766a5a35712f30000000000000000000","type":2,"accessList":null},"error":{"code":3,"data":"0x08c379a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000094416363657373436f6e74726f6c3a206163636f756e7420307834613136373738343464613638346338343066313738303831373630316664336462373135323836206973206d697373696e6720726f6c6520307839663264663066656432633737363438646535383630613463633530386364303831386338356238623861316162346365656566386439383163383935366136000000000000000000000000"}}, tx={"to":{},"from":"0x4a1677844da684c840f1780817601fd3db715286","data":"0x0075a3170000000000000000000000004a1677844da684c840f1780817601fd3db71528600000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000037697066733a2f2f516d5078364d594d5a7a54466b4e703336787a394832374e58433753334d454a6947476b59636a4d6b766a5a35712f30000000000000000000","value":{"type":"BigNumber","hex":"0x00"},"nonce":{"type":"BigNumber","hex":"0x00"},"maxFeePerGas":{"type":"BigNumber","hex":"0x10cadc"},"maxPriorityFeePerGas":{"type":"BigNumber","hex":"0x10c8e0"},"type":2,"gasLimit":{},"chainId":{}}, code=UNPREDICTABLE_GAS_LIMIT, version=abstract-signer/5.7.0)

Now: A clear error returned the contract.

We've fixed numerous bugs that may occur during gas volatility. These cases occasionally caused nonce desync issues in the past.

• Removing a global "max gas price" limit. We'll re-introduce this limit per-chain or per-transaction in the future.
• Ensuring retries attempt with at least 10% higher gas (handles error
  Transaction error: Replacement transaction underpriced
  ).
• Slightly increasing a transaction's gas limit to handle inaccuracies with the RPC provider's estimation.

Our goal is for Engine with 1 vCPU / 1GB memory* to handle the majority of apps' use cases. (*Costs $0.27 / day on AWS!)

We've made a handful of improvements to allow Engine to better handle traffic bursts:

• Configured server timeouts.
• Cached consistent auth computation (no impact to behavior).
• Improved underlying RPC latency.
• Improved underlying Contract metadata resolution latency.
• Scaled up load balancers for cloud-hosted Engine customers.
• Improved extension resolution in the thirdweb SDK.
• Improved batching behavior in the thirdweb SDK.

As a result, a single Engine on minimal infrastructure can handle 100-200 read requests per second and process 500 write requests per second. And throughput scales linearly by adding more Engine instances. Or get a cloud-hosted Engine for thirdweb to manage the infrastructure + scaling.

Bonus: most of these changes were made to thirdweb's infrastructure and SDK, so you'll see improvements across the thirdweb stack!

The timeline in the dashboard shows where in the lifecycle the current transaction is. Select Cancel transaction to cancel any transactions not yet mined.

The version badge in the dashboard now shows your current version.

And if it's out of date, cloud-hosted Engine customers can request a version update. The Engine team will update your host during low traffic (within 2 business days).

The prebuilt contract deployment endpoints now accept a defaultAdmin field which overrides the admin for a deployed contract.

POST /deploy/137/prebuilts/nft-collection
Body:
{
  "contractMetadata": {
    "name": "My NFT Collection",
    "symbol": "ABC",
    "defaultAdmin": "0xb282cAAC28e0bE9b7acad6158765a69D452395b3"
  }
}

This means your app can sponsor contract deployments and the contract admin will be a different wallet address. Your backend wallet that paid the gas will not have any permissions on the deployed contract.

• Sign typed data (EIP-712): POST /backend-wallet/sign-typed-data
• Prepare a signature to sign for ERC721 signature mints:
  POST /contract/{chain}/{contractAddress}/erc721/signature/prepare
  • Returns the typed data to be signed by an external wallet.

The team is continuously iterating based on feedback. Please let us know in Discord if you have feature requests or encounter issues.

Want to contribute? thirdweb Engine is fully open-source and we welcome contributions.

We're also hiring!

You can now update the metadata of ERC721 and ERC1155 NFTs directly from the dashboard!

Click on any of your NFTs and you'll find an "Update Metadata" tab where you can change the name, description, image or individual properties.

Keep in mind that you can also do this programmatically with the SDK:

const newMetadata = { description: "My new description" };
 
const contract = await sdk.getContract("0x...");
await contract.erc1155.updateMetadata(tokenId, newMetadata);

Let us know if you run into any issues!

We are excited to announce the beta release of the all-new thirdweb SDK. Applying the learnings, we have gathered from years of building developer tools in the decentralized computing space; we have created a new SDK that is more powerful, flexible, and easier to use than ever before.

This new version of the SDK covers all the client-side needs to build onchain applications in one simplified package.

• Single package: Developers only need to install one package to access all web3 tools. Installation is now as simple as npm install thirdweb.
• Minimal: Lightweight bundle with a small footprint and minimal dependencies. Up to 90% smaller footprint than the previous version for the same functionality.
• Performant: Fine-tuned for performance and efficiency. See benchmarks below. On average, it has 10x faster execution and up to 75% less memory than the last version for the same functionality.
• Interoperable: Works side-by-side with other popular libraries and frameworks such as ethers v5, ethers v6, viem, and prior versions of the thirdweb SDK.

• First-party support for embedded wallets (email/social login)
• First-party support for account abstraction (client/contracts/infra)
• Connectors for any web3 wallet
• React UI components for connection, transactions, NFT rendering and more
• Instant RPC connection to over 1,000+ EVM chains via thirdweb RPC edge
• Integrated IPFS download / upload
• Interact with any contract
• Extension functions for common contract standards
• Automatic ABI resolution
• CLI for contract deployment, publishing, and code generation

When we built the first iteration of the thirdweb SDK in 2020, there were only a few features that we wanted to provide to developers. Over time, we added more and more features (smart wallets, any-evm, react, react-native, and more) and added those as additional packages, which made the SDK more complex and more challenging to use. With the new SDK, we have combined all the functionality into a single package, making it easier to install, discover, and use.

This decision comes with the clear understanding that tree shaking has to work reliably across this new SDK. We are putting much effort into ensuring that the SDK is as small as possible and that only the parts of the SDK that the developer uses are included in the final bundle.

Some npm install examples

We are paying extremely close attention to the third-party dependencies we rely on in the SDK. This exercise ensures that the SDK is as lightweight as possible, and minimizes the risk of supply-chain security vulnerabilities.

We have reduced the total number of direct dependencies from more than 50 to 15 and we are looking to reduce this further. We are also working with industry partners to help them reduce their dependencies to lower our total transitive dependency count.

We put much effort into this release to optimize every single call for performance and minimal footprint.

The result of this focus is that the new SDK is roughly 10x faster and 30x lighter than the previous version and in-line or faster than other popular SDKs in the space.

We continuously run benchmarks on core SDK functions to ensure we meet our performance goals.

The following are some of the results from our most recent benchmark runs:

Getting started is as easy as running npm install thirdweb@beta in your project. We have also updated our documentation to reflect the changes in the new SDK.

npm install thirdweb@beta

import { createThirdwebClient, getContract } from "thirdweb";
import { balanceOf } from "thirdweb/extensions/erc20";
 
const client = createThirdwebClient({
  secretKey: "<your-secret-key>",
});
 
const USDCContract = getContract({
  client,
  chain: 1,
  address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
});
 
const vitalikBalance = await balanceOf({
  contract: USDCContract,
  address: "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B",
});
 
console.log(vitalikBalance);

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

Additional resources to help you get started:

• Migration Guide
• Documentation
• Next.js Starter Kit
• Vite Starter Kit

We are excited to share the new thirdweb SDK with the world. It is a vast improvement over the previous version, and we are confident that it will be a game-changer for developers building onchain applications.

The SDK is currently in beta, and we are actively seeking your feedback to shape its future.

We want to thank all of the developers who have provided feedback on the previous versions of the SDK, and we are looking forward to hearing your feedback on the new SDK.

We would also like to give special thanks to the tireless maintainers of the open-source projects that built the foundation of the new SDK:

• @jxom - abitype / mipd / viem
• @tmm - abitype / mipd / viem
• @paulmillr - @noble/hashes
• @TkDodo - @tanstack/react-query
• @tannerlinsley- @tanstack/react-query

The Dynamic Account Factory has been discontinued. The means that new users can not deploy the contract from Explore, and our contracts team will not be working on improvements to this contract. The reason behind the deprecation is because we weren't seeing significant demand for the featureset that dynamic accounts provided. Also, it is very gas inefficient compared to the other account factories.

You can still enable upgradeable smart accounts for users using the managed account factory contract. We will be continuing to make improvements there.

We have just shipped 4 new templates that let you easily get started with your web3 game. Each template showcases unique mechanisms that let you build great in-game experiences

Take Flight is a game template that showcases how you can create web3 games with seamless in-game experiences. It does so in 3 key ways

• Easily onboard users with their social login using embedded wallets. Users don't need to set up a wallet to play the game.
• The game is completely gasless, all on-chain interactions are sponsored using account abstraction.
• Since embedded wallets come with multi-device recovery and cross-platform support, you can access your wallet from another device instantly without having to do any sort of manual migration or linking

The game also comes with an on-chain leaderboard that ranks users based on their distance travelled

Link to repo

Blockventure is an RPG-style game that showcases how you can have a seamless in-game experience when interacting with on-chain assets. It comes with an inventory to track your assets, a shop where you can buy assets, and a marketplace where you can trade assets with other players. It's a great way to get started building an on-chain multiplayer economy. Since assets are on-chain, users can truly own their in-game purchases and potentially take them outside the game to other composable games as well.

Link to repo

This template shows you how you can easily monetize your web3 game with in-app purchases. Users can onboard themselves by purchasing assets using traditional methods that they are already very familiar with. This is especially useful for in-game currency mechanisms and on-chain asset marketplaces.

You can learn more about how to integrate In-App purchases in your mobile game by following this guide

Link to repo

Pioneer showcases how you can leverage session keys to create signless, gasless web3 games. It does so using session keys, which let users grant signing access to a game. Session keys also let you scope what type of transactions you want to give signing permissions for, that way users will be protected if they accidentally give signing permissions to malicious clients or clients that get compromised. Once the session key has been created with the necessary permissions, users don't need to deal with the "sign transaction" step again.

Link to repo

We're hoping that these templates inspire devs to create the next generation of great web3 games. Start building your web3 game today!

We have updated our dashboard to provide our customers with a better user experience. Our focus was on simplifying user behavior, and better user experience.

Our top-level product offering now consists of Connect, Contracts, and Engine.

Payments can now be found under the Connect tab, and Storage is located under Settings. So, you can easily monitor both your usage and storage under the same tab.

Our sponsorship rules feature lets you set controls over which transactions your paymaster should sponsor, letting you prevent bad actors from running up your paymaster usage. We recently shipped two new rules - account lists and admin accounts.

Account lists has 2 modes - blocklist and allowlist. Blocklist lets you stop malicious actors from being able to access sponsored transactions. Allowlist does the opposite - it lets you specify a list of account addresses where only transactions sent by one of those accounts will be sponsored.

We also now let you add admin accounts, which are exempt from sponsorship rules. This is useful for accounts that you control, especially if you are running tests and don't want to hit these limits.

This set of rules, particularly the ability to write custom rules using server verifier, should be enough for most usecases but we are planning on shipping more rules over the next few weeks. If you have any requests for rules that you would like to see, please let us know by posting your thoughts in the thirdweb Discord!

Allowed contract addresses, which let you restrict User Ops to a specific set of allowlisted contracts, is now available under the Sponsorship rules section of the Account Abstraction dashboard under the "Restrict to specific contract addresses" rule

No action is required. If you want to make future changes you can do so from the Account Abstraction dashboard instead of the API keys page

At thirdweb, our mission is to give web3 devs the tools they need to build great web3 apps. In Q3 of 2023, we launched our Account Abstraction toolkit. This gave devs all the pieces (Connect, Account factories, Bundler, Paymaster, and RPC) needed to easily integrate account abstraction into their apps. A key part of the toolkit is paymaster, which lets app devs sponsor gas fees for onchain actions that users take. This lets you easily build completely gasless web3 apps and is a massive UX improvement over traditional web3 apps, where users have to constantly approve and pay for transactions

However while you could now make your entire app gasless, you couldn't easily set rules around only sponsoring certain transactions.

With sponsorship rules, devs can now easily define rules around which transactions (User Ops) the paymaster should sponsor. This can be used to prevent abuse, progressively onboard users, and incentivize specific in-app actions.

We currently have 4 sponsorship rules available out of the box and will be adding more soon.

• Global spend limits: Maximum gas cost (in USD) that you want to sponsor. This applies for the duration of the billing period (monthly).
• Contract address restrictions: Allows you to specify a list of allowlisted contracts. Only transactions sent to these contracts will be sponsored.
• Chain restrictions: Use this if you want to sponsor transactions only on certain chains. If this is not set, transactions on all supported chains will be sponsored.
• Server verifier: This is a general purpose check that can be used to define custom rules. Before a transaction is sent, it checks with an endpoint that you specify on whether it should be sponsored or not.

You can easily set sponsorship rules through the configuration tab in the smart wallet dashboard. Once set, you can simply use the API key in your project and sponsorship rules will automatically be applied. Sponsorship rules are multichain by default and are not tied to an account factory.