Changelog

Firekeeper

What's Changed

  • ThirdwebManager inspector is a little more interactive now.
0:00
/0:07
  • Improved default redirect page visuals when logging in with OAuth from desktop platforms.
    • Added option to override said html with your own.
  • Option to bypass WalletConnect context checks by @BoysheO in https://github.com/thirdweb-dev/unity-sdk/pull/216
    • You now have the option to bypass WalletConnect Unity default synchronization context check as needed by setting
      AppContext.SetSwitch("IsSkipWalletConnectSyncCtxCheck", true);
  • ThirdwebClient.Create no longer takes in raw headers, now only takes in general sdk information optionally. This should not affect most users.
    • Improved http client cloning when needed in external modules.
    • Added CrossPlatformUnityHttpClient class which encompasses default .NET and WebGL ones.

Releases

.NET Release | NuGet

Unity Release

Support

Documentation | Support

Yash Kumar

We have made some improvements with respect to prebuilt contract deployments on ZkSync chains.

While it doesn't change the deployment process and experience for most users, there are some key changes as described below:

  • All thirdweb contracts can now be deployed on any ZkSync chain without any intervention from us, for existing and new ZkSync chains in the future
  • All contracts deployed that way are auto verified using standard solc metadata, which means you can view source and interact with them on the dashboard even if they're not verified on block explorers
Prithvish Baidya

We've added a new endpoint to Engine that retrieves and parses transaction logs.

What's new?

  • Get Transaction Logs Endpoint: Retrieve logs for mined transactions using a queue ID or transaction hash.
  • Automatic Log Parsing: Raw logs are parsed into structured event data by default.
  • ABI Inference: The endpoint infers the ABI for verified contracts or those with similar available sources.

Why is this important?

  • Instant Insights: Get quick information like token transfer amounts or minted NFT IDs without manual log parsing.
  • Less Boilerplate: Say goodbye to writing repetitive ABI handling and log parsing code.

How to use it

Make a GET request to the new endpoint with the following parameters:

  • chain: The chain ID or name (required)
  • queueId or transactionHash: Identifier for the mined transaction
  • parseLogs: Set to true to receive parsed event data (default: true)

For more information, you can check our API Reference.

Technical details

  • Works with verified contracts or those with inferable ABIs, can be overridden back to user provided ABI.
  • Parsing is attempted for all logs, providing structured data when possible.
  • Falls back to raw log data when parsing is not feasible.

Use cases

  • Easily retrieve information like how many ERC20 tokens were transferred in a transaction.
  • Quickly find out the tokenId of an NFT you just minted using Engine.
  • Anywhere else you've wanted to quickly access transaction logs without 100 lines of boilerplate code!

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.


thirdweb is hiring!

The small team at thirdweb is on a mission to build the most intuitive and complete web3 platform. Our products empower over 70,000 developers each month including Shopify, AWS, Coinbase, Rarible, Animoca Brands, and InfiniGods.

See our open roles. We’d love to work with you!

Phillip Ho

All cloud-hosted Engine instances (running v2.0.10 or later) can now configure alert notifications to be notified when an issue is detected on your Engine instance.

Add an alert

  1. Navigate to the new Alerts tab on the Engine dashboard.
  2. Select Create Alert.
    1. If the button is disabled, see below.
  3. Select the type of alert and how to be notified. Currently the following are supported:
    1. Alert types: Elevated 5xx rate, stuck nonce
    2. Notification types: Webhook, Slack, Email
  4. Select Add Alert.

Why is my Create Alert button is disabled?

At this time only the original admin (the account which deployed the cloud-hosted Engine) can view and manage alerts. This is usually the first admin address listed on the Admins tab. We plan to expand alert management to all admins in the near future.

View alert history

You can also view recently fired/resolved alerts on the Alerts tab.

What's next?

This feature lays the groundwork for advanced notifications for any type of error or event that Engine can emit.

For instance, in the future Engine can monitor the balance of a wallet and alert when it drops below a specified threshold. Or alert when it detects unusual transfer activity from a backend wallet.


thirdweb is hiring!

The small team at thirdweb is on a mission to build the most intuitive and complete web3 platform. Our products empower over 70,000 developers each month including Shopify, AWS, Coinbase, Rarible, Animoca Brands, and InfiniGods.

See our open roles. We’d love to work with you!

Greg

TypeScript SDK

Enclaves for Ecosystem Wallets

All Ecosystem Wallets are now stored and accessed within AWS Nitro Enclaves. This evolution of wallets provides improved security, speed, and capabilities. The migration to enclaves happens behind the scenes and without any changes necessary.

Upgrade to the latest version of the thirdweb SDK and each ecosystem wallet will be upgraded on next login. In the coming days and weeks we'll be adding additional capabilities that are unlocked by enclaves, the first of which is pregeneration.

Account Pregeneration

You can now pregenerate user accounts via the in-app wallet backend APIs. This allows for interacting with accounts before their owner has logged in. For example, you might send some funds to a user's email, and pregenerate their account if they don't have one yet.

curl -X POST 'https://embedded-wallet.thirdweb.com/api/v1/pregenerate' \
-H 'x-ecosystem-id: ecosystem.example-eco-123' \
-H 'x-secret-key: 9f8e7d6c5b4a3f2e1d0c9b8a7ffge434b2a1f0e9d8c7b6a5f4e3d2c1b0a9f8e7' \
-H 'Content-Type: application/json' \
-d '{
"strategy": "email",
"email": "user@example.com"
}'

Response format:

{
"wallet": {
"address": "string",
"createdAt": "string",
}
}

Learn more about pregenerating user accounts here.

Login with Coinbase

Coinbase is now supported as an in-app and ecosystem wallet authentication method.

import { inAppWallet } from "thirdweb/react";
const wallet = inAppWallet();
const account = await wallet.connect({
strategy: "coinbase",
chain: mainnet,
client: thirdwebClient,
});
0:00
/0:17

Ecosystem Wallet Unified Identity

With v5.45, we introduced linking multiple authentication methods to an in-app wallet to create a unified identity. Ecosystem wallets now support this same functionality across all platforms.

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

Bug Fixes and Other Improvements

React SDK

Bug Fixes and Other Improvements

  • The details modal now displays the currently logged in auth provider
  • The details modal now shows user info such as email when logged into an ecosystem wallet
  • The social icon arrangement in the Connect UI now overflows to a new line when using more than 5 auth methods
0:00
/0:09
  • Guest accounts are now hidden from the details modal linked profiles screen
Nicholas St. Germain

Get ready for an upgraded experience with our latest release! We’ve exposed key functions for smoother OAuth workflows, enhanced analytics, and provided custom UI examples to supercharge your development process. Plus, with helpful new tools and fixes, creating seamless OAuth flows and managing your game data has never been easier. Dive in and explore the possibilities!


What's Changed

Enhancements

  • Expose SecretKey->ClientID function from rust and update rust libs
  • Create and send analytics for connect, with opt-out in settings
  • OAuthBrowserUserWidget events for custom OAuth UI Scenarios
  • Custom OAuth Browser Overlay example with Circular Throbber and Back button
  • Set world override on Level_Thirdweb for GameMode to help new devs
  • Set EditiorCustomVirtualPath on plugin to help data segregation
  • Various helper functions

Modifications

  • Expose FWalletHandle to external access in C++
  • Fix White-screen OAuth Scenario in Examples

Removals

  • Hide OAuthBrowserWidget from editor

Marketplace | Documentation | Github Release

Firekeeper

What's Changed

  • Ecosystem Wallets implementation in .NET is now compatible with our previous JS implementation of Ecosystem Wallets.
    • If you had created accounts or had a user base from web sharded Ecosystem Wallets, they will automatically be migrated to the new performant enclave system upon first login.
    • No breaking API changes here, this change detects if an authenticated user requires migration and performs it.
  • ERC721 and ERC1155 NFT Contract Extensions such as _GetAll and _GetOwned now have default pagination (100 first token ids).
    • This is to avoid fetching an entire collection at once by mistake.
    • If the contract is ERC721A, tokensOfOwnerIn will be used before falling back to other extensions.
    • If the contract is ERC721Enumerable, tokensOfOwnerByIndex will be used before falling back to single fetching.
    • Improved batching of such calls.
  • Implemented ConcurrentQueue for RPC and improved batching/caching logic
    • If you do end up making large calls, such as fetching an entire collection, it should be handled gracefully
    • Avoid a lot more 429s
  • Speed up Smart Wallet user operations
    • No longer estimates the entire user operation gas and simulates prior to sending it.
    • This does not affect errors being caught.
    • This means if you are estimating gas using ThirdwebTransaction, you will only be returned the internal call gas limit rather than the entire op.
    • Less API calls at runtime, 30% faster execution.
    • If you still want to estimate the actual user operation gas costs, you can use SmartWallet.EstimateUserOperationGas
  • Fixed issue with _MintWithSignature extensions where the expected signature bytes would be passed as hex.
  • [Unity Only] Added ToQRTexture helper extension for converting any text to a Texture2D and potentially display it in a UI Image.

Links

.NET Release | NuGet

Unity Release

Documentation | Support

Arsenii

