We're creating the next evolution of thirdweb Pay with Universal Bridge.

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