thirdweb Pay is getting a full overhaul, from UI to service to onchain capabilities. Upgrade to version 5.88.0 or later of the SDK to get the latest and greatest.

You can now onramp with over 40 fiat currencies to any token using just a credit card. This gives your users zero fees on select currencies, and no KYC required for low amounts.

We've added new chains and new tokens available to bridge and swap. Over 1000 routes were added and more coming.

We're working on improved infrastructure to provide up to 10x faster quotes! These improvements will steadily roll out over the coming weeks.

We've been refining the UI of our prebuilt PayEmbed for all use cases: top up, commerce and transactions. Improvements include: showing fiat values next to token value everywhere, refined token selection flow, better error messaging and more.

• Updated Thirdweb Rust static libraries to v1
  • In-App Wallets now have near 1:1 functionality with Ecosystem Wallets and share the same infrastructure.
  • Existing wallets will be automatically migrated to the new enclave infrastructure upon first login if needed.
• Smart Wallet Factory improvements
  • Factory address is now stored on creation, eliminating the need for repeated declarations in nodes.
• Write Contract node enhancements
  • Now implemented as a K2Node, allowing for raw data input via JSON.

• File length constraint fixes
  • Renamed all async tasks to comply with Epic's new 170-character file length rule, which previously caused issues due to plugin name hashing.
• Unreal Engine Version Specific Compilation Issues
  • Added various conditional imports to additional headers resolving version-specific compilation issues.
• Bug fixes
  • Fixed an issue where abstract class instantiation was attempted from Blueprints; now properly using the HasDedicatedNode meta tag.
  • Resolved an Android packaging error with the Thirdweb plugin in UE 5.4.
  • Fixed a crash on startup when packaging for Mac.
  • Fixed Write Contract ExpandNode Error.
  • Removed Chromium Embedded Framework (CEF) and related project settings.
  • Fixed multiple compilation, build, and packaging issues.

• Improved Examples
  • Updated samples to use the latest fixed nodes.
• DX improvements
  • Various enhancements to Thirdweb editor utilities.
• Other updates
  • Updated copyright to 2025.

Unreal Engine v2.0.0 | Fab Marketplace (May not be up to date at the time of reading this, if that is the case, build from our github source!)

Documentation | Support

You can now use thirdweb dashboard to deploy contracts deterministically (create2) on multiple EVM chains.

To use this feature, deploy any thirdweb prebuilt or a custom contract using thirdweb dashboard. Then navigate to the Cross chain tab on contract page as shown below:

Use the dropdown to select the chain you wish to deploy on. Then click on Deploy button.

Once the contract gets deployed (or if it's already deployed at that address), the status will change to Deployed and you can click the link as shown above to navigate to that chain's contract page.

This feature is available for all thirdweb prebuilt contracts as well as custom contracts that are deployed / published using thirdweb tools. All direct deploy contracts (i.e. not proxy) must be deployed deterministically to enable this feature.

Note: this feature is available only for EVM chains

Go ahead and deploy a contract here.

Previously, the thirdweb dashboard only allowed you to import contracts, without the ability to associate them with specific projects. Contracts were displayed as a single list across teams, projects, and account pages.

Now, you can organize your contracts within projects for better management.

As part of this update, all your deployed contracts have been automatically added to all your projects. You can now review each project and keep only the relevant contracts by removing others from the project

When deploying a new contract, you can now add it to a project immediately.

Existing contracts can be added to projects with the new "Add to Project" button on the contract details page. Here's Doodles NFT contract for example:

Unlike the previous "Import to Dashboard" and "Remove from Dashboard" actions, adding or removing contracts from a project no longer requires signing a message.

The Published Contracts page has been removed from the Teams and Projects pages and is now accessible via your Wallet profile page. A Link to the wallet profile page is also added in the Account Management Dropdown as shown below

Here's the thirdweb.eth profile page for example

• Smart Wallet transaction receipt polling can now time out based on your client "Other" timeout options, similar to normal transactions.
• Our dashboard now supports rotating your secret keys. Rotated secret keys are now supported in this version.
• You can now call InAppWallet or EcosystemWallet's Create function and instantly login with a twAuthTokenOverride which would be an auth token/cookie that you would have retrieved from any other thirdweb app, such as a web app, electron launcher, or any app built using our various SDKs.

var forwardedWallet = await InAppWallet.Create(
    client: myClient, 
    authProvider: AuthProvider.Github, 
    twAuthTokenOverride: "my.auth.token"
);

Previously, it was only possible to go from .NET to other React apps using GenerateExternalLoginLink, this unlocks the other way.

.NET Release | NuGet Release | Unity Release

Documentation | Support

Effective Date: February 11, 2025, at 2:00 PM PST

Since launching in 2021, over 2 million smart contracts have been deployed with our toolkit — powering billions of transactions every year. We’re making some changes to our fee structure to better support the development of our smart contract development toolkit.

Starting on the effective date, a 2.5% platform fee (applied to both native and ERC20 tokens) will be introduced for all prebuilt contracts deployed through the thirdweb dashboard after 2 pm PST on February 11, 2025.

Please note this change does not effect already deployed contracts.

This change applies to any contracts that have a primary sale recipient, including but not limited to:

• Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
• Token Contracts: TokenERC20, TokenERC721, TokenERC1155
• Specialized Contracts: , LoyaltyCard, BurnToClaim, MarketplaceV3

• The 2.5% fee will be automatically deducted from primary sales executed through these contracts. For example, an asset listed at 0.1 ETH will distribute 0.0975 ETH to the seller and 0.0025 ETH to the platform.
• The fee applies only to prebuilt contracts deployed via the thirdweb dashboard. Custom contracts or externally deployed contracts remain unaffected.
• The fee is charged from the primary sale, including a claim or mint action when there is a price on the NFT (non-zero). The fee is paid in the same currency as the claiming or minting price.

This adjustment helps support continued development and maintenance of prebuilt smart contracts, ensuring reliability, security, and innovation for the ecosystem.

For any questions or further details, please reach out to our support team.

• Which prebuilt contracts will have included fees?
  • The following contracts and corresponding modular versions will now include a seller fee:
    • Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
    • Token Contracts: TokenERC20, TokenERC721, TokenERC1155
    • Specialized Contracts: LoyaltyCard, BurnToClaim, MarketplaceV3
• I deployed a contract prior to the effective date, will these fees apply to me?
  This fee is only applied to any contracts deployed after 2 pm PST on 2/10/2025.
• Can I opt out of the changes?
  • This change only applies to contracts deployed via the dashboard and not any contracts deployed programatically.

This release introduces a powerful credential management system and adds support for Circle's Web3 Services wallets. Circle, known for USDC and trusted by major financial institutions, provides institutional-grade wallets with bank-level security and SOC certifications - perfect for teams that need robust security assurance and regulatory compliance.

Managing cloud credentials across multiple wallets has always been a pain point. We've fixed that with a new credential system that brings enterprise-grade security features to your wallet infrastructure.

What's awesome about it:

• Easy Rotation: Update credentials for multiple wallets at once by rotating their shared credential - perfect for regular security maintenance
• Security at Scale: All wallets using the same credential automatically inherit security updates and policy changes
• Audit Superpowers: Easily track which wallets are using which credentials for security reviews and compliance
• Emergency Ready: Quick response to security incidents by updating credentials across all affected wallets simultaneously

We've added support for Circle's w3s developer-controlled wallets, bringing enterprise-grade signing capabilities to Engine. These wallets integrate seamlessly with our new credential management system and existing Engine infrastructure for transaction management.

Upgrade to engine v2.1.32, then try creating a smart backend wallet backed by Circle:

POST /wallet-credentials
{
  "type": "circle",
  "label": "my-circle-credential",
  "entitySecret": "..."
}

POST /backend-wallet/create
{
    "type": "smart:circle",
    "credentialId": "..."
}

Learn more about the entitySecret and how to create one from the Circle docs.

Take a look at our docs to learn more about configuring Engine to support Circle wallet, and check out our API Reference for detailed documentation and more examples.

We're working on expanding the credential system to support more wallet types and rolling out default credentials. Stay tuned for updates!

We're working on expanding support for more institutional wallet providers. Using Fireblocks, Copper, or another institutional wallet provider? We want to hear from you! Let us know which integrations would help your team ship faster.

Got questions? Join our Discord or check out the documentation.

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.

This update brings natural language support for token swapping and bridging, expanded access to offchain knowledge, and improved session context management.

• Added support for swapping and bridging tokens in natural language
  • Example → "Swap 1 USDC to 1 USDT on the Ethereum Mainnet" or "Bridge 0.5 ETH from Ethereum Mainnet to Polygon"
• Added more support for offchain knowledge including research headlines and articles about tokens or protocols
  • Example → “Tell me more about $UNI project”
• Support for updating context using the /session/{session_id} endpoint
  • Example,

{
  "message": "Hello Nebula!",
  "context": { 
    "session_id": "...",
    "wallet_address": "0x...",
    "chain_ids": ["1", "11155111"]
  },
}
 

Nebula is currently in Alpha for a select number of developers. For access to the product, please sign up on the Nebula waitlist.

For any feedback or support inquiries, please visit our support site.

The Insight API now supports automatic decoding of events and transactions. Developers can now receive decoded transaction data by simply adding the decode=true parameter to event and transaction endpoint calls. Insight API will load ABIs directly from it's vast database of contract metadata and return decoded events directly in the response. This significantly simplifies dealing with onchain data for developers by removing the need to 1) manage ABIs for external contracts and 2) write logic for decoding event data from any chain.

Example:

https://1.insight.thirdweb.com/v1/transactions/0xdac17f958d2ee523a2206206994597c13d831ec7?filter_transaction_hash=0xf08df164ed5cff369e3f8016cfd1dc43814d04756ce72b59d1738d1c8760ef21&decode=true&limit=1

Response:

{
 ...
  "decodedData": {
    "name": "transfer",
    "signature": "transfer(address,uint256)",
    "inputs": {
      "_to": "0x7bea8a667815b1e98e6e4badacf1772c89112cfb",
      "_value": 719000000
    }
  }
...
}

Learn more about Insight from our docs or by reviewing the source code on GitHub.

This update brings significant improvements to Nebula, including an upgraded model (t2) for a more engaging and helpful experience—now with added personality and even emojis! 🚀

• More output personality to make Nebula more friendlier and helpful. It even outputs emojis :D
• Improved speed performance and handling about chains (block information) or wallets on common prompts
• Increased memory retention per session by and context holding within session
• Improved accuracy at responding to prompts related to historical blockchain data
• Improve speed performance when fetching wallet balance

• Fixed wallet balances failed to fetch error due to missing sale prices

Nebula is currently in Alpha for a select number of developers. For access to the product, please sign up on the Nebula waitlist.

For any feedback or support inquiries, please visit our support site.

As our customer base continues to grow, we’re enhancing our RPC Edge support process to ensure faster and more efficient assistance.

What’s Changing?

We’re introducing Support IDs to streamline issue resolution. When reporting an RPC Edge issue, you’ll receive a Support ID, which you can share with our team to expedite troubleshooting.

How This Helps You:

✅ Faster response times – No need to repeat details, just share your Support ID.

✅ More efficient issue tracking – Our support team can quickly locate and diagnose your request.

✅ Improved support experience – Ensures every user gets the help they need, faster.

Example:

When reporting an issue, provide your Support ID like this:

🆔 Support ID: d4dea8aa-ad4a-4fe5-968b-24f1927f6f0b

This change ensures that every RPC-related inquiry is handled with greater speed and accuracy. 🚀

What's Changed

TL;DR
Added a new /query/blocks endpoint to retrieve block data with filtering, sorting, and aggregation capabilities.

What changed?

• Created a new /query/blocks endpoint in the API
• Implemented block data retrieval with support for:
  • Filtering by chain ID and other block parameters
  • Sorting and pagination
  • Aggregation functions
  • Group by operations
• Updated the storage interface to return QueryResult for block operations
• Added block scanning functionality to handle database rows

How to test?

1. Start the API server
2. Make GET requests to /query/blocks with optional query parameters:
   • chainId: Specify the blockchain network
   • filter: Apply filters to block data
   • sort_by: Sort results by specific fields
   • sort_order: Choose ascending or descending order
   • page and limit: Control pagination
   • aggregate: Apply aggregation functions
   • group_by: Group results by specific fields

Why make this change?
To provide a standardized way to query and analyze block data from the blockchain, enabling users to retrieve block information with flexible filtering and aggregation options. This enhancement aligns with the existing transaction and event query capabilities of the API.

Why is this useful?
As an example, this feature allows users to easily fetch the earliest block number that meets a specific timestamp criterion. For instance, when constructing block ranges based on timestamps, this can help in determining the precise blocks that fall within certain time windows. This functionality is crucial for tasks such as historical data analysis, event tracking, or aligning blockchain queries with specific real-world dates.

Learn more about Insight and how to use it.
Insight is open source.

Open source version of Insight 0.2.1-beta has been released and focuses on the robustness and reliability of indexing blockchain data.

• Implemented dynamic block range calculations for the reorg handler, allowing both forward and backward scanning based on sync state.
• Improved logic to find specific reorged block numbers rather than ranges, allowing to scan bigger ranges at a time.
• Enhanced error messages for better debugging.
• Updated reorg detection to avoid including non-reorged edge blocks
• Implemented fetching blocks in parallel chunks for performance gains
• Improved test coverage

• Added support for more time functions in aggregations. Added `toDateTime`, `toStartOfMonth`, `toStartOfHour`, and `toStartOfMinute`
• Whitelisted concat function to be used in aggregations and parsing the contract address from raw data

• Improved delete performance in ClickHouse by implementing partition-aware deletes and asynchronous processing. This enhancement minimizes wait times and optimizes resource usage during deletion operations

Learn more about Insight and how to use it.
Insight is open source.

At thirdweb, we empower developers to build decentralized apps effortlessly—and reliable storage is core to that mission. Today, we’re announcing two key upgrades to our IPFS infrastructure: improved resilience and enhanced monitoring, designed to scale your dApps with confidence.

We’ve introduced automated failover and retry mechanisms for IPFS uploads. If a primary node fails, thirdweb instantly switches to a backup, ensuring seamless data storage with minimal downtime. This redundancy safeguards your app’s content against network disruptions, keeping it consistently accessible for users.

Our upgraded monitoring tools now track real-time upload success rates, latency, and node health metrics like bandwidth, storage capacity, and peer connections. Historical data analysis lets us preemptively optimize nodes, addressing issues before they impact your app.

User trust hinges on reliability. With thirdweb’s fortified storage layer, you can build knowing your app withstands real-world challenges—letting you focus on innovation, not infrastructure.

This release focuses on granular configurations for responses to control randomness, limitations, and formats for outputs. Additionally, two new OpenAI compatible endpoints including /chat/completions and /models, and simplified context filter endpoint for an improved developer experience.

• Enable advanced LLM configurations to control output randomness and formatting, including temperature, presence penalty, max tokens, new response formats (JSON object, JSON schema), and nucleus sampling (top-p).

{ 
	"message": "Hello Nebula!",
	// ...
	// advanced llm configuration
	"max_tokens": 100, // integer
    "frequency_penalty": 0.0, // [-2.0, 2.0]
    "presence_penalty": 0.0, // [-2.0, 2.0]
    "temperature": 1.0, // [0.0, 2.0]
    "top_p": 1.0, // [0.0, 1.0]
    "response_format": {}, //{ type: "json_object" } | { "type": "json_schema", "json_schema": { ... } }
 }

• New endpoint for /chat/completions compatible with OpenAI client to process chat history and generate context-aware responses.

POST "https://nebula-api.thirdweb.com/chat/completions" \
  -X POST \
  -H "X-Secret-Key: $THIRDWEB_SECRET_KEY" \
  --data '{
  "messages": [{ "role": "user", "content": "Hello Nebula!"}],
  // (optional) context management
  "context": {
	  "session_id": "...", // optional
	  "wallet_address": "0x...", // optional
	  "chain_ids": ["1", "11155111"], // optional
  },
  // (optional) advanced llm configuration
  "max_tokens": 100,
  "frequency_penalty": 0.0,
  "presence_penalty": 0.0,
  "temperature": 1.0,
  "top_p": 1.0,
  "response_format": { type: "json_object" }
}'