An exciting update is rolling out to improve how contract data is handled on our platform, bringing greater efficiency and scalability!

Faster contract-related SDK calls and dashboards

First and foremost, we enhanced the retrieval process for contract bytecodes, proxy implementations, and metadata by introducing an additional persistence layer. This improvement allows us to serve previously processed data much faster without querying external sources.

This leads to reduced routing and quicker response times. Meaning... 👀 better performance when calling your favourite SDK v5 functions like resolveContractAbi() and getBytecode() or when loading a contract's dashboard (e.g. USDC contract) to see ABI, sources and etc.!

Additional Improvements

  • Overall stability enhancements through better error logging and improved dependency management.
  • Performance boosts through more efficient caching and database query optimizations.
  • Codebase refactoring to meet modern standards, enhancing maintainability and scalability.

We are starting to roll out this update incrementally, continuing to prioritise data accuracy while significantly boosting speed!

Stanley Szeto

As active development is underway with the Modular Contracts framework, safety and security of the code that we officially release into production is always top of mind at thirdweb.

Which is why today we release macro-audit-8, which covers the following repositories: modular contracts, contracts and contracts pay gateway.

You can find the full release of the audit here.

As Modular Contracts have undergone a significant refactor, we are now going through a second round of auditing in order to cover for those changes, so stay tuned!

Greg

TypeScript

Guest Accounts

Sometimes users want to get started using your app without logging in. You can now give users an in-memory "guest account" that can then be converted into a standard account by linking another auth method.

import { inAppWallet } from "thirdweb/wallets";
const wallet = inAppWallet();
// Create the temporary guest account
const account = await wallet.connect({
client,
strategy: "guest",
});

When your user is ready, link any other auth method so they can access their account in the future.

import { linkProfile } from "thirdweb/wallets";
await linkProfile(wallet, { strategy: "google" });

Your user can now access this same wallet with their Google account. Until the user links another profile to the wallet, it will be stored in memory and last until they clear their browser cookies or connect a different wallet.


React

Guest Accounts in the Connect UI

Guest accounts are available in the Connect UI just like any other authentication method.

import { ConnectButton } from "thirdweb/react";
import { createWallet } from "thirdweb/wallets";
<ConnectButton
wallets={[
createWallet("inApp", {
auth: {
options: [
"google",
"discord",
"telegram",
"email",
"phone",
"guest",
],
},
}),
]}
/>;
0:00
/0:05

Bug Fixes and Other Improvements

  • Fixed custom ID handling in custom contracts
  • Expand getNFTs ERC1155 support
Stanley Szeto

More and more protocols and chains have been releasing functionality around cross-chain messaging and token transfers. With Modular Contracts being released in beta, we saw this as an opportunity to partner up and create modules around these functionalities.

However, as we explored deeper into each protocol's cross-chain mechanisms, we noticed a significant amount of overlap across all functionalities, including:

  • A function to handle sending cross-chain payloads and tokens
  • A function to handle receiving cross-chain payloads and tokens
  • Setter and getter functions for their version of a router

With that in mind, we decided to create CrossChain.sol, an abstract contract that provides a unified interface to implement cross-chain functionality across any protocol.

Breakdown of CrossChain.sol

Inside the contract CrossChain.sol, there are three main functions:

sendCrossChainTransaction

function sendCrossChainTransaction(
uint64 _destinationChain,
address _callAddress,
bytes calldata _payload,
bytes calldata _extraArgs
) external payable virtual;

As the name suggests, this is the primary function responsible for sending cross-chain transactions from the protocol.

onCrossChainTransactionSent

function onCrossChainTransactionSent(
uint64 _destinationChain,
address _callAddress,
bytes calldata _payload,
bytes calldata _extraArgs
) internal virtual;

This callback function is used within the context of the sendCrossChainTransaction function.

onCrossChainTransactionReceived

function onCrossChainTransactionReceived(
uint64 _sourceChain,
address _sourceAddress,
bytes memory _payload,
bytes memory _extraArgs
) internal virtual;

This callback function is used within the context of the receive function for the specified cross-chain protocol.

With these two callback functions, the user’s application logic can be separated from the cross-chain functionality logic, making it easier to differentiate between the two.


And there you have it—an abstract contract to create a unified interface for cross-chain functionality.

If you want to find out more, check out the code here:
https://github.com/thirdweb-dev/modular-contracts

Greg

React

Get the Current Smart Account's Admin Wallet

You can now get the admin wallet for a currently connected smart account with useAdminWallet.

import { useActiveWallet, useAdminWallet } from "thirdweb/react";
const activeWallet = useActiveWallet(); // smart wallet
const adminWallet = useAdminWallet(); // the personal wallet that controls the smart wallet

TypeScript

Marketplace Extensions

The Marketplace contract is one of our most used contract templates, and to make it even easier to build on-chain marketplace experiences we're constantly adding SDK extensions to interact with the Marketplace contract.

To better understand what your specific Marketplace supports, we've added a number of specific functions to check for supported features on a contract prior to attempting to use them.

Determine Modular Contract Module Compatibility

With the release of Modular Contracts, you now might need to check if a given module is compatible with your core contract prior to installing it. You can now do this using the checkModulesCompatiblity function.

import { checkModulesCompatibility } from "thirdweb/modules";
const isCompatible = await checkModulesCompatibility({
chain: defineChain(1),
client: THIRDWEB_CLIENT,
coreBytecode: "0x...",
moduleBytecodes: ["0x..."],
});

Publish Contracts

Published contracts are more discoverable, more easily indexed, and more usable across thirdweb's tools than unknown contracts. It allows anyone to pull the contract's ABI and metadata to interact with your contract permissionlessly. You can now programmatically publish any contract to thirdweb's contract registry with publishContract.

import { publishContract } from "thirdweb";
const transaction = publishContract({
contract,
account,
metadata,
});
await sendTransaction({
account,
transaction,
});

Bug Fixes and Other Improvements

  • Function signatures and contract ABIs are now properly handled in resolveMethod
  • Pay now allows topping up from a different wallet with the same currency
  • Our internal ABI types are now publicly exported under thirdweb/utils
  • Balances are now properly invalidated on Pay transaction success
  • PayEmbed metadata can now be customized
Manan Tank

We've completed revamped the API Key settings page with a more polished UI and following UX improvements

  • Combined "Edit" and "View" pages to a single simpler page
  • Added "Save" button next to all the form groups instead of having a single "Save" button all the way at the bottom of page
  • No more hidden fields - Bundle ID restrictions and Domain restrictions are visible directly on page load
  • Improved helper text for form fields
Toomas Oosalu

Enhancements

  • Failover Algorithm Optimization: Enhanced the failover algorithm to improve resource efficiency.
  • Error Handling Improvements: Refined error handling for JSON-RPC errors, providing more robust responses.
  • RPC Edge Error Logging: Improved logging for RPC Edge, now handling multiple metadata objects and error stacks more effectively.
  • Correlation ID for Error Responses: Added correlation IDs to error responses, uniquely tagging each RPC request for easier troubleshooting.
  • Lit Protocol Resources: Expanded available resources for the Lit protocol.
  • Database Connection Handling: Enhanced management of database connections for better performance.
  • Internal Block Staleness Monitoring: Strengthened internal monitoring to detect and address block staleness more proactively.
  • Test Coverage: Increased service test coverage to over 90%, ensuring higher reliability.

Bug Fixes

  • RPC Edge Routing Error Rate: Reduced error rates in RPC Edge routing by optimizing node discovery strategy.
  • Node-Specific Failovers: Fixed an issue where node-specific errors triggered unnecessary failovers, improving overall system stability.
Firekeeper

What's Changed

  • Adds AuthProvider.X as a login option. Linking supported.
// Unity - InAppWallet
var iawOptions = new WalletOptions(
provider: WalletProvider.InAppWallet,
chainId: 421614,
inAppWalletOptions: new InAppWalletOptions(authprovider: AuthProvider.X)
);
var iaw = await ThirdwebManager.Instance.ConnectWallet(iawOptions) as InAppWallet;
// Unity - EcosystemWallet
var ecoOptions = new WalletOptions(
provider: WalletProvider.EcosystemWallet,
chainId: 421614,
ecosystemWalletOptions: new EcosystemWalletOptions(
ecosystemId: "ecosystem.the-bonfire",
authprovider: AuthProvider.X
)
);
var eco = await ThirdwebManager.Instance.ConnectWallet(ecoOptions) as EcosystemWallet;
// .NET - InAppWallet (Windows Console Example)
var inAppWalletOAuth = await InAppWallet.Create(
client: client,
authProvider: AuthProvider.X
);
if (!await inAppWalletOAuth.IsConnected())
{
_ = await inAppWalletOAuth.LoginWithOauth(
isMobile: false,
(url) =>
{
var psi = new ProcessStartInfo { FileName = url, UseShellExecute = true };
_ = Process.Start(psi);
},
);
}
var inAppWalletOAuthAddress = await inAppWalletOAuth.GetAddress();
Console.WriteLine($"InAppWallet OAuth address: {inAppWalletOAuthAddress}");
// .NET - EcosystemWallet (Windows Console Example)
var ecosystemWalletOAuth = await EcosystemWallet.Create(
ecosystemId: "ecosystem.the-bonfire",
client: client,
authProvider: AuthProvider.X
);
if (!await ecosystemWalletOAuth.IsConnected())
{
_ = await ecosystemWalletOAuth.LoginWithOauth(
isMobile: false,
(url) =>
{
var psi = new ProcessStartInfo { FileName = url, UseShellExecute = true };
_ = Process.Start(psi);
}
);
}
var ecosystemWalletOAuthAddress = await ecosystemWalletOAuth.GetAddress();
Console.WriteLine($"EcosystemWallet OAuth address: {ecosystemWalletOAuthAddress}");
  • Fixes edge case when sending two SmartWallet transactions at once from an undeployed account and using EntryPoint 0.7.0 where deployment code would be duplicated causing an error.