from openai import OpenAI
	
client = OpenAI(
	base_url="<https://nebula-api.thirdweb.com/>",
	api_key="{{THIRDWEB_SECRET_KEY}}",
)
	
chat_completion = client.chat.completions.create(
	model="t0",
	messages=[{"role": "user", "content": "Hello Nebula!"}],
	stream=False,	
    extra_body={ "context": { "wallet_address": "0x..." }}
)
 
print(chat_completion)

• New OpenAI compatible endpoint to list out models used by Nebula

from openai import OpenAI
 
# https://nebula-api.thirdweb.com/models
 
client = OpenAI(
    base_url="https://nebula-api.thirdweb.com/",
    api_key="",
)
 
models = client.models.list()
print(models)

• Simplified context_filter and execute_config into context for /chat, /execute, and /chat/completions endpoints.

Before:

 
{
  "message": "Hello Nebula!",
  "session_id": "...",
  "context_filter": { 
    "wallet_addresses": [], 
    "chain_ids": [], 
    "contract_addresses": []
  },
  "execute_config": { 
    "type": "client", 
    "signer_wallet_address": "0x0000..." 
  }
}

New:

{
  "message": "Hello Nebula!",
  "session_id": "...",
  "context": { 
    "wallet_address": "0x...",
    "chain_ids": ["1", "11155111"]
  },
}

Nebula is currently in Alpha for a select number of developers. For access to the product, please sign up on the Nebula waitlist.

For any feedback or support inquiries, please visit our support site.

With the thirdweb SDK, all smart wallets maintain the same address across any EVM chain. Account factories and wallet deployments are managed for you from within the thirdweb SDK unless overridden with your own factory. If you need a different wallet address for any reason, you can provide an optional account salt to the wallet.

Create a smart wallet on your default chain:

import { smartWallet } from "thirdweb/wallets";
 
const mySmartWallet = smartWallet({
  chain: sepolia,
  sponsorGas: true,
});

Send your transaction on any chain:

const sendTx = prepareTransaction({
  to: receiver.address,
  value: 100000n,
  chain: baseSepolia,
  client,
});
 
const sendResult = await sendAndConfirmTransaction({
  account: sender,
  transaction: sendTx,
});

If you need to create a wallet using the same admin account but a different address, use an account salt:

const mySmartWallet = smartWallet({
  chain: sepolia,
  sponsorGas: true,
  overrides: {
    accountSalt: "123",
  },
});

Check out the video for more:

.NET 2.17.0 Release

The last piece of the puzzle required to create .NET apps and games leveraging a blockchain-powered AI assistant or NPC that also has the power to fully execute transactions. Further enhanced when combined with Server Wallets and Account Abstraction.

Read, Write, Reason.
The best way to understand is to look at examples.

We'll prepare some context for the AI - here, we'll generate a basic PrivateKeyWallet and upgrade it to a SmartWallet on Sepolia.

// Prepare some context
var myChain = 11155111; // Sepolia
var mySigner = await PrivateKeyWallet.Generate(client);
var myWallet = await SmartWallet.Create(mySigner, myChain);
var myContractAddress = "0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8"; // DropERC1155
var usdcAddress = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"; // Sepolia USDC

A one liner creates a Nebula session.

// Create a Nebula session
var nebula = await ThirdwebNebula.Create(client);

You can Chat with Nebula. The Chat method accepts any IThirdwebWallet as an optional parameter, context will automatically be updated.

// Chat, passing wallet context
var response1 = await nebula.Chat(message: "What is my wallet address?", wallet: myWallet);
Console.WriteLine($"Response 1: {response1.Message}");

You may also pass it smart contract context.

// Chat, passing contract context
var response2 = await nebula.Chat(
    message: "What's the total supply of token id 0 for this contract?",
    context: new NebulaContext(contractAddresses: new List<string> { myContractAddress }, chainIds: new List<BigInteger> { myChain })
);
Console.WriteLine($"Response 2: {response2.Message}");

You can have a full on conversation with it with our Chat override accepting multiple messages.

// Chat, passing multiple messages and context
var response3 = await nebula.Chat(
    messages: new List<NebulaChatMessage>
    {
        new($"Tell me the name of this contract: {myContractAddress}", NebulaChatRole.User),
        new("The name of the contract is CatDrop", NebulaChatRole.Assistant),
        new("What's the symbol of this contract?", NebulaChatRole.User),
    },
    context: new NebulaContext(contractAddresses: new List<string> { myContractAddress }, chainIds: new List<BigInteger> { myChain })
);
Console.WriteLine($"Response 3: {response3.Message}");

Chatting is cool, but what if I just want it to do things and stop talking so much?

You can Execute transactions directly with a simple prompt.

// Execute, this directly sends transactions
var executionResult = await nebula.Execute("Approve 1 USDC to vitalik.eth", wallet: myWallet, context: new NebulaContext(contractAddresses: new List<string>() { usdcAddress }));
if (executionResult.TransactionReceipts != null && executionResult.TransactionReceipts.Count > 0)
{
    Console.WriteLine($"Receipt: {executionResult.TransactionReceipts[0]}");
}
else
{
    Console.WriteLine($"Message: {executionResult.Message}");
}

Similarly, Execute can take in multiple messages.

// Batch execute
var batchExecutionResult = await nebula.Execute(
    new List<NebulaChatMessage>
    {
        new("What's the address of vitalik.eth", NebulaChatRole.User),
        new("The address of vitalik.eth is 0xd8dA6BF26964aF8E437eEa5e3616511D7G3a3298", NebulaChatRole.Assistant),
        new("Approve 1 USDC to them", NebulaChatRole.User),
    },
    wallet: myWallet,
    context: new NebulaContext(contractAddresses: new List<string>() { usdcAddress })
);
if (batchExecutionResult.TransactionReceipts != null && batchExecutionResult.TransactionReceipts.Count > 0)
{
    Console.WriteLine($"Receipts: {JsonConvert.SerializeObject(batchExecutionResult.TransactionReceipts, Formatting.Indented)}");
}
else
{
    Console.WriteLine($"Message: {batchExecutionResult.Message}");
}

Full Reference

We've added transaction and connection analytics that will show up on your thirdweb dashboard and give you a better sense of your users' activities - make sure you grab this version to get the benefits!

If you've read this far, access Nebula and start building cool things. You're early - a full stack blockchain integration powered by AI is not something you see in .NET land too often, make use of thirdweb to build next-gen applications, and reach out to us!

Unity 5.17.0 Release

• Additions from Thirdweb's .NET SDK Release 2.17.0
  • Includes Thirdweb Nebula AI Integration.
  • Combine with Backend Wallets & Account Abstraction to create truly unique experiences.
• Moved analytics to the .NET SDK (DLL), removed from ThirdwebManagerBase.
• MetaMaskWallet.Disconnect now calls wallet_revokePermissions allowing you to fully disconnect the extension - thanks @tulfix !

You now have all the tools to be the first to build the best interactive NPCs to ever accompany your players - contact us if you run into any issues!

Links

.NET Release | NuGet Release | Unity Release

Documentation | Support

We just added a new section on your project overviews showing how your users are transacting from your apps!

These stats will show all transactions initiated from the client side by day/week/month, as well as the most interacted chains and contracts with direct links.

Check out your own stats by navigating to your project overview, and make sure to use the latest version of the thirdweb SDKs.

We're continuously improving our analytics to better help you monitor the growth of your apps, let us know what you'd like to see next!

At Thirdweb, we’ve been hard at work implementing significant improvements to our infrastructure, and we’re thrilled to share the results of these efforts. This update represents a major leap forward in scalability, performance, and resilience, ensuring we’re better equipped to serve our users now and in the future. Here's what we’ve achieved:

One of the key drivers of this overhaul was the need to reduce latency and improve response times. Our engineering team has:

• Reduced P99 Latency: We’ve slashed P99 latency from upwards of 20 seconds to just 2 seconds. This improvement means even the slowest requests now complete faster than ever.
• Optimized Average Response Time: The average response time is now just 250ms, providing a snappier, smoother experience for our users.
• Expanded Regional Coverage in Europe and Asia Pacific: We have introduced new regions in Europe and Asia Pacific, allowing us to provide more localized services to meet the growing demands of our global customer base. Additionally, these new regions enhance our disaster recovery capabilities, ensuring greater resiliency and reliability.

These enhancements ensure that our platform is not only faster but also more consistent under varying workloads.

To handle ever-increasing traffic demands, we’ve rolled out improved autoscaling capabilities. These dynamic systems allow us to:

• Respond to peak load surges without sacrificing performance.
• Maintain cost efficiency by scaling resources up or down as needed.

This ensures that no matter how much demand our platform faces, we’re ready to deliver resilient service.

Reliability is critical, especially as we scale. To validate our infrastructure’s ability to handle increasing demand, we conducted resilience testing at over 6,000 Requests Per Second (RPS). The system performed admirably, solidifying confidence in its ability to handle extreme loads.

Our load testing focused on the RPC router, which efficiently routed requests to over 2,000 nodes globally over a 6-hours period. The screenshots below provides a sample measurement of the aggregated P90 latency across all RPC calls in all regions.

We’re expanding our global footprint with the rollout of Regional RPC services in Asia Pacific (SEA), Europe (EU), and Americas (US). This regionalization improves latency by up to 60% for users across the globe and ensures a more localized and reliable service experience.

Security and collaboration are critical, and our updated authentication system now integrates seamlessly with teams. This allows:

• Enhanced access control for better security.
• Simplified management of team-based workflows.

This update ensures that working as a team on our platform is both secure and effortless.

These improvements mark a significant milestone in our ongoing commitment to delivering a fast, reliable, and scalable platform for our users. But we’re not stopping here. Our team is already planning the next wave of enhancements to stay ahead of the curve and continue providing the best experience possible.

Thank you for being a part of our journey. We’re excited about these changes and can’t wait for you to experience them. Let us know your thoughts and stay tuned for more updates!

thirdweb v5.85.0 has been released with new features a breaking change for the beta nebula API as well as notable bug fixes.

The following property names have been updated in Nebula.chat() and Nebula.execute() to align with the HTTP API:

• prompt is now message
• context is now contextFilter

Before:

Nebula.chat({
  client,
  prompt:
    "What's the total supply of this contract: 0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8",
  context: {
    chains: [sepolia],
  },
});

After:

Nebula.chat({
  client,
  message:
    "What's the total supply of this contract: 0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8",
  contextFilter: {
    chains: [sepolia],
  },
});

Both Nebula.chat() and Nebula.execute() now support multiple input messages through the new messages property, enabling more complex conversation flows.

Nebula.chat({
  client,
  messages: [
    {
      role: "user",
      content:
        "Tell me the name of this contract: 0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8",
    },
    {
      role: "assistant",
      content: "The name of the contract is My NFT Collection",
    },
    {
      role: "user",
      content: "What's the symbol of this contract?",
    },
  ],
  contextFilter: {
    chains: [sepolia],
  },
});

Nebula.execute({
  client,
  account,
  messages: [
    { role: "user", content: "What's the address of vitalik.eth" },
    {
      role: "assistant",
      content:
        "The address of vitalik.eth is 0xd8dA6BF26964aF8E437eEa5e3616511D7G3a3298",
    },
    { role: "user", content: "Send them 0.0001 ETH" },
  ],
  contextFilter: {
    chains: [sepolia],
  },
});

Each message in the array requires a role ("user" or "assistant") and content string.

• Fixed NFT components incorrectly displaying metadata when multiple contracts with the same token ID are rendered due to caching issues
• Fixed MarketplaceV3 deployment for Xsolla testnet

• Added mode as a predefined chain
• Added overrides for Lumia Testnet to use pre-EIP1559 gas values

This chart shows a breakdown of transactions sent by your Engine's backend wallets by their status. This gives you an insight into the transaction volume and success/error rate trend at a glance

Pagination and Status filters added in Transaction history table. Pagination UI also has an input field that allows you quickly jump to a page - allowing you to quickly comb through a large list of transactions

We've added new chains to the platform this week!

Sei Testnet: RPC and Chain Settings

Use the best Sei Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.

Sei Network: RPC and Chain Settings

Use the best Sei Network RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Viction Testnet: RPC and Chain Settings

Use the best Viction Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Eclipse Testnet: RPC and Chain Settings

Use the best Eclipse Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

EVM on Flow Testnet: RPC and Chain Settings

Use the best EVM on Flow Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.

Rivalz: RPC and Chain Settings

Use the best Rivalz RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Rivalz2: RPC and Chain Settings

Use the best Rivalz2 RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Ouroboro: RPC and Chain Settings

Use the best Ouroboro RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Every chain comes out of the box with SDK support RPC, Engine and Account Abstraction capabilities. All you need is the chain id to get going.

const wallet = smartWallet({
  chain: defineChain(388), // just need the chainId!
  sponsorGas: true,
});

For testnets, you'll also find a faucet in each chain page.

Happy building! 🛠️

.NET v2.16.0 Release

Depending on the framework, or on the external wallet platform support, you may not have direct access to every single wallet out there.
This new AuthProvider allows you to login to otherwise native-unavailable wallets such as Abstract Wallet & Coinbase Smart Wallet through a flow similar to OAuth, using SIWE.

It'll redirect you to static.thirdweb.com and use our React SDK and other wallet SDKs as needed, unlocking the ability to login (or link) with any wallet thirdweb supports on web, from runtime platforms that would otherwise be unsupported by said wallet, and create an In-App or Ecosystem Wallet out of it.

Windows Console Example:

var inAppWalletSiweExternal = await InAppWallet.Create(client: client, authProvider: AuthProvider.SiweExternal);
var address = await inAppWalletSiweExternal.LoginWithSiweExternal(
    isMobile: false,
    browserOpenAction: (url) =>
    {
        var psi = new ProcessStartInfo { FileName = url, UseShellExecute = true };
         _ = Process.Start(psi);
    },
    forceWalletIds: new List<string> { "io.metamask", "com.coinbase.wallet", "xyz.abs" }
);

This is useful when you want your guest mode to be tied to a unique device identifier, and depending on your framework there may be various APIs to fetch such identifiers that you may want to use.

Example:

var guestWallet = await EcosystemWallet.Create(
    ecosystemId: "ecosystem.the-bonfire",
    client: client,
    authProvider: AuthProvider.Guest
);
var address = await guestWallet.LoginWithGuest(SomeSystemInfoAPI.deviceUniqueIdentifier);

Unity 5.16.0 Release

• Additions from Thirdweb's .NET SDK Release 2.16.0
• Integrated AuthProvider.SiweExternal in ThirdwebManager.
  • Work around your favorite external wallet not having Unity support.
  • OAuth style linking variant of AuthProvider.Siwe, but using wallets and SIWE in a static React environment.

var walletOptions = new WalletOptions(
    WalletProvider.InAppWallet,
    421614,
    new InAppWalletOptions(authprovider: AuthProvider.SiweExternal)
);
var wallet = await ConnectWallet(walletOptions);
ThirdwebDebug.Log("Connected to InAppWallet with SiweExternal auth provider." + await wallet.GetAddress());