Links

.NET Nuget Release | Unity Release

.NET Docs | Unity Docs

Nicholas St. Germain

Unreal Engine SDK 1.2.0 is here, bringing game development to the next level with expanded platform support! Now with Android, iOS, and VisionOS integration, plus streamlined workflows and enhanced core functionality, it's never been easier to bring your games to life across multiple devices.


What's Changed

Enhancements

  • Added Android Support
  • Added IOS Support
  • Added IOS Simulator Support
  • Added VisionOS Support
  • Added LinuxArm64 Support
  • Automatically parse full path of savedir for storage directory imports
  • Exposed GetPrivateKey from rust in C++ and added the associated blueprint wrapper

Modifications

  • Updated rust core libs to sync with upstream
  • Renamed thirdweb.lib to libthirdweb.lib to uniformly align file naming
  • Migrated remaining subsystem functions to their appropriate destinations
  • Cleaned up remaining StringCast references
  • Updated readme with new platform support coverage
  • Update content examples to reference migrated functions

Removals

  • ThirdwebSubsystem

Marketplace | Documentation | Github Release

Greg

You can now login to an in-app wallet using X/Twitter.

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

This also works for linking accounts to an existing wallet.

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

Parse NFT URIs

We've added a parseNFTUri utility function to parse NFT image URIs of all formats to an IPFS hash. We've also added a parseAvatarRecord function to specifically parse ENS avatars to a usable HTTPS URL.

import { parseAvatarRecord } from "thirdweb/extensions/ens";
import { parseNftUri } from "thirdweb/extensions/common";
const avatarUrl = await parseAvatarRecord({
client,
uri: "...",
});
const nftUri = await parseNftUri({
client,
uri: "...",
});

Hide Specific Wallets in the Wallet Switcher

You can now hide specific wallet types in the React wallet switcher UI. This can be helpful if you'd like to use smart wallets without exposing the wallet address to the user, or in the opposite case to hide the underlying admin wallet from the user.

<ConnectButton
client={client}
detailsModal={{
// We hide the smart wallet from the user
hiddenWallets: ["smart"],
}}
accountAbstraction={{
chain: baseSepolia,
sponsorGas: true,
}}
/>;

Bug Fixes and Other Improvements

  • Specify your preferred provider on the buyWithFiat function using preferredProvider
Greg

LINE Authentication

LINE is now supported as an authentication method across the SDK.

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

This includes linking an account to form a unified identity.

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

Fetch Users on the Server with getUser

You can now retrieve users by email, phone number, wallet address, or user ID from the server in a single line of code.

import { getUser } from "thirdweb/wallets";
const user = await getUser({
client,
email: "vitalik@ethereum.org",
});
⚠️
This function will only work with a secret key and should not be used on the client under any circumstances.

Salts for Deterministic Contract Deploys

You can now use a salt to deterministically deploy published contracts.

const address = await deployPublishedContract({
client,
chain,
account,
contractId: "Airdrop",
contractParams: {
defaultAdmin: "0x...",
contractURI: "ipfs://...",
},
salt: "test", // <--- deterministic deploy
});

This also works with unpublished contracts deployed via deployContract.

const address = await deployContract({
client,
chain,
account,
bytecode: "0x...",
abi: contractAbi,
constructorParams: {
param1: "value1",
param2: 123,
},
salt: "test", // <--- deterministic deploy
});

deployPublishedContract Constructor Parameters Format

Constructor parameters passed to deployPublishedContract are now passed as an object rather than an array.

const address = await deployPublishedContract({
account,
chain,
client,
contractId: "Airdrop",
contractParams: {
defaultAdmin: TEST_ACCOUNT_A.address,
contractURI: "",
},
});

Bug Fixes and Other Improvements

  • Added support for React Native 0.75
  • Fixed ERC721 delayed reveal detection
  • Multiple smart wallet transactions can now be sent in parallel
  • Added the toFunctionSelector utility
  • Social profiles now display in the linked accounts list
  • Polygon MATIC is now POL
Samina Kabir

Over the years, we've seen smart contracts struggle to keep up with developers' evolving needs. Innovation opens new possibilities for asset distribution and compliance, yet deployed contracts remain rigid.

To solve this, we've built Modular Smart Contracts—a framework that allows for highly customizable contracts. Think of these as building blocks: start with a base and add different pieces to create a contract fit to your needs.

Modular Contracts is officially launched with limited deployments, available on testnets only from September 12 - September 26. Post this period, mainnet deployments will be available.

What can you use right now?

  • Popular Pre-built Contracts - We've redesigned our top seven contracts using the modular contract framework. These are now available for deployment through the dashboard. Visit Explore to view the available contracts.
  • Deploy custom modules - Write and add custom created modules to any ERC20, ERC721, or ERC1155 core contract.
  • Connect SDK Support - Once your contract is deployed, use the Connect SDK to build an application. View SDK Integration documentation.

Improvements since alpha

  • Creator Token Standard - We worked with Limit Break to create a module that enforces on-chain programmable royalties through transfer security policies. This module is now a default in all thirdweb pre-built contracts utilizing royalties.
  • Changes to Claim Conditions - Based on user feedback, we added a start and end timestamp and simplified the module to only allowlist or public phases.
  • Simplified modules - Improved composability patterns and simplified modules across the board. View the full changelog.

What’s coming up in the next few weeks?

  • Modules UI - Be able to interact with thirdweb enabled modules (upload NFTs, set claim conditions, and more) through the dashboard rather than through the SDK or Explorer.
  • Modular Contract Wizard v1- A UI building tool to create contracts combining compatible core and modules.
  • Cores & Modules listed on Explore - Discover more modules from other protocols and be able to list modules and core contracts on Explore for your audiences.

Beta Feedback Program

We're excited to invite you to try Modular Smart Contracts and provide our team with direct feedback during a 20-minute call. As a thank you, you'll receive $50 in credit to utilize towards any usage, growth plan, or upgraded instances of Engine. To participate, please sign up to be a tester. We'll then send you more information via email.

Resources

Feedback

As always, for any support or feedback please visit our support site and feedback board. Thank you to our community for making this possible- stay shippin’ 🚀

Manan Tank

Connect Analytics Charts

Connect Analytics is now available for everyone - including free plan with improved Charts. Try it out!

Deployed Contracts table and Import Contract Modal

In-App wallet pages

Sidebar UI

The sidebar is moved inside the page container - closer to the content so its easier to navigate on wide screens

Scroll indicators on various tables

Firekeeper

This is no exaggeration, our Ecosystem Wallets are now so feature rich there is no use case in all of gaming that it does not support.

Thirdweb now provides you with a cross-platform, cross-sdk, cross-device, cross-language blockchain-powered, secure, non-custodial account system that you can not only reuse across your own games and apps, but also your ecosystem partners' games and apps.

It doesn't stop there, you can use this EcosystemWallet to create a Guest mode (AuthProvider.Guest) first and upgrade later through Account Linking, which we feature here alongside other additions like Line authentication. All of this without losing the EcosystemWallet address.

The Account Linking feature, once understood, unlocks infinite possibilities as it ties into all our auth methods, which now include:

  • Email (OTP)
  • Phone (OTP)
  • Google
  • Apple
  • Facebook
  • Discord
  • Farcaster
  • Telegram
  • Line
  • Siwe (Sign in with Ethereum - yep you can link external wallets and even login to your EcosystemWallet with them next time)
  • Guest (does not require any inputs, simply choose it as your auth provider to create a guest mode)

It doesn't stop there, we also offer custom authentication:

  • JWT (you want to create a wallet out of an OIDC-compatible authentication system, entirely possible)
  • AuthEndpoint (you want to go even further, having us verify a generic payload against your backend, for things like TG Mini-Apps)

There is not a single use case we don't support. You just have to integrate, and we're here to help.

If you don't want to commit to a performant, scalable, entirely secure and shareable with third-parties and fast EcosystemWallet, don't worry, all of the above is available for InAppWallet too.

Now for how-to's

Do note that once again, it's the same API for InAppWallet, but without ecosystemId and the optional ecosystemPartnerId.

Below are the different ways you can use some of the functionality introduced in this version.

You can turn any of these wallets into a Smart Wallet easily, using SmartWallet.Create or by passing SmartWalletOptions to Unity's ThirdwebManager.ConnectWallet function on top of your base options / using the ThirdwebManager.UpgradeToSmartWallet helper if you want to do it later.