• AuthProvider.Guest now uses a unique device identifier, making it a little more persistent than the previous implementation.
  • Guest mode is meant as an ephemereal login method, you should allow users to link additional auths later in the flow.
  • This update makes Guest mode a little more persistent in cases where users delete something by mistake.
• Fixed edge case where Application.identifier being an empty string with some build configs would cause an empty bundle id to be used as the fallback instead of com.company.product.

Links

.NET Release | NuGet Release | Unity Release

Documentation | Support

• Nebula TypeScript SDK now available in Beta, integrate /chat and /execute calls easily or be able to plug into any framework
  • View the full reference documentation
• New example template on how to create specialized AI agents that can interact with blockchain data while maintaining a distinct personality and purpose
  • View template

• Read and write contracts with better function argument extraction
  • Improved understanding and parsing for array function arguments related to reading or executing contract functions

• ENS resolver not parsing correctly in select cases
• Query wallet balance improvements handling wallet addresses with multiple tokens or NFTs
• Add improved read support for chains with block extraData including Polygon

The thirdweb TypeScipt SDK v5.84.0 release adds support for Nebula, our new AI model designed interact with real time blockchain data and execute transactions with natural language.

Simply install the thirdweb package on your frontend or backend to get started.

npm install thirdweb

Nebula enables developers to query real-time blockchain data using simple natural language prompts. From checking contract symbols to analyzing on-chain metrics, Nebula provides human-readable responses to your blockchain queries.

import { Nebula } from "thirdweb/ai";
 
const response = await Nebula.chat({
  client,
  prompt:
    "What's the symbol of this contract: 0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8",
  context: {
    chains: [sepolia],
  },
});
 
console.log("chat response:", response.message);

Nebula goes beyond just querying data - it can now execute blockchain transactions based on natural language instructions. Simply connect your wallet and describe the transaction you want to perform.

import { Nebula } from "thirdweb/ai";
 
const wallet = createWallet("io.metamask");
const account = await wallet.connect({ client });
 
const result = await Nebula.execute({
  client,
  prompt: "send 0.0001 ETH to vitalik.eth",
  account,
  context: {
    chains: [sepolia],
  },
});
 
console.log("executed transaction:", result.transactionHash);

• Natural language processing for blockchain queries
• Real-time data access across 2000+ chains
• Transaction execution through simple prompts
• Works with 300+ wallet providers, in-app wallets, smart wallets and engine
• Context-aware responses and actions with multi step sessions

This addition to the SDK marks a significant step forward in making blockchain technology more accessible and user-friendly. Nebula's natural language capabilities greatly reduce the complexity of doing complex actions on the blockchain.

For detailed documentation and examples, please visit our documentation portal or join our Discord community for support and discussions.

Happy Building! 🛠️

The thirdweb TypeScript sdk v5.84.0 introduces the new engineAccount() function, enabling seamless backend integration with your thirdweb Engine instance. This addition allows developers to leverage the full power of the thirdweb SDK and contract extensions functions in backend environments while benefiting from Engine's performance, reliability, and monitoring capabilities.

• Create Engine-powered accounts for backend transaction handling with nonce and fund management
• Full access to thirdweb SDK functions and extensions from the backend
• Built-in transaction monitoring and reliability features

// Initialize engine account with your instance credentials
const engine = engineAccount({
  engineUrl: process.env.ENGINE_URL,
  authToken: process.env.ENGINE_AUTH_TOKEN,
  walletAddress: process.env.ENGINE_WALLET_ADDRESS,
});
 
// Prepare transactions like usual
const tx = await claimTo({
  contract: getContract({ client, chain, address: "0x..." }),
  to: "0x...",
  tokenId: 0n,
  quantity: 1n,
});
 
// Send transaction through engine
const result = await sendTransaction({
  account: engine,
  transaction: tx,
});
 
// Transaction hash is returned once engine submits it onchain
console.log(result.transactionHash);

This update helps backend development workflows by opening up the large catalog of extensions functions available in the SDK. The engineAccount() function serves as a bridge between your backend services and the blockchain, handling transaction preparation, submission, and confirmation in a reliable manner.

For more information about this release, please visit our documentation or join our Discord community for support and discussions.

The SDK now exposes the autoConnect function for use outside of React environments. This allows developers to implement wallet auto-connection functionality in any JavaScript/TypeScript environment.

import { autoConnect } from "thirdweb/wallets";
 
const autoConnected = await autoConnect({
  client,
  onConnect: (wallet) => {
    console.log("wallet", wallet);
  },
});
console.log("isAutoConnected", isAutoConnected); // true or false

For more information about this release, please visit our documentation or join our Discord community for support and discussions.

Happy building! 🛠️

We're excited to introduce powerful new batching capabilities in Engine v2.1.25, enabling you to execute multiple operations atomically and efficiently read from multiple contracts in a single call.

New Endpoint: /backend-wallet/{chainId}/send-transaction-batch-atomic

Send multiple transactions that will be executed together in a single atomic operation. Perfect for operations that need to happen in a specific order, like token approvals followed by transfers. Check out the API Reference for more details.

• Guaranteed order of execution
• All transactions succeed or fail together
• Single queue ID for tracking the entire batch
• Compatible with all smart account setups:
  • Smart backend wallets (no additional headers needed)
  • Regular backend wallets using x-smart-account-address header

curl --request POST \
  --url http://localhost:3005/backend-wallet/84532/send-transaction-batch-atomic \
  --header 'Authorization: Bearer {{authToken}}' \
  --header 'x-backend-wallet-address: {{walletAddress}}' \
  --data '{
  "transactions": [
    {
      "toAddress": "0x...",
      "value": "0",
      "data": "0x..." // First transaction (e.g., approval)
    },
    {
      "toAddress": "0x...",
      "value": "0",
      "data": "0x..." // Second transaction (e.g., transfer)
    }
  ]
}'

• Previous: Each transaction got its own queue ID, executed independently
• New: Single queue ID for entire batch, guaranteed atomic execution

New Endpoint: /contract/{chainId}/read-batch

Execute multiple read operations across different contracts in a single call, with guaranteed consistency of data from the same block. Check out the API Reference for more details.

• All reads executed in the same block
• Reduced RPC calls using multicall3
• Perfect for getting related data across contracts
• Consistent state snapshot across all reads

curl --request POST \
  --url http://localhost:3005/contract/421614/read-batch \
  --header 'Authorization: Bearer {{authToken}}' \
  --data '{
  "calls": [
    {
      "contractAddress": "0x...",
      "functionName": "balanceOf"
    },
    {
      "contractAddress": "0x...",
      "functionName": "allowance"
    }
  ]
}'

The transaction status object now includes a batchOperations field that provides details about all operations in an atomic batch. This field will be null for non-batch transactions:

{
  batchOperations: [
    {
      to: string | null,
      data: string | null,
      value: string,
    },
  ] | null;
}

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.

Contract Analytics on thirdweb dashboard is now powered by thirdweb Insight

You can select a date range and see various analytics for the contract such as

• Unique wallets that have sent transactions
• Total Transactions & Events
• Breakdown of unique Functions calls & emitted Events

View this contract analytics on dashboard

Insight is a powerful tool that lets you retrieve blockchain data from any EVM chain, enrich it with metadata, and transform it using custom logic.

Whether you're building a gaming inventory system, tracking DeFi metrics, or analyzing NFT collections, Insight makes it easy to get the data you need with simple API calls. Learn more about thirdweb insight to use in your projects!

We’re excited to announce a major update to Insight API! The latest changes enhance the API’s functionality by introducing multichain support, enabling seamless data fetching across multiple blockchain networks.

• Parallel Data Fetching: Fetch data from multiple chains simultaneously, improving efficiency.
• Consolidated Responses: Responses now include chain_ids in the payload to identify the source chain for each piece of data.
• Enhanced Response Schema: Added metadata fields:
  • chain_ids: List of queried chain IDs.
  • total_items: Total count across all chains.
  • limit_per_chain: Indicates the per-chain limit derived from the request's original limit.

Only requests with supported chain IDs—validated against Thirdweb Insight’s chain list—are now processed. This ensures consistent and accurate responses.

The following endpoints now support multichain queries:

• /tokens/erc20: Consolidates token balances across chains
• /events: Returns events from specified chains, preserving chain identification.
• /transactions: Provides transactions with proper error handling for invalid chain IDs.
• /query: Delivers raw query results with metadata for chain information.

Existing single-chain requests remain fully supported, ensuring no disruptions for current users.

curl -X GET "https://insight.thirdweb.com/v1/{clientId}/events/0x6e55472109e6abe4054a8e8b8d9edffcb31032c5/Transfer(address,address,uint256)?limit=100&chain=660279"

curl -X GET "https://insight.thirdweb.com/v1/{clientId}/events/0x6e55472109e6abe4054a8e8b8d9edffcb31032c5/Transfer(address,address,uint256)?limit=100&chain=1&chain=660279"

{
  "meta": {
    "chain_ids": [1, 660279],
    "total_items": 113,
    "limit_per_chain": 100,
    "...": "..."
  },
  "data": [
    {
      "chainId": 1,
      "...": "..."
    },
    {
      "chainId": 660279,
      "...": "..."
    }
  ]
}

This update lays the groundwork for future improvements on multichain queries via Insight API. As we continue to expand, our goal is to make working with multichain data as seamless and efficient as possible.

Start leveraging these improvements today to explore multichain insights more effectively!

We're excited to announce that thirdweb Insight has expanded its blockchain data querying capabilities with support for 43 chains, including these 15 new chains:

• Polygon mainnet
• Polygon Amoy testnet
• Optimism mainnet
• OP Sepolia testnet
• Celo mainnet
• Ancient8 mainnet
• Ancient8 testnet
• Plume mainnet
• Plume testnet
• Avalanche Fuji testnet
• Superposition testnet
• Etherlink testnet
• Mantle Sepolia testnet
• XAI testnet
• Lumia testnet

What This Means For Developers
With these additions, you can now use all of Insight's powerful features across these new chains:

• Query on-chain events with the Events Blueprint
• Track transactions with the Transactions Blueprint
• Monitor token balances (ERC-20, ERC-721, ERC-1155) with the Tokens Blueprint

For example, to query latest events on Optimism

const getLatestOptimismEvents = async () => {
 try {
   const response = await fetch(
      "https://10.insight.thirdweb.com/v1/events?sort_by=block_number&sort_order=desc",
      {
        headers: {
          "x-client-id": <your-client-id>,
        },
      },
    );
   const latestEvents = await response.json();
   return latestEvents;
 } catch (error) {
   console.error('Error:', error);
 }
};

View All Supported Chains
For a complete list of supported chains and their respective chain IDs, check the thirdweb chainlist.

We’re excited to share the latest updates to Nebula, bringing powerful new features, enhancements, and bug fixes to improve your development experience. This release focuses on expanding Nebula’s capabilities, making it even easier to deploy contracts, retrieve information, and interact seamlessly with the platform.

• Contract deployment support: Deploy thirdweb ERC-20 (Token), ERC-721 (NFT Collection), ERC-1155 (Edition), and Split contracts using Nebula via the chat interface or the API.
  • Prompt Nebula to prepare and execute contract deployments in natural language — example, “Deploy an ERC-20 contract named “Hello World” with description “Hello world token deployed with an AI” and symbol “HELLO”
  • More published contracts will be supported in upcoming releases. If you would like for your published contract to be enabled on Nebula, please contact us.
• Multi-message API: Enable multi-message on the /chat and /execute endpoints to allow multi-shot prompts that can be helpful to maintain and clarify context, and refine responses. The /chat and /execute endpoints accept:
  • message: string or
  • messages: [{ role: "user" | "assistant", content: string }]

• Comprehensive support for developers: Expanded resources and guidance to help developers effectively build web3 apps and games using thirdweb's extensive tooling and documentation.
  • "How do i transfer erc20 tokens in .NET?”
  • "How do i setup a session key in unity?”
• Build using Nebula and Eliza, a simple and lightweight framework for creating autonomous AI agents.
  • Eliza plugin is current available for testing out on dev and will be available on production soon. Start with https://github.com/elizaOS/eliza/tree/develop/packages/plugin-thirdweb

Nebula is currently in Alpha for a select number of developers. For access to the product, please sign up on the Nebula waitlist.

For any feedback or support inquiries, please visit our support site.

• Additions from Thirdweb's .NET SDK Release 2.14.0
• Additions from Thirdweb's .NET SDK Release 2.15.0
• Added AuthProvider.Backend's related walletSecret to In-App and Ecosystem Wallets' options. You can now create server side wallets!
• Split ThirdwebManager into ThirdwebManagerBase, ThirdwebManager (frontend), ThirdwebManagerServer (backend)
  • Adds ThirdwebManagerServer prefab, uses SecretKey instead of ClientId and BundleId.
  • Adds a lot of flexibility and extendability for various use cases.

var serverWalletOptions= new WalletOptions(
    provider: WalletProvider.InAppWallet,
    chainId: 421614,
    inAppWalletOptions: new InAppWalletOptions(authprovider: AuthProvider.Backend, walletSecret: "my-epic-secret")
);
var myAiWallet = await ThirdwebManagerServer.Instance.ConnectWallet(serverWalletOptions);

It's time to make blockchain-powered AI allies and opponents that leverage backend wallets and perhaps even Nebula.

.NET Releases | NuGet Release | Unity Release

Support | Docs

Engine v2.1.24 introduces sponsored transaction support for regular backend wallets, enabled on zkSync chains leveraging native account abstraction.

Added x-transaction-mode: sponsored header that enables sponsored transactions for regular backend wallets. This brings key benefits:

• No need to hold or manage gas tokens
• All gas costs are handled by thirdweb's paymaster
• Receive consolidated gas usage bills from thirdweb
• Compatible with local, AWS KMS, and GCP KMS wallets

To send sponsored transactions:

// Add this header with your regular backend wallet
x-transaction-mode: sponsored
x-backend-wallet-address: 0x...

The header:

• Works with regular backend wallets on supported chains
• Is ignored when used with Smart Backend Wallets (their transactions are already sponsored)
• Returns an error if used on currently unsupported chains

1. Update to Engine v2.1.24
2. Add the x-transaction-mode: sponsored header
3. Send transactions normally through your regular backend wallet

Contact support@thirdweb.com for any questions about implementing native AA support in your application.

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.

• Added DropER721_Burn, DropERC1155_BurnBatch, TokenERC721_Burn, TokenERC1155_Burn, TokenERC1155_BurnBatch contract extensions.
• Overriding default RPCs is now allowed through a new ThirdwebClient creation parameter rpcOverrides.

var client = ThirdwebClient.Create(
    clientId: "myepicclientid",
    bundleId: "my.bundle.id", // for native apps
    rpcOverrides: new()
    {
        { 1, "https://eth.llamarpc.com" },
        { 42161, "https://arbitrum.llamarpc.com" }
    }
);

• Removed some leftover unnecessary logging.

• Additions from Thirdweb's .NET SDK Release 2.13.0
• Exposed the ability to override RPC per chain ID in the ThirdwebManager.
• Exposed the ability to force specific wallet ids into your WalletConnect modal in the ThirdwebManager.
• Added hover tooltips for all ThirdwebManager options.

Flag under ThirdwebManager > Preferences.

If enabled, Thirdweb will automatically connect to the last connected wallet on initialization (this behavior does not apply to the WalletConnectWallet provider option).

If a wallet was connected as a non smart wallet, then later upgraded, the smart wallet is saved as the last wallet, and the next session will autoconnect to the smart wallet.

Any failure during this entire flow should not throw.

.NET Release | NuGet Release | Unity Releases

Support | Documentation

We are thrilled to announce support for backend wallets! This enhancement empowers developers to programmatically access wallets through their backend systems without needing to manage private keys directly. It simplifies wallet management while maintaining security and flexibility for various use cases.

Traditionally, managing wallets in decentralized applications often required dealing with private keys or relying on client-side solutions. However, there are scenarios where programmatic access to wallets on the backend is essential, such as:

• Server-side automation: Automating blockchain interactions for services like token minting, payments, or data signing.
• Enhanced security: Keeping private keys off the client side while enabling wallet operations.
• Custom integrations: Integrating wallets seamlessly with backend APIs for complex workflows.

With backend wallet support, developers can now securely and conveniently access wallets from their backend infrastructure.

The new feature allows you to create a wallet instance on the backend using the backend, here's how it's done with the typescript SDK:

import { inAppWallet } from "thirdweb/wallets";
 
const wallet = inAppWallet();
const account = await wallet.connect({
  strategy: "backend",
  client: createThirdwebClient({
    secretKey: "...", // Your backend client secret key
  }),
  walletSecret: "...", // Your unique wallet secret. Each secret corresponds to a single wallet
});
console.log("account.address", account.address);

Ready to explore backend wallet support? Try it out on all version of the thirdweb SDK from 5.83.0 onwards.

Features 🚀

We've added beta support for EIP-7702 authorization lists. You can now construct and send 7702 authorizations with the following functions:

• signAuthorization: Generate authorization signatures
• prepareTransaction: Added authorizationList parameter

import {
  signAuthorization,
  prepareTransaction,
  sendTransaction,
} from "thirdweb";
 
const authorization = await signAuthorization({
  request: {
    address: "0x...",
    chainId: 911867,
    nonce: 100n,
  },
  account: myAccount,
});
 
// Preparing a transaction with authorization
const transaction = prepareTransaction({
  chain: chain,
  client: client,
  value: 100n,
  to: recipient,
  authorizationList: [authorization],
});
 
// Sending the authorization transaction
const result = await sendTransaction({
  account,
  transaction,
});

Added deploySmartAccount function to explicitly deploy smart account contracts.

import { deploySmartAccount } from "thirdweb";
 
const account = await deploySmartAccount({
  smartAccount,
  chain,
  client,
  accountContract,
});

Improvements 🔧

Deployed smart accounts now use the legacy signature behavior (ERC-1271) rather than ERC-6492 pre-deploy signatures.

Features 🚀

We've added the getAdminAccount method to inAppWallet interfaces when using Account Abstraction (AA), including gasless ecosystem wallets. This addition allows developers to retrieve the admin account for AA-compatible in-app wallets.

// Initialize the in-app wallet with sponsored gas enabled
const wallet = inAppWallet({
  smartAccount: {
    chain: sepolia,
    sponsorGas: true,
  },
});
 
// Connect to the wallet using a specific client and strategy
const account = await wallet.connect({
  client, // Your defined client instance
  strategy: "google", // Specify your authentication strategy
});
 
// Retrieve the admin account
const adminAccount = await wallet.getAdminAccount();
 
// Log the admin account address
console.log("Admin Account Address:", adminAccount.address);

Improvements 🔧

We've added a new onClose callback option to Connect Details modal, providing developers with greater control over modal behavior and user interactions. The callback receives the last active screen name when the user closes the modal, enabling better UX flows and analytics.

<ConnectButton
  detailsModal={{
    onClose: (screen: string) => {
      console.log(`Modal closed while on screen: ${screen}`);
      // Handle post-close logic here
    },
  }}
/>;

We've also added an onTimeout callback in useAutoConnect hook to handle connection timeout scenarios gracefully. Timeouts can happen if the user has previously connected a wallet, but we're unable to reconnect to that wallet.

<AutoConnect
  onTimeout={() => {
    console.log("Auto connection timed out");
  }}
/>;

Bug Fixes 🐛

We fixed an issue where smart accounts could not execute transactions on chains besides the one they were initially created on. AA transactions on chains besides the initial one now deploy the smart account on the new chain before executing the transaction

// Configure the smart wallet
const wallet = smartWallet({
  chain: sepolia,
  sponsorGas: true,
});
 
// Connect the smart wallet
const smartAccount = await wallet.connect({
  client,
  personalAccount,
});
 
// Prepare a transaction on another chain
const transaction = prepareTransaction({
  value: 10000n,
  to: "0x..."
  chain: baseSepolia,
  client
});
 
// This will deploy the smart account on Base Sepolia
const result = await sendTransaction({
  account: smartAccount,
  transaction
});

Removals and Deprecations 🗑️

We've removed co.lobstr from the available wallets list as it is not EVM-compatible

Adds the ability to Unlink a LinkedAccount from your In-App or Ecosystem Wallet.

List<LinkedAccount> linkedAccounts = await inAppWallet.GetLinkedAccounts();
List<LinkedAccount> linkedAccountsAfterUnlinking = await inAppWallet.UnlinkAccount(linkedAccounts[0]);

Integrates authorizationList for any transactions.
This EIP essentially allows you to set code to an EOA, unlocking a world of possibilities to enhance their functionality.