Login With Guest (.NET SDK)

var guestWallet = await EcosystemWallet.Create(ecosystemId: "ecosystem.the-bonfire", client: client, authProvider: AuthProvider.Guest);
if (!await guestWallet.IsConnected())
{
_ = await guestWallet.LoginWithGuest();
}
var address = await guestWallet.GetAddress();

Login With Guest (Unity)

var walletOptions = new WalletOptions(
provider: WalletProvider.EcosystemWallet,
chainId: 421614,
ecosystemWalletOptions: new EcosystemWalletOptions(ecosystemId: "ecosystem.the-bonfire", authprovider: AuthProvider.Guest)
);
var ecosystemWallet = await ConnectWallet(walletOptions) as EcosystemWallet;

Get Linked Accounts

var linkedAccounts = await ecosystemOrInAppWallet.GetLinkedAccounts();

Link a new Account

All Auth Methods Supported! Just pass the related params to that auth method that you typically would

// Assuming you already have a connected wallet you want to link a new profile to
var walletToLink = await InAppWallet.Create(client: client, authProvider: AuthProvider.Google);
var linkedAccounts = await mainConnectedWallet.LinkAccount(walletToLink );

A Full Unity Example, ThirdwebManager is there as a helper after all and APIs are simpler

// Sign up with guest mode to avoid the friction of auth with new users
var walletOptions = new WalletOptions(
provider: WalletProvider.EcosystemWallet,
chainId: 421614,
ecosystemWalletOptions: new EcosystemWalletOptions(ecosystemId: "ecosystem.the-bonfire", authprovider: AuthProvider.Guest)
);
var ecosystemWallet = await ConnectWallet(walletOptions) as EcosystemWallet; // or EcosystemWallet.Create
// This address will not change after linking i.e. in this case "upgrading" your account
var address = await ecosystemWallet.GetAddress();
Debug.Log($"Connected EcosystemWallet: {address}");
// This is how you display currently linked accounts
var linkedAccounts = await ecosystemWallet.GetLinkedAccounts();
Debug.Log($"Linked accounts: {Newtonsoft.Json.JsonConvert.SerializeObject(linkedAccounts)}");
// Create a raw EcosystemWallet to link, in this example user would have chosen to link Line
var ecosystemWalletToLink = await EcosystemWallet.Create(
client: ThirdwebManager.Instance.Client,
ecosystemId: "ecosystem.the-bonfire",
authProvider: AuthProvider.Line
);
// Use the Unity SDK helper to link the accounts
var newLinkedAccounts = await ThirdwebManager.Instance.LinkAccount(ecosystemWallet, ecosystemWalletToLink);
Debug.Log($"New linked accounts: {Newtonsoft.Json.JsonConvert.SerializeObject(newLinkedAccounts)}");

Additional changes

  • Improved speed of NFT-related extensions.
  • Fixed an issue with SIWE as an AuthProvider when using ThirdwebManager to connect.
  • Added contract extensions ERC721A_TokensOfOwner & ERC721A_TokensOfOwnerIn.
  • Added optional pagination to all _GetAllNFTs & _GetOwnedNFTs extensions.
  • Improved ERC721A NFT-fetching speed.

Links

Unity v5 Portal Docs | .NET Portal Docs | .NET Full Reference

.NET Nuget Release | Unity Release

Note from Firekeeper

Our goal at thirdweb has always been to work for game developers - with such systems, you're able to offload all the account system, auth, database, item management, currency management, and analytics work to the blockchain. This is what we do, and we want to help you and listen to feed back - make sure you reach out, we have many programs to get you going!

We have the recipe to make blockchain games unbeatable, cheap, fast, invisible. Persistent In-App & Ecosystem Wallets paired with Account Abstraction, Session Keys and some easy to deploy contracts is what we do. It's all open-source, it's all yours to manage.

It's time to ditch external wallets.

Blockchain games can finally focus on being fun and on distribution across different runtime platforms and companion apps.

Jonas Daniels

We integrated the newly available Social SDK in the thirdweb Dashboard, making it available anywhere wallet addresses are rendered. Simply hover any wallet address or ENS name to see linked social profiles.

Improved wallet address rendering including the social profiles hover card in the dashboard
Greg

React Native now supports Coinbase Smart Wallet with v5.53.0 of the thirdweb SDK. Create a Coinbase Smart Wallet connection using the same createWallet function you know and love:

import { createWallet } from "thirdweb";
const wallet = createWallet("com.coinbase.wallet", {
appMetadata: {
name: "My app name",
},
mobileConfig: {
callbackURL: "https://example.com",
},
walletConfig: {
options: "smartWalletOnly",
},
});
await wallet.connect({
client,
});
0:00
/0:17

Create and Sign a UserOp in One Step

We've added a createAndSignUserOp function to handle everything involved with turning a set of transactions into a single AA UserOp. Gasless and/or sponsored transactions couldn't be easier:

import { createAndSignUserOp } from "thirdweb/wallets/smart";
const userOp = await createAndSignUserOp({
client,
adminAccount,
smartWalletOptions,
transactions,
});

Bug Fixes and Other Improvements

  • Improved common icons in React Native SDK
  • Increased storage slots for proxy resolution

Fixed ERC20 balance reading when showing the Pay modal

Edward Sun

We made a number of improvements on testing on thirdweb Pay.

  1. Added a testMode property to the buyWithCrypto PayUIOptions. This will allow you to filter for all supported testnets and try out a crypto-to-crypto purchase experience without using mainnet funds.
  2. Enabled Pay with Fiat on testnet purchases. No funds are delivered in this flow, but the credit card testnet experience will allow you to simulate an end-to-end user journey without requiring an actual credit card purchase.
Arsenii

A few more updates on how the team makes our RPC Edge solution more resilient and flexible!

Initial Node Prioritisation with Default Scoring

While dynamic routing and scoring optimise node selection over time, it's crucial that the system starts off in a reasonable state when the server spins up. To address this, we've now implemented a robust approach for default node prioritisation. The priorities are now designed to be easily adjustable, enabling the team to efficiently re-order or disable certain nodes in case of emergencies or other ad-hoc situations. This step ensures more flexibility and efficiency in managing the initial order of nodes, creating a smoother path for ongoing improvements.

Changes made recently in this regard:

  • Node Default Prioritisation: we are now configuring RPC Edge to utilise explicitly set default priorities, supporting granular configurations options (e.g. methods and regions) to ensure that specific node preferences can be applied where needed for the enhanced performance.
  • Configuration Schema and Structure: the new schema accommodates the team in efficient management of relevant configuration options, ensuring a clean and scalable system.
  • Prioritisation Logic Improvements: sorting and filtering algorithms have been improved and generalised to handle various configurations
  • Caching for Performance: in-memory caching for configurations is in place, reducing the load & latency on the system when serving requests for high-load chains.

These changes are being released incrementally as we continue to prioritise the stability and quality of our RPC Edge solution.

Greg

You can now query any address's on-chain social profiles using the new social extension in the thirdweb SDK.

import { getSocialProfiles } from "thirdweb/social";
const profiles = await getSocialProfiles({
address: "0x...",
client,
});

The query will return an array of SocialProfile objects for each profile the address is associated with. This type has a standardized top-level interface of type (farcaster, lens, and ens are currently supported), name, bio, and avatar. You can access protocol-specific user information such as the Farcaster FID under the metadata field.

[
{
"type": "ens",
"name": "joenrv.eth",
"avatar": "ipfs://bafybeic2wvtpv5hpdyeuy6o77yd5fp2ndfygppd6drdxvtfd2jouijn72m",
"metadata": {
"name": "joenrv.eth"
}
},
{
"type": "farcaster",
"name": "joaquim",
"bio": "Eng Lead @ thirdweb",
"avatar": "https://lh3.googleusercontent.com/EUELPFJzdDNcc3qSaEMekh0_W16acnS8MSvWizt-7HPaQhfJsNFC5HA0W4NKcy6CN9zmV7d4Crqg2B8qM9BpiveqVTl2GPBQ16Ax2IQ",
"metadata": {
"fid": 2735,
"bio": "Eng Lead @ thirdweb",
"pfp": "https://lh3.googleusercontent.com/EUELPFJzdDNcc3qSaEMekh0_W16acnS8MSvWizt-7HPaQhfJsNFC5HA0W4NKcy6CN9zmV7d4Crqg2B8qM9BpiveqVTl2GPBQ16Ax2IQ",
"username": "joaquim",
"addresses": [
"0x2247d5d238d0f9d37184d8332ae0289d1ad9991b",
"0xf7970369310b541b8a84086c8c1c81d3beb85e0e"
]
}
},
{
"type": "lens",
"name": "joaquim",
"bio": "Lead engineer @thirdweb",
"avatar": "https://ik.imagekit.io/lens/media-snapshot/557708cc7581172234133c10d473058ace362c5f547fa86cee5be2abe1478e5b.png",
"metadata": {
"name": "joaquim",
"bio": "Lead engineer @thirdweb",
"picture": "https://ik.imagekit.io/lens/media-snapshot/557708cc7581172234133c10d473058ace362c5f547fa86cee5be2abe1478e5b.png"
}
}
]