The best way to understand it outside of reading the EIP is looking at the example below; to preface it: we sign an authorization using the wallet we want to set code to. Another wallet sends a transaction with said authorization passed in, essentially activating it. The authority wallet now has code set to it pointing to an (insecure) Delegation contract in this case, which allows any wallet to execute any call through it on behalf of the authority. In this example, we call the wallet executing both the authorization and the claim transaction afterwards, the exectuor.

An authority may execute its own authorization, the only difference is internal whereby the authorization nonce is incremented by 1.

// Chain and contract addresses
var chainWith7702 = 911867;
var erc20ContractAddress = "0xAA462a5BE0fc5214507FDB4fB2474a7d5c69065b"; // Fake ERC20
var delegationContractAddress = "0x654F42b74885EE6803F403f077bc0409f1066c58"; // BatchCallDelegation
// Initialize contracts normally
var erc20Contract = await ThirdwebContract.Create(client: client, address: erc20ContractAddress, chain: chainWith7702);
var delegationContract = await ThirdwebContract.Create(client: client, address: delegationContractAddress, chain: chainWith7702);
// Initialize a (to-be) 7702 EOA
var eoaWallet = await PrivateKeyWallet.Generate(client);
var eoaWalletAddress = await eoaWallet.GetAddress();
Console.WriteLine($"EOA address: {eoaWalletAddress}");
// Initialize another wallet, the "executor" that will hit the eoa's (to-be) execute function
var executorWallet = await PrivateKeyWallet.Generate(client);
var executorWalletAddress = await executorWallet.GetAddress();
Console.WriteLine($"Executor address: {executorWalletAddress}");
// Fund the executor wallet
var fundingWallet = await PrivateKeyWallet.Create(client, privateKey);
var fundingHash = (await fundingWallet.Transfer(chainWith7702, executorWalletAddress, BigInteger.Parse("0.001".ToWei()))).TransactionHash;
Console.WriteLine($"Funded Executor Wallet: {fundingHash}");
// Sign the authorization to make it point to the delegation contract
var authorization = await eoaWallet.SignAuthorization(chainId: chainWith7702, contractAddress: delegationContractAddress, willSelfExecute: false);
Console.WriteLine($"Authorization: {JsonConvert.SerializeObject(authorization, Formatting.Indented)}");
// Execute the delegation
var tx = await ThirdwebTransaction.Create(executorWallet, new ThirdwebTransactionInput(chainId: chainWith7702, to: executorWalletAddress, authorization: authorization));
var hash = (await ThirdwebTransaction.SendAndWaitForTransactionReceipt(tx)).TransactionHash;
Console.WriteLine($"Authorization execution transaction hash: {hash}");
// Prove that code has been deployed to the eoa
var rpc = ThirdwebRPC.GetRpcInstance(client, chainWith7702);
var code = await rpc.SendRequestAsync<string>("eth_getCode", eoaWalletAddress, "latest");
Console.WriteLine($"EOA code: {code}");
// Log erc20 balance of executor before the claim
var executorBalanceBefore = await erc20Contract.ERC20_BalanceOf(executorWalletAddress);
Console.WriteLine($"Executor balance before: {executorBalanceBefore}");
// Prepare the claim call
var claimCallData = erc20Contract.CreateCallData(
    "claim",
    new object[]
    {
        executorWalletAddress, // receiver
        100, // quantity
        Constants.NATIVE_TOKEN_ADDRESS, // currency
        0, // pricePerToken
        new object[] { Array.Empty<byte>(), BigInteger.Zero, BigInteger.Zero, Constants.ADDRESS_ZERO }, // allowlistProof
        Array.Empty<byte>() // data
    }
);
// Embed the claim call in the execute call
var executeCallData = delegationContract.CreateCallData(
    method: "execute",
    parameters: new object[]
    {
        new List<Thirdweb.Console.Call>
        {
            new()
            {
                Data = claimCallData.HexToBytes(),
                To = erc20ContractAddress,
                Value = BigInteger.Zero
            }
        }
    }
);
// Execute from the executor wallet targeting the eoa which is pointing to the delegation contract
var tx2 = await ThirdwebTransaction.Create(executorWallet, new ThirdwebTransactionInput(chainId: chainWith7702, to: eoaWalletAddress, data: executeCallData));
var hash2 = (await ThirdwebTransaction.SendAndWaitForTransactionReceipt(tx2)).TransactionHash;
Console.WriteLine($"Token claim transaction hash: {hash2}");
// Log erc20 balance of executor after the claim
var executorBalanceAfter = await erc20Contract.ERC20_BalanceOf(executorWalletAddress);
Console.WriteLine($"Executor balance after: {executorBalanceAfter}");

Note that for the time being this only works on 7702-enabled chains such as Odyssey and the feature has only been integrated with PrivateKeyWallet.

Adds the ability to retrieve auth provider specific user information from In-App and Ecosystem Wallets.

• SwitchNetwork is now part of the main IThirdwebWallet interface. Smart Wallets now attempt to switch the underlying admin network automatically as well.
• ERC721_TotalSupply extension now includes burned NFTs when using thirdweb contracts, allowing for ERC721_GetAll and ERC721_GetOwned functions to return said NFTs as well.
• Various new utilities for conversions and transaction decoding, including decoding authorizationList.

Full Changelog: https://github.com/thirdweb-dev/dotnet/compare/v2.11.1...v2.12.0

.NET Release | NuGet Release | Unity Release

Docs | Support

Christmas is around the corner and thirdweb wallets have some gifts for you!

If you're using the React UI components, you should now see the options to remove accounts that you might have linked by accident.

For users on typescript, this is also available as a function

const wallet = inAppWallet();
wallet.connect({ strategy: "google" });
 
const profiles = await getProfiles({
  client,
});
 
const updatedProfiles = await unlinkProfile({
  client,
  profileToUnlink: profiles[1], // assuming there is more than 1 profile linked to the user.
});

This give you more flexibility to manage users account and privacy!

Some of you have been asking for custom session tokens beyond the standard 7 days we have today and we hear you.

Starting today, you will be able to set customer session expiration if you're on custom auth endpoints on JWK.

Simply return a field exp corresponding to the Unix timestamp in seconds that you want to session token to expire.

//before 
{
  "userId": "..."
}
// after
{
  "userId": "..."
  "exp": 1735032658
}

Sign an exp field in the JWT payload that is signed by your server.

All these features are available today fromthirdweb@5.78.0 onwards. We have more things planned and look forward to seeing you again with more updates when the new year rolls around!

Merry Christmas and happy holidays!

We've made Engine even more reliable in v2.1.20. Here's a sample of nonce management improvements we made:

Transactions can be stuck in mempool for multiple reasons (usually chain-specific). We made improvements to more aggressively retry transactions through including:

• Retries with increasing gas (up to 10x gas).
• Retries after a fixed amount of time, even if the RPC blocks are delayed.
• Configuration to limit the max gas to spend on resends to stay within chain limits.
• Configuration to limit how long to retry a transaction for.

Engine resets the nonce when a wallet runs out of funds to ensure that after the wallet is funded, transactions are sent with correct nonces.

The Retry Failed Transactions now allows retrying any failed transactions including user operations.

Want to force a specific transaction to retry with the same nonce? Use the Retry Transaction (Synchronous) endpoint.

Advanced usage to manage wallet nonces

Most users should rely on Engine to manage and correct wallet nonces. If you want more direct control, the following endpoints allow you to directly manage Engine's wallet nonces. These endpoints are safe to run and intended to "fix" wallets that are stuck. Be warned they may cancel any pending transactions with those nonces.

The Reset Nonces endpoint was updated to optionally allow resetting the nonce state for a single wallet (by default it resets all wallets).

A new Cancel Nonces endpoint allows you to send null transactions with high gas to effectively "cancel" pending transactions using those nonces.

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!

We just released a new package that allows you to use thirdweb's in-app and smart wallets within you wagmi app with minimal effort. Few lines of code to add web2 sign in like google, discord, passkey, etc along with ERC-4337 smart accounts that unlock gasless transactions, batched transactions and session keys.

First, install the thirdweb and @thirdweb-dev/wagmi-adapter packages in your wagmi app.

npm install thirdweb @thirdweb-dev/wagmi-adapter

Make sure you're running wagmi 2.14.1 or above.

You probably already have a wagmi config with some connectors, simply add the inAppWalletConnector to the list, along with the desired options.

import { http, createConfig } from "wagmi";
import { inAppWalletConnector } from "@thirdweb-dev/wagmi-adapter";
import {
  createThirdwebClient,
  defineChain as thirdwebChain,
} from "thirdweb";
 
const client = createThirdwebClient({
  clientId: "your-client-id",
});
 
export const config = createConfig({
  chains: [sepolia],
  connectors: [
    // add the in-app wallet connector
    inAppWalletConnector({
      client,
      // optional: turn on smart accounts!
      smartAccounts: {
        sponsorGas: true,
        chain: thirdwebChain(sepolia),
      },
    }),
  ],
  transports: {
    [sepolia.id]: http(),
  },
});

Now you can connect users with the desired auth strategy. Options include email, phone, passkey, google, discord, x, telegram, github, and more.

const { connect, connectors } = useConnect();
 
const onClick = () => {
  // grab the connector
  const inAppWallet = connectors.find(
    (x) => x.id === "in-app-wallet",
  );
  // call connect with the desired strategy
  connect({
    connector: inAppWallet,
    strategy: "google",
  });
};

And that's it! The example above connects your users with their google account, creates an ERC4337 smart account with sponsored transactions that you can use with the rest of your wagmi app.

Happy building! 🛠️

We previously added unified identities to the thirdweb SDK, allowing users to link multiple profiles as valid authentication options within your app. However, you couldn't tell which provider they had signed in with for the current session. In thirdweb v5.77.0, we've added the getLastAuthProvider utility to the React module, allowing you to retrieve the most recently used provider from within any web context.

import { getLastAuthProvider } from "thirdweb/react";
 
getLastAuthProvider(); // "google"

• Fixed a caching issue in our new headless components

Users can now publish their contracts with contract references in deploy params.

What this means is, if there are address params in your contract's constructor, you can provide a reference to another published contract for those params. These reference contracts will then be deterministically deployed before deploying your contract.

You can specify these references in publish form as shown below:

For e.g., _owner param is of type address and allows publisher to specify a contract reference. You can do this by selecting Dynamic Input and providing details of the published contract. Please note that the contract being set as reference should be a published contract with default values pre-filled.

You can also setup a chain of such references, i.e. a referenced contract has another reference contract in its deploy params, and so on.

In addition to the address type, you can also provide dynamic inputs for bytes params. For e.g., if the bytes param is composed of address, uint256, and bool, you can specify these values instead of giving an encoded bytes value. These will be encoded during deployment. The address param within this bytes param can again be a dynamic reference. See below:

This feature works for address[] and bytes[] params too.

Engine is used by web2 and web3 companies for production use, powering 10M+ transactions per week. Making sure your Engine is secure and your funds are safe are critical, so here's security improvements we made (v2.1.20) and what's coming up.

We've completed our second code and infrastructure assessment from an independent third party auditor and will be sharing the report shortly.

No critical vulnerabilities were identified, and all reported issues were addressed.

• Improved CORS response handling. Clearer logs + responses if calls are made from invalid origins.
• Added modern browser security headers to restrict unused permissions (embedding, geolocation, camera, etc.).
• Updated dependencies to address publicly reported vulnerabilities.

• singlePhaseDrop added to all claim-to endpoints allowing users to set claim conditions and claim tokens in a single phase for custom drop contracts.
• gasPrice can now be overridden allowing users to explicitly set the gas price for pre-EIP1559 chains.
  • Post-EIP1559 chains should continue to use maxFeePerGas and maxPriorityFeePerGas overrides, if needed.

{
  // ...write request body
  txOverrides: {
    "gasPrice": "50000000000"            // pre-EIP1559
    // "maxFeePerGas": "50000000000"     // post-EIP1559
  }
}

• All /mint-to endpoints were updated to thirdweb v5 SDK and should have greatly improved response times.
• Idempotency keys up to 200 characters are now supported.
• The codebase is updated with better organization and code standards, and we're enforcing linting rules moving forward.

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!

A new version of Insight is released, focusing on bringing decoded data to the API and bug fixes to the indexing logic.

Decoding for events and transactions in the API

Implemented functionality to decode event logs (supporting both indexed and non-indexed parameters) and transaction inputs whenever a query is made with. partial ABI.

For example, let's say we want to query all allocated withdrawal function calls on the TheCompact contract (0x00000000000018DF021Ff2467dF97ff846E09f48).

The partial ABI of the function is ((bytes,uint256,uint256,uint256,uint256,address)), however the Insight API allows for named arguments, so we can use allocatedWithdrawal((bytes allocatorSignature,uint256 nonce,uint256 expires,uint256 id,uint256 amount,address recipient) _withdrawal)

We can do the following query to insight

curl 'https://1.insight.thirdweb.com/v1/:clientID/transactions/0x00000000000018DF021Ff2467dF97ff846E09f48/allocatedWithdrawal((bytes,uint256 nonce,uint256 expires,uint256 id,uint256 amount,address recipient) _withdrawal)'

and receive a response

{
    "meta": {
        "chain_id": 1,
        "address": "0x00000000000018DF021Ff2467dF97ff846E09f48",
        "signature": "0x27c777a9",
        "page": 0,
        "limit": 5,
        "total_items": 1,
        "total_pages": 0
    },
    "data": [
        {
            "chain_id": 1,
            "hash": "0x8cd2145f99f11885c4136330ad1bb77555504f58bede20fc1f32f1ba12adcb53",
            "nonce": 832,
            "block_hash": "0xe6053a9f4e9ee63b37f174ece3938a46e1dd782dfefc55316e770134bfc59d60",
            "block_number": 21131927,
            "block_timestamp": 1730936111,
            "transaction_index": 117,
            "from_address": "0x0734d56da60852a03e2aafae8a36ffd8c12b32f1",
            "to_address": "0x00000000000018df021ff2467df97ff846e09f48",
            "value": 0,
            "gas": 67401,
            "gas_price": 15172764689,
            "data": "0x27c777a9000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000007b00000000000000000000000000000000000000000000000000000000672c0c60302aafae8a36ffd8c12b32f1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000038d7ea4c680000000000000000000000000000734d56da60852a03e2aafae8a36ffd8c12b32f10000000000000000000000000000000000000000000000000000000000000000",
            "function_selector": "0x27c777a9",
            "max_fee_per_gas": 28932060124,
            "max_priority_fee_per_gas": 187296056,
            "transaction_type": 2,
            "r": 56974697277111379906610442563886472860956697825679089697101225017574199230150,
            "s": 41080792507018916056596496103695262958288003493025956403880548103799170703734,
            "v": 1,
            "access_list_json": "[]",
            "contract_address": null,
            "gas_used": null,
            "cumulative_gas_used": null,
            "effective_gas_price": null,
            "blob_gas_used": null,
            "blob_gas_price": null,
            "logs_bloom": null,
            "status": null,
            "decodedData": {
                "name": "allocatedWithdrawal",
                "signature": "allocatedWithdrawal((bytes,uint256,uint256,uint256,uint256,address))",
                "inputs": {
                    "_withdrawal": {
                        "allocatorSignature": "",
                        "nonce": 123,
                        "expires": 1730940000,
                        "id": 21786436819914608908212656341824591317420268878283544900672692017070052737024,
                        "amount": 1000000000000000,
                        "recipient": "0x0734d56da60852a03e2aafae8a36ffd8c12b32f1"
                    }
                }
            }
        }
    ]
}

The interesting part is the decodedData property, which contains the decoded function input arguments

"decodedData": {
                "name": "allocatedWithdrawal",
                "signature": "allocatedWithdrawal((bytes,uint256,uint256,uint256,uint256,address))",
                "inputs": {
                    "_withdrawal": {
                        "allocatorSignature": "",
                        "nonce": 123,
                        "expires": 1730940000,
                        "id": 21786436819914608908212656341824591317420268878283544900672692017070052737024,
                        "amount": 1000000000000000,
                        "recipient": "0x0734d56da60852a03e2aafae8a36ffd8c12b32f1"
                    }
                }
            }

• Poller gap filling uses configured poll range - Introduced a limit on polling missing blocks, based on `blocksPerPoll` configuration instead of the whole missing range.
• Fixed signature calculation for partial ABI - Fixed a bug where various uint types in the partial ABI resulted in an incorrect signature
• Fixed nullpointer exception when checking if polling limit is reached
• Clickhouse delete performance - Updated to use lightweight deletes instead when handling reorgs, to reduce load on the DB
  

Learn more about Insight and how to use it.
Insight is open source.

We've been iterating on our next generation smart accounts contracts. They are ERC-7579 compliant modular smart accounts, unlocking the growing catalog of account modules.

This is a BETA release, so expect some changes, but you can already start playing with it on both TypeScript and DotNet SDKs.

We have published 2 contracts to get you started, a modular account factory and a simple validator module.

A generic, un-opinionated smart account factory that lets you pick a smart account implementation and any default modules you like.

thirdweb: The complete web3 development platform

Build web3 apps easily with thirdweb’s powerful SDKs, audited smart contracts, and developer tools—for Ethereum & 700+ EVM chains. Try now.

thirdweb

A simple validator module, with multi owner and session key support.

thirdweb: The complete web3 development platform

Build web3 apps easily with thirdweb’s powerful SDKs, audited smart contracts, and developer tools—for Ethereum & 700+ EVM chains. Try now.

thirdweb

Once you have deployed both of those contracts, you can use them in the SDK to deploy accounts for you users, using the new Config smart account presets.

 import { sepolia } from "thirdweb/chains";
 import { smartWallet, Config } from "thirdweb/wallets/smart";
 
 const modularSmartWallet = smartWallet(
   Config.erc7579({
     chain: sepolia,
     sponsorGas: true,
     factoryAddress: "0x...", // the 7579 factory address
     validatorAddress: "0x...", // the default validator module address
   }),
 });

You now have a modular smart account wallet instance that you can use with the rest of the SDK as usual.

You can also pass this configuration to the Connect UI components:

<ConnectButton
  client={client}
  accountAbstraction={Config.erc7579({
    chain: sepolia,
    sponsorGas: true,
    factoryAddress: "0x...", // the 7579 factory address
    validatorAddress: "0x...", // the default validator module address
  })}
/>;

API and contracts are still in BETA - expect breaking changes and frequent updates.

Once stabilized, we will deploy a default factory and validator module on all chains which will be the default in the SDKs.

We're releasing this early so we can get some feedback from you, play with it on testnet and let us know what you think!

Happy building! 🛠️

We just added support for ERC-6492 signatures in the TypeScript and DotNet SDKs. This means that you can now sign and verify signatures for smart accounts even if they haven't been deployed yet!

If your app uses smart accounts and sign in with ethereum (SIWE), this massively improves the first time user flow. Users can simply proceed to the app: there's no wait for the account to be deployed.

It also reduces cost for app developers, since the cost of deploying smart accounts is incurred on the first transaction, rather than when signing in.

No code changes for this one, just make sure you use the latest version of the SDK on both the signing and the verifying side, or any 6492 compatible signature verification library.

Happy building! 🛠️

We've added new chains to the platform this week!

AppChain: RPC and Chain Settings

Use the best AppChain RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Metal L2: RPC and Chain Settings

Use the best Metal L2 RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Xsolla ZK Sepolia Testnet: RPC and Chain Settings

Use the best Xsolla ZK Sepolia Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Funki Sepolia Sandbox: RPC and Chain Settings

Use the best Funki Sepolia Sandbox RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Sanko: RPC and Chain Settings

Use the best Sanko RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

DOS Tesnet: RPC and Chain Settings

Use the best DOS Tesnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

DOS Chain: RPC and Chain Settings

Use the best DOS Chain RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

BOB: RPC and Chain Settings

Use the best BOB RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

BOB Sepolia: RPC and Chain Settings

Use the best BOB Sepolia RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Every chain comes out of the box with SDK support RPC, Engine and Account Abstraction capabilities. All you need is the chain id to get going.

const wallet = smartWallet({
  chain: defineChain(388), // just need the chainId!
  sponsorGas: true,
});

For testnets, you'll also find a faucet in each chain page.

Happy building! 🛠️

• Additions from Thirdweb's .NET SDK Release 2.11.0
  • SmartWallet.PersonalSign no longer requires the SmartWallet to be deployed, increasing speed. Verification is done through ERC-6492. Validating a signature also works with ERC-6492 signatures now. Useful for apps that want to instantly authenticate (using Thirdweb Auth - SIWE for example) without incurring costs.
  • purchaseData can now be passed to Thirdweb Pay quote params, making Direct Payment flows fully featured.