You can access the same query via the prebuilt React Query hook useSocialProfiles.

import { useSocialProfiles } from "thirdweb/react";
const { data: profiles } = useSocialProfiles({
client,
address: "0x...",
});
⚠️
The SDK's new social features are still in beta, and may have breaking changes in the coming weeks.

The Connect Button

Our ConnectButton component in both React and React Native uses the social SDK to display a users profile rather than their wallet address when available.

Bug Fixes and Other Improvements

  • Modular Contract Support - Learn more
  • Added test mode to Pay options on ConnectButton - Learn more
  • Added getOwnedTokenIds to ERC1155 extension - Learn more
  • Added options to hide Buy, Send, and Receive buttons in useWalletDetailsModal - Learn more
  • Fixed base URI extraction logic in contract extensions
  • Fixed function ID retrieval for contract extensions
  • Improved React Query caching performance
Toomas Oosalu

We are continuously improving our RPC Edge and the latest update is out!

Dynamic Method Based Scoring and Routing for RPC Edge

We implemented a modular scoring strategy to choose the most performant node for the requests. Edge RPC uses method-based scoring and picks the dominant method within a batch. It also supports scoring and retrying JSON RPC server errors and fails over to other nodes if there is a problem.

Edge RPC will know itself how to choose the best upstream node with 99.9% probability. This change will improve error rate, latency and data accuracy and will only improve over time.

First tests are already showing improved latency by 20%!


Error Handling and Logging Updates

We improved Edge RPC's error handling to better follow the JSON RPC spec. RPC errors are now included in the response body and the Edge RPC always returns HTTP 200 status.

Improved internal metrics and logging around Edge RPC failovers and incomplete responses.

Deprecations
Removed support for deprecated Mumbai RPC.

We will start to roll out the Edge RPC scoring method update incrementally and continue to prioritize data correctness and speed.

Joaquim Verges

We just released v5.52.0 of the thirdweb TypeScript SDK which unlocks the ability to deploy, configure and interact with our new Modular Contracts.

Deploying a Modular Contract

You can now easily build your personalized contract by picking the modules suited for your use case.

Here's how to deploy a ERC721 contract with the Claimable and BatchMetadata module, which together create a Drop functionality.

import {
ClaimableERC721,
BatchMetadataERC721,
deployModularContract,
} from "thirdweb/modules";
const deployed = deployModularContract({
client,
chain,
account,
core: "ERC721",
params: {
name: "My Modular NFT Contract",
},
modules: [
ClaimableERC721.module({
primarySaleRecipient: ...,
}),
BatchMetadataERC721.module(),
],
});

Upgrading a Modular Contract

These modules can be swapped at any time, and new ones can also be added post deployment. Here's how to install a new module programmatically:

import {
RoyaltyERC721,
} from "thirdweb/modules";
const transaction = RoyaltyERC721.install({
contract: coreContract,
account,
params: {
royaltyRecipient: account.address,
royaltyBps: 100n,
transferValidator: ZERO_ADDRESS,
},
});
})

Interacting with a Modular Contract

We have core contracts for ERC20, ERC721 and ERC1155 standards. Those follow the standard ERCs and can be interacted with like usual with the standard extensions.

The interesting part is to interact with an attached module. This is done by using the defined module name spaced API:

import { ClaimableERC721 } from "thirdweb/modules";
const transaction = ClaimableERC721.mint({
contract,
to: "0x...", // Address to mint tokens to
quantity: 2, // Amount of tokens to mint
});
// Send the transaction
await sendTransaction({ transaction, account });

This makes it easy to discover the available API for each module.

You will also soon be able to generate the namespaced TypeScript API for your own modules via the thirdweb CLI.

To learn more about modular contracts and how to create modules, head over to the documentation.

Phillip Ho

All new Engine deployments from the thirdweb dashboard will be on v2.