• InAppWalletOptions now extends EcosystemWalletOptions (no changes to dx).
• Slightly improved Playground UI.

.NET Release | NuGet Release | Unity Release

Docs | Support

Added the ability to pay for gas with ERC20 tokens when using Smart Wallet.

• Currently supports Base USDC, Celo CUSD, and Lisk LSK tokens.
• Simply select a TokenPaymaster when creating a SmartWallet and all transactions will be paid for with the corresponding ERC20 from the user's Smart Wallet.
• Useful on L2s where the native token is ETH and you want to enshrine another coin or onramp your users directly to that coin.
• These TokenPaymasters entirely operate onchain, leveraging popular DEXes and decentralized price feeds from Uniswap & Chainlink.
• This product is in beta, and only compatible with EntryPoint v0.7.0, which we auto select for you if not overriden when configurin your wallet.

Example:

import { base, lisk, celo } from "thirdweb/chains";
import { TokenPaymaster, smartWallet } from "thirdweb/wallets";
 
// Have users pay for gas in Base USDC
const usdcWallet = smartWallet({
  chain: base,
  sponsorGas: true,
  overrides: {
    tokenPaymaster: TokenPaymaster.BASE_USDC,
  },
});
 
// Have users pay for gas in Lisk LSK
const lskWallet = smartWallet({
  chain: lisk,
  sponsorGas: true,
  overrides: {
    tokenPaymaster: TokenPaymaster.LISK_LSK,
  },
});
 
// Have users pay for gas in Celo CUSD
const cusdWallet = smartWallet({
  chain: celo,
  sponsorGas: true,
  overrides: {
    tokenPaymaster: TokenPaymaster.CELO_CUSD,
  },
});

The latest update brings unparalleled marketplace integration to your fingertips! All 36 marketplace engine calls are now available in C++, Blueprints, and as async tasks, complete with supporting structs to streamline your workflow. Dive into enhanced examples, fetch IPFS nodes seamlessly, and enjoy compatibility with Unreal Engine 5.2 and 5.5 for even greater flexibility. We've cleaned up runtime settings, optimized dynamic tasks, and resolved key build errors to ensure a smooth development experience. Get ready to unlock the full potential of your marketplace projects with these powerful new tools!

• Bug Report and Feature Request Templates in Repo
• Missing C++ functions for exising engine calls
• All 36 marketplace engine calls in c++, Blueprints, and as async tasks with supporting structs
• Sign In With Ethereum and Link with SIWE
• Fetch IPFS nodes
• QR Code Generator for future use

• Unbind Route on destroy for Browser
• UE_5.2 compatibility for customer
• UE_5.5 compatibility
• Cleanup Runtime settings
• Cleanup duplicate async tasks for dynamic tasks
• Updated examples
• Updated Rust libs

• intrinsic build errors
• OAuthBrowserWidget Error being empty

• Moved BuildPlugin to its own repo

Marketplace | Documentation | Github Release

Since introducing Smart Backend Wallets we introduced some new capabilities to Engine and over a dozen bugfixes.

It is important to verify the signature header for Engine webhook calls to verify they came from your Engine. The dashboard now allows you to send a test payload to determine if your webhook endpoint is unreachable, not handling the webhook signature properly, or returning a unexpected response.

On the Webhooks dashboard page, select ... > Test webhook to send an example webhook payload to your backend and see the status code and response body.

You can now delete backend wallets directly from the dashboard. Keep your backend wallets list tidy by removing unused backend wallets.

Engine now estimates the required amount of gas when it attempts to send a transaction without sufficient gas funds:

Insufficient funds in 0x4Ff9aa707AE1eAeb40E581DF2cf4e14AffcC553d on Polygon Mainnet. Transaction requires > 0.000682043142837 POL.

Lastly we've been squashing bugs to ensure your Engine handles transactions as reliably as possible.

• Fixed Contract Subscriptions to support all chain IDs (previous large chain IDs like Xai Sepolia were unsupported).
• Updated dependency libraries to address reported vulnerabilities.
• Fixed malformed transactions causing the transactions to not load in the dashboard.
• Fixed an edge case where errors for read contract calls were dropped.
• Fixed an edge case in nonce self-healing.
• Fixed Smart Backend Wallet support for certain extension endpoints.
• Handled a different RPC response that could cause a nonce to be skipped.
• See Engine release notes for more details.

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!

The Engine dashboard now shows all recent versions with timestamps and allows you to select any version to upgrade or downgrade to.

Find the improved version selector in the upper right corner of the Engine dashboard.

While Engine releases follows semantic versioning, non-major updates may add input validation or fix an incorrect response (e.g. a 500 that should have been a 400 response). These fixes correct behavior, but in rare cases this may conflict with how your backend sends or parses requests. In these cases, you can now self-service downgrade to a previous Engine version.

Example: Engine used to rely on an older SDK that did not strictly enforce ABIs. In a newer update, provided ABIs must match the proper spec. This may cause write calls that provided an incomplete ABI to start throwing an error.

We're aiming to provide visibility in the dashboard when Engine versions change shortly. We also plan to roll out a predictable schedule when cloud-hosted Engines may receive critical security or reliability updates.

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!

• Added AuthProvider.Steam as a login option for In-App or Ecosystem Wallets.

// Using .NET SDK
var steamWallet = await InAppWallet.Create(client: client, authProvider: AuthProvider.Steam);
if (!await steamWallet.IsConnected())
{
    _ = await steamWallet.LoginWithOauth(...);
}
var steamWalletAddy = await steamWallet.GetAddress();
// Using Unity SDK
var steamWalletOptions = new WalletOptions(
    provider: WalletProvider.InAppWallet, 
    chainId: 1, 
    inAppWalletOptions: new InAppWalletOptions(authprovider: AuthProvider.Steam);
);
var steamWallet = await ThirdwebManager.Instance.ConnectWallet(options);
var steamWalletAddy = await steamWallet.GetAddress();

• Added the ability to pay for gas with ERC20 tokens when using Smart Wallet.
  • Currently supports Base USDC, Celo CUSD, and Lisk LSK tokens.
  • Simply select a TokenPaymaster when creating a SmartWallet and all transactions will be paid for with the corresponding ERC20 from the user's Smart Wallet.
  • Useful on L2s where the native token is ETH and you want to enshrine another coin or onramp your users directly to that coin.
  • These TokenPaymasters entirely operate onchain, leveraging popular DEXes and decentralized price feeds from Uniswap & Chainlink.
  • This product is in beta, and only compatible with EntryPoint v0.7.0, which we auto select for you if not overriden when configurin your wallet.

// Example of paying for a transaction ERC20 stablecoins instead of native ETH
// Using .NET SDK (Lisk LSK)
var chainId = 1135; // lisk
var erc20SmartWallet = await SmartWallet.Create(
  personalWallet: privateKeyWallet, 
  chainId: chainId, 
  tokenPaymaster: TokenPaymaster.LISK_LSK
);
// Using Unity SDK (Base USDC)
var chainId = 8453; // base
var erc20SmartWallet = await ConnectWallet(
    new WalletOptions(
        WalletProvider.InAppWallet,
        chainId,
        inAppWalletOptions: new InAppWalletOptions(authprovider: AuthProvider.Steam),
        smartWalletOptions: new SmartWalletOptions(sponsorGas: true, tokenPaymaster: TokenPaymaster.BASE_USDC)
    )
);
// Then just trigger any transaction!
var erc20SmartWalletAddress = await erc20SmartWallet.GetAddress();
Debug.Log($"ERC20 Smart Wallet address: {erc20SmartWalletAddress}");
var receipt = await erc20SmartWallet.Transfer(chainId: chainId, toAddress: erc20SmartWalletAddress, weiAmount: 0);
Debug.Log($"Receipt: {JsonConvert.SerializeObject(receipt, Formatting.Indented)}");

.NET Release | NuGet Release | Unity Release

Docs | Support

We supported pregeneration for enclave wallets a while back.

Today, wallet pregeneration is available for in-app wallets too!

What does this mean?

This means that you can now know the in-app wallet address of a user before they register on your platform!

This allows you to perform airdrop, pre-load certain assets, and more!

The API is the same as ecosystem wallets except we don't have to include the ecosystem details:

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

On top of that, we also now support pregeneration via custom IDs. This means that you can know your user's address ahead of time even if you use a custom authentication methods like JWT or an auth endpoint.

Here's what that would look like:

curl -X POST 'https://embedded-wallet.thirdweb.com/api/v1/pregenerate' \
  -H 'x-secret-key: YOUR_SECRET_KEY_HERE' \
  -H 'Content-Type: application/json' \
  -d '{
    "strategy": "userId",
    "userId": "YOUR_CUSTOM_USER_ID_HRE"
  }'

For more information and background on what pregeneration is all about, check out the newly updated documentation here.

We're excited to announce that thirdweb Insight has expanded its blockchain data querying capabilities with support for six new chains:

• Donatuz
• Avalanche
• Soneium Minato
• Fhenix- Helium
• Ape Chain

What This Means For Developers
With these additions, you can now use all of Insight's powerful features across these new chains:

• Query on-chain events with the Events Blueprint
• Track transactions with the Transactions Blueprint
• Monitor token balances (ERC-20, ERC-721, ERC-1155) with the Tokens Blueprint

https://<chain-id>.insight.thirdweb.com

For example, to query Avalanche data:

const getAvaxTransfers = async () => {
  try {
    const response = await fetch(
      "https://43114.insight.thirdweb.com/v1/<client-id>/transactions/<wallet-address>",
    );
    const walletTransactionsInfo = await response.json();
    return walletTransactionsInfo;
  } catch (error) {
    console.error("Error:", error);
  }
};

Use Cases
These new chain additions enable various use cases across different sectors:

• DeFi
  • Track token movements and trading volume across new DeFi ecosystems
  • Monitor liquidity pools and DEX activity
  • Analyze cross-chain token economics
• Gaming
  • Track in-game assets and NFTs on gaming-focused chains
• Monitor player rewards and achievements
• Analyze gaming economy metrics
• NFTs
  • Track NFT collections and transfers across new marketplaces
  • Monitor NFT trading activity and ownership
  • Analyze collection performance metrics

View All Supported Chains
For a complete list of supported chains and their respective chain IDs, check the thirdweb chainlist.

As of v5.69.0, we've added Steam as an authentication option in our TypeScript SDK for all the games and game enjoyooors out there. You can setup Steam auth just like any other authentication method.

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