For existing cloud-hosted Engines, please request a version upgrade in the dashboard. (We're making upgrades self-service very soon!)

What's new?

The worker architecture in Engine v2 was redesigned with maximum onchain throughput in mind. Users should see:

  • Higher onchain throughput: Batches of transactions for a single backend wallet are now fully parallelized. The entire batch will often be sent in the next block, resulting in up to 700x more transactions sent per second, depending on the chain.
  • Lower time to send: Slow polling and DB locks are removed. Transactions are processed from the queue as soon as they arrive, resulting in a median of 300ms from Engine receiving a transaction to sending it.

Benchmarks

Engine v2 is capable of sending hundreds of transactions per second to a chain's RPC. However the total transactions from a single wallet that a block will accept depends on the chain. Here are some numbers we've seen on a single 1 vCPU / 1 GB memory host:

  • B3 testnet: 1500 txs per block
  • Base testnet: 65 txs per block
  • Polygon testnet: 85 txs per block
  • Arbitrum testnet: 100 txs per block

Note: transactions mined per second ~= # transactions per a block / block time

Any breaking changes?

Publicly documented interfaces have no breaking changes. There is no expected changes required from users.

How we got here

Engine development started 1.5 years ago to power onchain transactions internal to thirdweb. After chatting with other teams, we recognized most teams were spending engineering weeks solving similar problems. Engine was open-sourced in Q2 2023 and we've been iterating on it since.

Engine v1 was designed to send batches of transactions without waiting for previous ones to be mined. This already introduced a lot of challenges around nonce management (see Sending more than one transaction at a time is easy, right?). We've since uncovered dozens of edge cases from internal testing and customer reports across a multitude of chains, contract types, and use cases.

As Engine expanded in scope, so did web3 use cases. We started seeing apps and games use Engine in ways that demanded higher throughput and lower latency. We looked at bottlenecks: DB locks, short polling, batching logic, coupling of dependencies. Leveraging learnings in the past year, we started on v2 to address these bottlenecks.

Engine v2 moves performance-critical and atomic operations from Postgres to Redis queues. This change allows for faster reads and writes to DB leading to less blocking behavior, lower latency, and fewer scaling issues. The code is better organized, typesafe, and built on the thirdweb v5 SDK (which comes with added performance gains).

In v2 transactions no longer block on RPC responses, saving 50-200ms per transaction (very noticeable at scale!). While this change introduced even more nonce edge cases to handle, the performance tradeoff is worth it. Engine v2 employs multiple patterns and workers to track and self-heal nonces.

What's next

We feel confident Engine v2 handles the throughput needs of the vast majority of web3 use cases today.

The next challenge is to improve observability and debuggability around queues and transactions. We plan to expose API metrics, queue latency metrics, realtime nonce details, transaction logs, and more. Our roadmap also includes options to replay failed transactions, reset nonces, and more.

Keep your eyes peeled on the Engine dashboard for updates as we roll them out!


thirdweb is hiring!

The small team at thirdweb is on a mission to build the most intuitive and complete web3 platform. Our products empower over 70,000 developers each month including Shopify, AWS, Coinbase, Rarible, Animoca Brands, and InfiniGods.

See our open roles. We’d love to work with you!

Firekeeper

Unity SDK upgrades can be daunting - this is one of the things v5 solves by moving the core to our .NET SDK - making feature upgrades seamless requiring only a couple file changes at most.

However, for existing v4 users, it can be challenging to integrate a major update, even though it is an objectively better SDK and brings a myriad of improvements and flexibility to the game dev journey.

A migration guide has been added to the portal here.

We've also migrated our Take Flight template and recorded it in realtime to serve as reference.

Take-Flight-Migration.mp4
Stanley Szeto

We have recently refactored our Modular Contracts to introduce new changes that we believe will benefit both the developer and ecosystem experience as a whole.

With that, we have made changes to our Minting, Royalty, Metadata, and a new Sequential Token ID module along with our Core contracts.

Minting

beforeMintWithSignature

In the Claimable and Mintable modules, the beforeMint function has now been split into two functions: beforeMint and beforeMintWithSignature.

All signature-based mints will now be done through the beforeMintWithSignature function, and all regular mints will now be done through the beforeMint function.

With the splitting of functionality, a division in the parameters passed into both functions has also been introduced.

For regular minting, the following parameters are now introduced:

/**
* @notice The parameters sent to the `beforeMintERC20` callback function.
*/
struct ClaimParamsERC721 {
address currency;
uint256 pricePerUnit;
bytes32[] recipientAllowlistProof;
}
// No params needed for the mintable module

For signature mints, the following parameters are now introduced:

/**
* @notice The request struct signed by an authorized party to mint tokens.
*
* @param startTimestamp The timestamp at which the minting request is valid.
* @param endTimestamp The timestamp at which the minting request expires.
* @param currency The address of the currency used to pay for the minted tokens.
* @param pricePerUnit The price per unit of the minted tokens.
* @param uid A unique identifier for the minting request.
*/
struct ClaimSignatureParamsERC721 {
uint48 startTimestamp;
uint48 endTimestamp;
address currency;
uint256 maxMintPerWallet;
uint256 pricePerUnit;
bytes32 uid;
}
/**
* @notice The request struct signed by an authorized party to mint tokens.
*
* @param startTimestamp The timestamp at which the minting request is valid.
* @param endTimestamp The timestamp at which the minting request expires.
* @param currency The address of the currency used to pay for the minted tokens.
* @param pricePerUnit The price per unit of the minted tokens.
* @param uid A unique identifier for the minting request.
*/
struct MintSignatureParamsERC721 {
uint48 startTimestamp;
uint48 endTimestamp;
address currency;
uint256 pricePerUnit;
bytes32 uid;
}

Reference to code:
ClaimableERC721.sol#L196

maxMintPerWallet

In the Claimable module, maxMintPerWallet has now been introduced in both the claimCondition and claimSignatureParams, along with a totalMinted mapping that tracks the number of mints a wallet has done so far.

This change introduces a new validity rule that allows users to set the maximum number of mints a single wallet can make.

Reference to code:
ClaimableERC721.sol#L75

Mintable module no longer supports URI Metadata

Modular contracts should be composable, and for that to be the case, the functionality of modules should be independent of each other.

We believed that the Mintable module did not achieve this, as it was capable of both validating the mint and setting the URI Metadata.

Due to this, we have removed the functionality to set the URI Metadata from the Mintable module and placed its responsibility solely on Metadata modules.

Royalty

Creator Token Standard has now been implemented

The Creator Token Standard by Limit Break has now been implemented into the Royalty modules. This introduces a beforeTransfer hook into each of the royalty modules along with a transferValidator that validates whether a transfer should be done or not, based on the policies set for the collection.

You can learn more about the Creator Token Standard here.

Reference to code:
RoyaltiesERC721.sol

Metadata

updateMetadata hook

updateMetadata is a new hook that has been introduced, allowing users to set the URI of a token as they mint it.

The purpose of introducing the updateMetadata hook was to allow the URI Metadata of a token to be set during minting, but to place this functionality in the Metadata modules rather than the Mintable module.

Reference to code:
BatchMetadataERC721.sol#L114

BatchMetadata now implements setBaseURI, getBatchId, getBatchRange

These three new functions have been introduced to allow the BatchMetadata module to have delayed reveal functionality through the setBaseURI function.

getBatchId and getBatchRange have also been introduced as helper functions to improve the overall user experience when using the setBaseURI function.

SimpleMetadata and DelayedRevealBatchMetadata are now deprecated

SimpleMetadata and DelayedRevealBatchMetadata have both been deprecated in favor of BatchMetadata.

This change was introduced because:

  1. BatchMetadata is more gas-efficient than SimpleMetadata while achieving the same functionality.
  2. BatchMetadata can now replicate delayed reveal functionality through setBaseURI.

Sequential TokenId

A new module called the SequentialTokenIdERC1155 module has been introduced, which optionally allows for sequential minting in ERC-1155-based collections.

Along with this module, the updateTokenId hook for ERC-1155 core contracts has also been implemented.

Reference to code:
SequentialTokenIdERC1155.sol

Core Contracts

updateTokenId, updateMetadata hooks

To support the newly introduced hook functions, the ERC-721 Core contract now implements the updateMetadata hook, and the ERC-1155 Core contract now implements both the updateTokenId and updateMetadata hooks.

Both of these functions are placed in the mint and mintWithSignature functions.

As previously mentioned:

  • updateTokenId is now responsible for optionally updating the token ID.
  • updateMetadata is now responsible for optionally updating the URI of a token.

Reference to code:
ERC1155Base.sol#L212

baseURI parameter in mint

To properly support the updateMetadata hook, the mint function now accepts the new parameter baseURI, which is passed into the updateMetadata hook.

Reference to code:
ERC1155Base.sol#L205

mintWithSignature function

To support the beforeMintWithSignature function in both the Claimable and Mintable modules, the mintWithSignature function has been introduced, which retrieves the signer of the signature and calls the beforeMintWithSignature function.

Reference to code:
ERC1155Base.sol#L230

Base contracts

Not to be confused with the Base chain, Base contracts serve as the core functionality of both Core and CoreInitializable contracts.

Now, both Core and CoreInitializable contracts inherit from the Base contract. This was done to reduce code duplication and improve maintainability.

Reference to code:
ERC1155Base.sol

To find all the changes made in this refactor, head on over to the GitHub repository.

To start using the contracts today, you can find them on the Explore page of the ThirdWeb Dashboard

Greg

We've added the ability to retrieve claim conditions across the ERC20, ERC721, and ERC1155 extensions.

import { getClaimConditions } from "thirdweb/extensions/erc20";
import { getClaimConditions } from "thirdweb/extensions/erc721";
import { getClaimConditions } from "thirdweb/extensions/erc1155";
import { getContract } from "thirdweb";
const erc20Contract = getContract({
chain: defineChain(1),
client: THIRDWEB_CLIENT,
address: "0x...",
});
const erc20Conditions = await getClaimConditions({
contract: erc20Contract,
});
const erc721Contract = getContract({
chain: defineChain(1),
client: THIRDWEB_CLIENT,
address: "0x...",
});
const erc721Conditions = await getClaimConditions({
contract: erc721Contract,
});
const erc1155Contract = getContract({
chain: defineChain(1),
client: THIRDWEB_CLIENT,
address: "0x...",
});
const conditions = await getClaimConditions({
contract: erc1155Contract,
});

Bug Fixes and Other Improvements

  • Added resolveImplementation support for MATIC proxy
  • Removed unusable single phase claim condition extension
Firekeeper

With the release of our .NET SDK v2, the next generation of our Unity SDK is finally out of beta - no more platform specific updates!

This version comes with long-awaited features and various speed, stability and performance improvements.

Ecosystem Wallets

An ecosystem wallet is your own managed in-app wallet service that allows you to create a branded wallet and login system, and allow any number of partners to spin up in-app wallets. End users that create in-app wallets in your partner applications (either with email, phone number, socials or your own custom authentication) will receive one account and wallet address that they can access across all apps and games in your ecosystem.

Ecosystem Wallets use an enclave backend to handle private keys and signing, remaining non-custodial and secure, while also offloading the otherwise sharded wallet client side cryptographic work to a single http request - the ultimate cross-platform friendly account system.

You may upgrade these Ecosystem Wallets to Smart Wallets as you would any other wallet. The API is extremely similar to our In-App Wallets', and in some places simplified as well due to the streamlined infrastructure that powers it.

We've also reworked our login flows to increase speed and performance across the board, it's time to move on from external wallets (or just link them to our embedded wallets from now on through our Unified Identity system!)

Automatic Smart Wallet Network Switching

Given how our new SDK is structured, where no chain id is necessarily stored in the sdk or wallet's state, you may interact with any chain at will easily, setting up contracts or low level transactions across multiple chains and using a single wallet to execute them all.

Such functionality is now available seamlessly through our Smart Wallet offering. Simply create a smart wallet on any initial chain, and interact with any contract or send any transaction using another chain id - the smart wallet will automatically switch to that chain!

Do note that if you are overriding the default account factory in your connection parameters, that account factory must be deterministically deployed across the chains you are interacting with.

Unlocking low level transaction flows and zkSync specific flows

The ThirdwebTransaction.Create inputs have been simplified, removing redundant chain id parameters.
We've also made it simpler to create low level transactions by adding ThirdwebTransactionInput constructors that take in simpler types, and made zkSync transactions go through the EIP712 transaction flow regardless of whether you use a paymaster or not - this means you can override zkSync specific transaction variables like gas per pubdata and we'll still route your transaction through the 712 flow. If none of this made sense to you, don't worry, these are low level uncommon use cases.

Miscellaneous

[Utils] Added Utils.GetAddressFromENS and Utils.GetENSFromAddress - more info about ENS here.
[Utils] Added Utils.IsDeployed as a standalone way to check if there is contract code at a specified address.
[AA] CallGasLimit UserOp value now accepts user estimated or manual gas limits as overrides automatically if it's above bundler esimated callGasLimit.
[RPC] Improved response time, batching and caching behavior.

Unity-Specific

[ThirdwebManager] Added EcosystemWalletOptions as a parameter for when connecting to WalletProvider.EcosystemWallet.
[ThirdwebManager] Added EcosystemWalletModal prefab - similar to InAppWalletModal, will spawn if using ThirdwebManager.ConnectWallet with the respective wallet provider and otp-based authentication // fully customizeable, as are all things thirdweb. You may still opt to use our lower level .NET APIs and create your own flows.
[Extensions] Added Unity-specific extension for the NFT type - NFT.GetNFTSprite will return a Sprite loaded with your NFT's image.

Mandatory - Various Fixes & Performance Improvements

No, really. We're serious.

What's Next?

Now that the core is stable, we want to listen to your feedback, improve on all of it while also continuing to add features and unlock more functionality to help game developers, studios and publishers across the globe integrate the best tech ever created - blockchain tech.

UI Components are next, expect Scene_Playground to be updated as we roll those out - first up, production ready, fully featured Connect.

Support

https://thirdweb.com/support

Releases

.NET v2: https://www.nuget.org/packages/Thirdweb/2.0.0

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

Greg

Basename Resolution

The thirdweb SDK now supports Basenames or any other L2 ENS subdomains. To convert any Basename to an address, you can use the existing resolveAddress function.

import {
resolveAddress,
BASENAME_RESOLVER_ADDRESS,
} from "thirdweb/extensions/ens";
import { base } from "thirdweb/chains";
const address = await resolveAddress({
client,
name: "myk.base.eth",
resolverAddress: BASENAME_RESOLVER_ADDRESS,
resolverChain: base,
});

You can determine any address's Basename using the new resolveL2Name function.

import {
resolveL2Name,
BASENAME_RESOLVER_ADDRESS,
} from "thirdweb/extensions/ens";
import { base } from "thirdweb/chains";
const name = await resolveL2Name({
client,
address: "0x1234...",
resolverAddress: BASENAME_RESOLVER_ADDRESS,
resolverChain: base,
});

Bug Fixes and Other Improvements

  • Signature mint UIDs now accept a string
  • In-app wallet connection is now hidden in the PayEmbed
  • Merkletree proof fix for Drop contracts
  • Improved error messages for smart wallet connection failures
  • Fixed NFT approval on CreateDirectListingButton
Firekeeper

We’re excited to announce the latest update to our Unreal Engine plugin! This release brings expanded support for both Unreal Engine 5.3 and 5.4, ensuring smooth integration across a wider range of projects. We've also added compatibility for Mac and Linux targets, broadening the plugin’s reach and making it more versatile for developers working on different platforms.

In this update, we’ve significantly improved the OAuth flow by leveraging the embedded Unreal WebBrowser, making the authentication process smoother and more reliable. Additionally, we've addressed and resolved issues with Apple and Facebook login, ensuring a seamless experience for users.

Stay tuned for more updates as we continue to enhance the plugin and support your development needs!

Unreal Marketplace Link

Greg

We've added a new template project our collection of almost 300 project templates. You can now quickly get started with a React frontend and Go backend using SIWE. Just like Next.js and Express Auth templates, you'll get a fully working app with SIWE authentication via our connect button. You can use this to build gated backend endpoints without any web2 authentication. Check out the template here, and reach out on our support site with any issues.

GitHub - thirdweb-example/thirdweb-auth-react-go: Example thirdweb Auth application using React and Go.
Example thirdweb Auth application using React and Go. - thirdweb-example/thirdweb-auth-react-go
Edward Sun

We've made a big update on thirdweb Pay that enables crypto or credit card sales for any purchase – on-chain or off-chain.

How does this work?

Let's say you want to sell a hoodie and you want to take payment in Base USDC.

You don't want to limit your customers by their ability to find a way to Base. With thirdweb Pay, anyone can buy with anything in their wallet – crypto or physical:

What happens after your customers send you funds? You'll want a secure way to be notified, and kick off your fulfillment flow. This is where webhooks come in.

Create a webhook on your Pay dashboard to securely receive purchase events. Once your webhook is called, kick off your flow to deliver the goods to your customers. You can sell:

  • a real-life hoodie
  • an NFT of a hoodie
  • your custom game token
  • anything in your imagination

If you are selling something on-chain, we strongly recommend using thirdweb Engine for delivery.

Get started with thirdweb Pay today. Visit the Commerce section in the Pay playground to start your implementation - it only takes a few seconds. 🔨

Winston Yeo

Previously, when querying for user details via the in app wallet backend API, you would get something like:

[
{
"userId": "2c7af0c5-798d-446a-9a30-305110c57783",
"walletAddress": "0x9020d2941ad941ABc1C2890301D8F889e263b0C4",
"phone": "+1234567890",
"createdAt": "2024-04-03T16:36:26.379156+00:00",
}
]

Now it returns something like:

[
{
"userId": "2c7af0c5-798d-446a-9a30-305110c57783",
"walletAddress": "0x9020d2941ad941ABc1C2890301D8F889e263b0C4",
"phone": "+1234567890",
"createdAt": "2024-04-03T16:36:26.379156+00:00",
"linkedAccounts": [
{
"type": "cognito",
"details": {
"phone": "+12265055474"
}
}
]
}
]

Note the addition of the linkedAccounts field.

This adds full support for linked accounts which we introduce a while back.

For more details, check out the updated docs here!

Edward Sun

thirdweb Pay now supports any chain built on the Polygon AggLayer.

Allow your users to pay with any cryptocurrency or credit/debit card for transactions or tokens on any chain built on the Polygon stack. If you're building a chain on the Polygon stack, let us know!

Edward Sun

We've dramatically lowered fees on thirdweb Pay for credit card transactions.

This change is especially impactful for non-US customers, where fees are now cheaper by 20 to 30%!

Pay allows your users to purchase cryptocurrencies and execute transactions with their credit card or debit card, or with any existing cryptocurrency in their wallet. Visit the docs to get started 🛠️ 🚀.

Manan Tank

We're excited to introduce the new Connect Button Playground — a powerful new tool designed to simplify the process of configuring the thirdweb v5 SDK's Connect Button

0:00
/2:43

  • Easily Customize Wallets: Choose from 350+ popular wallet providers
  • Configure In-app wallet sign options: Allow users to sign in using various methods, including Google, Discord, Farcaster, Telegram, Passkey, email, or phone number.
  • Real-Time Configuration: Preview and Adjust the appearance and functionality of your Connect Button in real-time, ensuring it perfectly fits your application’s needs.
  • Enhanced UI Customization: Fine-tune modal options, appearance, theme, and colors to match the UI perfectly with your app
  • Code Generation: Code is generated for your selected configuration so you can easily copy and paste the code and integrate it in your application in seconds!

Try out the new Connect Button Playground

Amine Afia

Thirdweb RPC network is rapidly expanding worldwide, enhancing our ability to deliver a more responsive and reliable experience across all regions. With the introduction of Geo Routing, your requests are now intelligently routed to the closest available node, resulting in faster response times.

By routing requests to the nearest node based on the client’s location, RPC Edge achieves reduced latency and enhances global coverage. For example, in regions like Southeast Asia, we've seen up to a 10x improvement in response times. Requests that previously experienced frequent peaks of up to 2 seconds are now consistently processed in under 200 milliseconds.

We remain committed to continually optimizing RPC Edge to seamlessly power every application built on Thirdweb with the best possible performance, no matter where your users are located.

Greg

New Connect UI

We've redesigned the Connect UI for a better user profile experience. Each wallet now receives a unique gradient avatar based on the address (unless the wallet has an ENS profile image). We've also updated the modal and wallet switching UX for easier wallet management. No changes are necessary to take advantage of the new UI, just upgrade to v5.48.0 or later.

0:00
/0:21

Wallet Linking

You can now associate any injected wallet with an existing in-app wallet. This works just like our new Unified Identity with the new wallet authentication strategy. The user will be prompted to sign a standard SIWE message that adds the wallet address to the current account's connected profiles list.

import { inAppWallet, createWallet } from "thirdweb/wallets";
import { mainnet } from "thirdweb/chains";
const rabby = createWallet("io.rabby");
const wallet = inAppWallet();
const account = await wallet.connect({
client: MY_CLIENT,
strategy: "wallet",
wallet: rabby,
chain: mainnet,
});

This same functionality is available in the prebuilt Connect UI.

0:00
/0:19

Bug Fixes and Improvements

  • The Pay modal will now only appear if the user doesn't have enough funds to complete the transaction.
  • Fixed conditionally rendered hook error when buying funds with fiat
Firekeeper

What's Changed

Support for Account Abstraction 0.7.0 (EntryPoint 0.7.0)

You may now opt to use our new Account Factories that are built on top of the 0.7.0 ERC-4337 standard release, by passing Constants.ENTRYPOINT_ADDRESS_V07 as your entryPoint parameter in SmartWallet.Create or through the ThirdwebManager's ConnectWallet function. Note that we will continue supporting AA 0.6.0 - so no rush.

Among various other things, this unlocks:

  • Improved gas costs when interacting with Smart Wallets due to packed UserOp structs and more changes.
  • Improved gas limit estimations and faster simulation.
  • Token Paymasters - though not live on 0.7 until a little later, the API has been exposed to pass a TokenPaymaster (enum) when creating a Smart Wallet and choose which ERC20 you want users to pay gas with. This is an alternative to the default gasless flow where you sponsor gas for your users.

We've also added support for Abstract Testnet's native account abstraction (ZkSync-based chain).

Authentication

The new API for authenticating with your backend through SIWE in a single call looks like this now.

public static async Task<T> Authenticate<T>(
this IThirdwebWallet wallet,
string domain,
BigInteger chainId,
string authPayloadPath = "/auth/payload",
string authLoginPath = "/auth/login",
string authPayloadMethod = "GET",
string authLoginMethod = "POST",
bool separatePayloadAndSignatureInBody = false,
IThirdwebHttpClient httpClientOverride = null
)

We've made it a little more flexible so you can hopefully get rid of any custom authentication code you might have and use this helper instead to unlock backend thirdweb auth with any wallet easily.

We've also fixed an issue with some older variants of Smart Wallet factories which resulted in "Invalid SIgnature" being thrown upon personal signing (and by extension, authenticating).

API Improvements

  • Low Level - Added IThirdwebWallet.ExecuteTransaction support for external and smart wallets to execute raw low level transaction input rather than going through ThirdwebTransaction.
  • Low Level - Simplified the ThirdwebTransactionInput by adding a constructor with user friendly types.
  • Mid Level - Added ThirdwebTransaction.Prepare, allowing you to have a quick way to estimate, simulate and populate a transaction without sending it.
  • High Level - Deprecated Utils.FetchThirdwebChainAsync, please use Utils.GetChainMetadata as the former will be removed in a future version.

General Improvements

  • Stricter coding standards were implemented, making sure the core won't fail you regardless of which .NET version or platform you're on.
  • Improved performance and stability across the board.
  • Various minor bugfixes were implemented and a couple properties were renamed to improve DX.

.NET Docs: https://portal.thirdweb.com/dotnet
Unity v5 Docs: https://portal.thirdweb.com/unity/v5

.NET Nuget: https://www.nuget.org/packages/Thirdweb
Unity Release: https://github.com/thirdweb-dev/unity-sdk/releases/tag/v5.0.0-beta.4

Phillip Ho

We’ve added an EOA Transaction Simulator to thirdweb’s collection of free tools!

Provide details about the sender wallet and the contract method to call, and see the precise error that would be returned by the contract call. Successfully simulated calls also return the estimated gas settings for the transaction.

Use Cases

  • Rapidly test behavior with different function arguments.
  • Debug failing contract calls when using the Connect SDK or Engine.
  • Test your contract permissions by simulating calls from different wallet addresses.
A failed simulation prints the error returned from the contract function.
A successful simulation prints estimated transaction details.

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

Joaquim Verges

We just released v5.46 of the thirdweb SDK which adds react native passkey support for in-app wallets.

This means that you can onboard users with just their fingerprint, giving them a full user profile and wallet with just one tap!

0:00
/0:12

You can integrate this using the prebuilt ConnectButton or ConnectEmbed with just one line of code, but it's also very simple to build your own UI and connect using the typescript API.

Here's an example to connect an in-app wallet with passkey, and sponsor all transactions. With this you can make the blockchain completely invisible.

const wallet = inAppWallet({
auth: {
passkeyDomain: "example.com",
},
smartAccount: {
chain: base,
sponsorGas: true,
},
});
await wallet.connect({
client,
strategy: "passkey",
type: "sign-in",
});

Check out the documentation for more info.

Happy building 🛠️

Firekeeper

What's Changed

Added SIWE (Sign In With Ethereum) as an additional login provider for In-App Wallets.

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

Added ability to link accounts, creating a Unified Identity across email, phone, social and other authentication options.

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

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

Miscellaneous

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

Releases

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

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

Documentation

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

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

Greg

Unified Identity (Profile Linking)

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

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

0:00
/0:28

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

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

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

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

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

This will return a profiles array similar to below.

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

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

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

Split Contract Extension

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

Vote Contract Extension

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


Bug Fixes and Other Improvements

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

Overview

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

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

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

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

Get started by following the documentation here.

Features

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

Getting Started

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

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

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

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

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

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

Firekeeper

What's Changed

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

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

Firekeeper

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

It's that simple!

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

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

Greg

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

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

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

Key Improvements

Unified API

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

Enhanced Composability

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

Native Experience

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

Simplified ThirdwebManager

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

Optimized Package

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

Cross-Platform Consistency

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

Comprehensive Chain Support

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

Join the Future of Blockchain Gaming

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

Documentation and Support

Firekeeper

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

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

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

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

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

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

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

Prithvish Baidya

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

Depending on network limitations and conditions, Engine v2 is able to fill an entire block!

What's new?

Optimized transaction parallelization

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

Improved nonce management

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

High transaction API calls

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

How fast is it?

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

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

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

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

Why is this important?

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

How can I try it?

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

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

What are the breaking changes?

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

When will this Engine v2 be out of beta?

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

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

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


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

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

Firekeeper

What's Changed

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

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

discord-unity-v4

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

Greg

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

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

CreateDirectListingButton

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

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

German, Korean, and French Localization

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

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

Bug Fixes and Other Improvements

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

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

Smart Wallets

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

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

GetAllActiveSigners returns permissions similar to the inputs of CreateSessionKey

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

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

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

External Accounts

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

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

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

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

Miscellaneous

Thirdweb.Pay specific constants have been removed.

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

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

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

Firekeeper

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

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

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

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

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

Amine Afia

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

Detailed Load Monitoring

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

Error Rate Tracking

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

Health Check Insights

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

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

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

Greg

SDK Documentation

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

BuyDirectListingButton Added to the Connect UI

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

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

useChainMetadata Added to the React SDK

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

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

Bug Fixes and Other Improvements

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

Create In-App Wallets with Farcaster

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

To connect via farcaster with your own UI:

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

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

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

Or, try Farcaster login in our playground.

0:00
/0:15

Other Improvements

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

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

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

Why are we making this change?

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

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

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

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

Get Started with pre-builts

Navigate to the Modular Contracts collection on Explore

Choose the modular contract you want to deploy

Fill out contract parameters and deploy the contract

Configure your contract's functions post-deployment through Explorer

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

FAQs

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

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.

Greg

PayEmbed Modes

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

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

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

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

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

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

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

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

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

Redirect Mode

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

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

Other Improvements

  • NFTInput and NFTMetadata types are now available

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

Joaquim Verges

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.

Funding wallets

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

0:00
/0:10

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

Commerce

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.

0:00
/0:17

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.

Transactions

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

0:00
/0:48

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! 🛠️

Greg

Claim Button Component

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.

RPC Caching

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


Bug Fixes and Other Improvements

  • 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
Firekeeper

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

What's Changed

  • [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

Greg

In-App Wallet Sign In

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

0:00
/0:23

More Preset Chains

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

💡
Need a chain not exported from thirdweb/chains? You can generate any EVM chain's config with its chain ID using defineChain
  • 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

Lens Extension

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


Bug Fixes and Other Changes

  • 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

0:00
/0:23
Greg
0:00
/0:14

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.


Other Features and Bug Fixes

  • 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
Prithvish Baidya

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.

Greg

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.

0:00
/0:09
Joaquim Verges

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.

0:00
/0:23

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! 🛠️

Greg

ERC20 Paymaster Support

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.

Recent Transactions in the Connect UI

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.

Optional from Parameter for Contract Reads

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.


Bug Fixes

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

SIWE (Auth) is now supported in the React Native

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.

Retrieve a user's proof for an ERC20, ERC721, or ERC1155 airdrop claim

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.

Specify a recipient address on the Pay Embed

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.

Zora NFT support on getOwnedNFTs

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.

Vietnamese Locale added to Connect UI

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

Advanced UserOp Utilities

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.


Bug Fixes

  • 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
Amine Afia

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.

0:00
/0:21

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.

Farhan Khwaja

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!

Firekeeper

.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.

Phillip Ho

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.
The relevant Connect SDK utility methods are shown too!

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

Greg

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.

Add an ecosystem to your 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.

Protected Ecosystems

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.

👉
Today, ecosystem wallets are only available on the web. We're working hard to make these wallets available securely on native platforms soon.
Isaac Dubuque

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!

Joaquim Verges

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

0:00
/1:41

The components come it 2 flavors: ConnectButton and ConnectEmbed

ConnectButton

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.

ConnectEmbed

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! 🛠️

Edward Sun

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.

Firekeeper

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.

Platform-Agnostic & Performant

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.

Extension Framework

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.

Thirdweb Pay

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

Custom Authentication

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.

Miscellaneous

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!

What's Next

Unity 5.0!

Learn More

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!

Greg

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.

Connect UI

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.

Custom UI

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.

💡
If you don't specify chains, the chains available to your connection will be defined by the connecting application.

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.

Advanced Usage

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!

Manan Tank
Pay Dashboard
Pay Dashboard

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

Uncover Valuable Insights

  • 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

Check it out!

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 🚀

James Sun

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!

Farhan Khwaja

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

Enhanced ABI Support

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.

Ngrok URLs in the dashboard

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

Restrict the request body with keypair authentication

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

Resource metrics for Cloud-hosted Engine

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

zkSync Transaction Support

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.

Firekeeper

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.

Firekeeper

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.

Joaquim Verges

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! 🛠️

Yash Kumar

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

Contract Verification

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 Sources & ABI Import

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.

Greg

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?

useCapabilities

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

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.

⚠️
While this example shows the default thirdweb paymaster URL, we recommend setting up a proxy on your backend which calls this URL, and passing the proxy endpoint to sendCalls so you can control domain restrictions for anyone using your proxy.

useCallsStatus

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.

Try it out

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!

Joaquim Verges

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 ⚒️

Firekeeper

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!

Firekeeper

Massive upgrade to the WalletConnect SDK

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

WalletConnect Updates

  • 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.

Preview: Standalone target (Desktop)

b312e809bd60bed0a30ca1323a6eb9db-1
07842b7a8754e062eebceb0f222e2cd4
0b5b29b305e3f683c45ea81419cfed24

Preview: Mobile target (will scale down based on phone screen size)

b7824a675cba5b3e693b6f22aca7d640
c673368b6c41ca37ad2587efffff2f2d
a4756c6d80b1820b3b1d2b9fd230840a

Miscellaneous updates

  • [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

Greg

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.

0:00
/0:08

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.

Joaquim Verges

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! 🛠️