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

Etherlink: RPC and Chain Settings

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

Etherlink Testnet: RPC and Chain Settings

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

Lisk: RPC and Chain Settings

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

ZERO: RPC and Chain Settings

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

Cronos zkEVM Testnet: RPC and Chain Settings

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

Cronos zkEVM: RPC and Chain Settings

Use the best Cronos zkEVM 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! 🛠️

• Fixed an issue with typed data signing using In-App/Ecosystem Wallets when one of the fields was larger than Uint32.
• Improved NFT Metadata Population & Added Filters
  • The ERC1155_GetOwnedNFTs extension now returns the QuantityOwned metadata field correctly for each NFT.
  • The ERC721_GetNFT and ERC721_GetAllNFTs extensions can now take in a new fillOwner parameter that defaults to true and decides whether to make additional requests to populate the Owner field of the metadata, otherwise defaulting to Constants.ADDRESS_ZERO.
  • The ERC1155_GetNFT and ERC1155_GetAllNFTs extensions can now take in a new fillSupply parameter that defaults to true and decides whether to make additional requests to populate the Supply field of the metadata, otherwise defaulting to BigInteger.MinusOne.

.NET Release | NuGet Release | Unity Release

Docs | Support

With the introduction of modular contracts, we are improving the contract management experience on our dashboard to accompany this new development paradigm.

A modular contract has a core contract and module contracts that compose the entire modular contract. With this development in mind, we want to encourage users to add and remove modules with direct support on dashboard.

The following pre-built modules now have special component support on dashboard to enable users to interact with these modules without depending on the Contract Explorer or SDK.

• Transferable
• Royalty
• OpenEdition
• BatchMetadata

To check out these changes, deploy a modular contract on dashboard or view your existing contracts with the aforementioned modules installed.

More module UIs will be released in the coming weeks for the remaining modules- stay tuned. We'd love to hear your feedback on these new changes!

We've made yet another improvement to our dashboard analytics, adding both a project and team-based analytics overview page. Now, you can browse analytics for:

• Weekly and daily active Users
• All-time users
• New users by week or day
• Returning users by week or day
• Distribution of wallets connected
• Total wallets connected
• Distribution of in-app wallet sign-in methods
• Total in-app wallet logins
• Total gas sponsored for your users over time
• ...and more

But there's a catch! You can't see these analytics until you've connected the thirdweb SDK to your app. So start building and your charts can look as amazing as these. 🫡

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

Metis Sepolia Testnet: RPC and Chain Settings

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

Metis Andromeda: RPC and Chain Settings

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

Donatuz Testnet: RPC and Chain Settings

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

ZERO Testnet (Sepolia): RPC and Chain Settings

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

Blast: RPC and Chain Settings

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

Pivotal Sepolia: RPC and Chain Settings

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

Skopje Testnet: RPC and Chain Settings

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

GPT: RPC and Chain Settings

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

Superseed: RPC and Chain Settings

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

Geist: RPC and Chain Settings

Use the best Geist 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(59902), // just need the chainId!
  sponsorGas: true,
});

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

Happy building! 🛠️

We've previously sped up in app wallet authentication.

Today, we've dramatically improved our in-app wallet generation speeds. It's now around 40% faster!

In app wallets now get to benefit from the updated security model that ecosystem wallets enjoy.

In particular, we've moved to an enclave model allowing for verifiable code execution. This way, you'll know exactly what the private keys are being used for at all times.

This sets us up to use in app wallets in places where we couldn't before. Think CLIs, backend float wallets, etc.

Migration for existing users on the sharded model happens automatically and requires no work on your end.

We've written a more in depth security overview of the new model here.

To enjoy all the latest goodies, simply update to the latest thirdweb SDK version 5.67.0!

We are introducing a massive change to thirdweb dashboard with a focus on Teams and Projects

By default all your API keys are converted to projects under a single team as shown below

You can click on your project to view analytics, configure thirdweb services and manage settings.

You can quickly switch between teams and projects directly from dashboard header

Manage your team's general settings, team members, billing, gas credits and notification alerts in team settings dashboard

We now have an entire dashboard dedicated to Account management. You can manage your teams, view all your contracts and manage authorized devices.

• Create multiple teams
• Invite and manage team members
• Account settings
• Link Engines and Contracts with Projects
• Link Projects to Ecosystems

• Having an incorrect or slightly off system time would produce errors when logging in with In-App Wallets in some cases, we have added a fallback in this scenario that will work around this issue.
• IThirdwebWallet.Transfer now has an optional tokenAddress override to transfer ERC20 tokens using said function; this is an alternative to ThirdwebContract.ERC20_Transfer.
• ERC1155 transfer-related functions' data bytes parameter has now been made optional.
• The inability to fetch NFTMetadata when calling an NFT-related method no longer throws, and instead returns NFTMetadata with a description containing the error message.
• Enables custom implementation for OTP Verification Modal by @Vingator in https://github.com/thirdweb-dev/unity-sdk/pull/218
  • Introduces abstract OTP verification modal so you can customize it more easily.
  • Shared by In-App and Ecosystem Wallets.

.NET Release | NuGet Release | Unity Release

Docs | Support

Exciting new tools and refinements are here with the latest release! Track transactions effortlessly with new nodes for status and receipts, and take advantage of the Blueprint Screenshot Debug feature added directly to your Editor Toolbar. We’ve enhanced security by masking sensitive logs and streamlined configuration with a global PartnerID setting. Plus, enjoy smoother Android authentication and cleaner session key creation. These updates make for a more secure and streamlined experience, so dive in and explore what's new!

• Get Transaction Status node
• Get Transaction Receipt nodes
• Add Blueprint Screenshot Debug Functionality to Editor Toolbar as Button

• Mask sensitive strings in logging
• Migrate PartnerID to global configuration, removing from all nodes

• Use JSI-bound custom tabs to fix android external auth
• Formatting string on Read Contract

• Reduce inputs on CreateSessionKey
• Per node PartnerID

Marketplace | Documentation | Github Release

• In-App Wallets now use the same infrastructure as Ecosystem Wallets.
  • Up to 90% performance increase, specially on lower end devices or web platforms.
  • Much less cryptography done client side, using secure enclaves over shamir's secret sharing.
  • If you were using In-App Wallets previously, they will be automatically migrated to the new infrastructure upon first login.
    • If you were using custom auth with In-App Wallets before this release, you may pass your legacy encryption key during the creation of your wallet - it will be used to migrate your wallets to the new infrastructure upon first login.
    • Encryption keys are no longer required for In-App Wallets when logging in with JWT (OIDC Compatible Custom Auth) or AuthEndpoint (Generic Custom Auth).
• Added GetUserDetails method to In-App/Ecosystem Wallets that returns more information about your logged in user.
  • GetEmail and GetPhoneNumber have been deprecated in favor of GetUserDetails
• Added GetEcosystemDetails method to return general information about your Ecosystem Wallet, can be used for dynamic branding, etc.
• Fixes TokenERC721_MintTo functions failing with invalid signature; the token id parameter has also been removed.

.NET Release | NuGet Release | Unity Release

Docs | Support

Engine v2.1.0 introduces Smart Backend Wallets, powered by account abstraction. Key benefits include:

• No more gas management
• No need to hold crypto
• Fewer stuck transactions
• Backward-compatible interface
• One-step setup

Smart backend wallets send all transactions as user operations from a smart wallet using thirdweb's paymaster. Your wallets no longer need to hold or top-up gas funds, and thirdweb sends you a bill for your gas used.

No more top-ups also means your business no longer needs to hold crypto. This is great news for any business that must avoid holding cryptocurrency tokens for regulatory or financial reasons.

Use a smart backend wallet with an AWS KMS or GCP KMS wallet for enterprise-grade security for the signer.

While Engine v2 processes transactions very fast, some chains or nodes may throttle transactions submitted from a single backend wallet. Smart backend wallets circumvent this limitation because transactions (or "user operations") are sent from a large fleet of bundler wallet addresses.

Smart backend wallets behave like existing (EOA) backend wallets. Simply update your app's x-backend-wallet-address header with the smart backend wallet address. All of Engine's endpoints are supported.

Engine creates an EOA signer wallet and deploys a smart account using thirdweb's battle-tested account factory, or your own.

The EOA signer wallet may be a local wallet, AWS KMS, or GCP KMS. You don't need to keep track of this wallet, Engine manages it behind the scenes.

The thirdweb account that deployed Engine (cloud-hosted) or tied to the thirdweb secret key (self-hosted) will be billed for gas usage. A valid payment method must be on file to send transactions on mainnet chains.

Smart backend wallets are enabled on all Engine tiers (Standard, Premium, Enterprise, and self-hosted) for no added cost.

User operations on testnet are free, and thirdweb charges a 10% fee for gas used on mainnet chains. See Pricing for more details.

See the list of chains that support account abstraction on thirdweb. Don't see your chain? Reach out to us!

The existing Create Backend Wallet endpoint now supports new types: smart:local, smart:aws-kms, and smart:gcp-kms:

POST /backend-wallet/create
{
    "type": "smart:local"  // or smart:aws-kms, smart:gcp-kms
}

(Dashboard support coming soon.)

Now provide the backend wallet address to any Engine API that accepts a backend wallet to start using it. We can't wait to see what you build with these new capabilities!

This update represents a major step forward in making web3 infrastructure more accessible and manageable for teams. Whether you're building a game, marketplace, or DeFi app, smart backend wallets provide the foundation for scalable, secure, and efficient blockchain operations.

The benefits mentioned above address the top pain points we heard from customers, and we believe account abstraction-based wallets are the ideal solution.

Account abstraction is complex, but thirdweb (Engine, SDK, infrastructure, contracts) handles the full stack:

• Manage smart accounts
  • Deploy and manage smart account factory contracts
  • Initialize EntryPoint contract connections
  • Handle complex account deployment logic
  • Manage deterministic address computation
• Send user operations
  • Build UserOperation
  • Calculate gas parameters (verification gas, pre-verification gas)
  • Handle signature schemes and validation
  • Manage nonces across operations
• Bundler infrastructure
  • Run or connect to ERC-4337 bundlers
  • Handle bundler connections and failovers
  • Monitor bundle status and handle failures
  • Manage complex retry mechanisms
• Gas management
  • Maintain gas balance
  • Alert and top-up wallets
  • Handle gas price fluctuations
  • Manage paymaster integrations

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 are excited to announce the release of Insight v0.0.6-beta! This version brings significant improvements to enhance your blockchain data analysis experience.

You can now perform aggregate functions and use GROUP BY clauses in your queries. This enhancement allows for more sophisticated data analysis, enabling you to summarise and categorise blockchain data effectively.

We've added the ability to look up transactions based on their function signatures. This feature simplifies filtering and analysing transactions that invoke specific smart contract functions.

• Fixed an issue where bytes were incorrectly truncated from non-address topics and ensured proper handling of empty topics.

• Strip and normalise Solidity function and event signatures for consistent querying.
• Added options for Clickhouse TLS and API basic authentication to enhance security.
• Implemented a whitelist for allowed Clickhouse functions to control query executions.
• Updated Docker image tagging in the release workflow for streamlined deployments.

Minor Insight v0.0.5-beta has been released previously without receiving its own changelog, and here are the main takes from it:

• Added Clickhouse and poller settings for better configuration management.
• Implemented skipping of unmerged blocks in the reorg handler to enhance stability.
• Skipped duplicate blocks in the committer to prevent redundant data processing.
• Introduced missing block polling in the gap handler and committer to ensure data completeness.

If you encounter any issues or have suggestions, please feel free to open an issue in our GitHub repository.

Your project's dashboard just became more useful with a new set of metrics to track the growth of your apps!

Login to your account, select your project and head over to the Connect tab to see an overview of your aggregated metrics for connections, in-app wallets, account abstraction and pay. You can also dive deeper into each individual section for more detailed metrics.

This is just scratching the surface of all the insights Connect can give you about how your app is performing. Keep an eye out on your dashboards for more stats and metrics.

Happy Building! 🛠️

Our latest release introduces even more control and functionality to your workflow! With new raw contract read/write capabilities, enhanced mobile URL redirects, and automated deeplink registration on Android, you’re set up for seamless integration. Improved organization and logging, situationally-enforced external OAuth for added compatibility, and optimized async task handling all work together to keep your development smooth and efficient. Dive in to experience these enhancements and fine-tune your projects like never before!

• Generic Raw Read/Write Contract via Engine
• Mobile AppURL redirect override
• Engine Base URL + Access Token added to settings
• Automatic Deeplink registration on android devices

• GetLinkedAccounts automatically converted to data struct
• Rust Core updated
• Async Tasks grouped into folder structure
• Imports cleaned up
• Logging cleaned up to Verbose/VeryVerbose
• Enforced external auth for some OAuth providers
• .h/.cpp split out for some files
• Async Tasks now check for game thread and use weakThis refs

Marketplace | Documentation | Github Release

We just released a new version of the thirdweb Connect SDK which comes with a refreshed prebuilt UI components for executing transactions, onramping, bridging and swapping any token.

The new UI brings a simpler onramping flow showing you all your available balances up front, easy way to pay with another wallet and with a credit card.

We also upgraded the transaction flow to make it clearer for when your users don't hold enough funds in their wallets to complete a transaction.

Try it out live on the playground: https://playground.thirdweb.com/connect/pay

Happy building! 🛠️

• Upgraded base project/examples to Unity 6 and Playground from In-App to Ecosystem Wallet.
  • Much faster on platforms like WebGL and lower end devices.
  • Ecosystem Wallets are shareable with third parties.
• Added a link.xml to cover Thirdweb's .NET Core assemblies. Minimal stripping is no longer a hard requirement unless using WalletConnect as one of your wallet provider options.
• Updated base project Android settings to target Min API 34 to match latest store policies.
• Upgraded EDM4U (External Dependency Manager) - contains various improvements.

Unity Release | Docs

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

Immutable zkEVM: RPC and Chain Settings

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

Immutable zkEVM Testnet: RPC and Chain Settings

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

Ozean: RPC and Chain Settings

Use the best Ozean 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(13473), // just need the chainId!
  sponsorGas: true,
});

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

Happy building! 🛠️

• Added AuthProvider.Twitch as a new auth provider option for logging in with In-App or Ecosystem Wallets.
• Upgrading an EcosystemWallet to a SmartWallet without passing optional parameters will now attempt to use defaults from your dashboard Account Abstraction settings if any.
  • Create a SmartWallet with an EcosystemWallet as a signer and no additional conflicting overrides to make use of this feature.
  • Explicitly passed SDK overrides will always take priority over dashboard options.
  • If dashboard options are unavailable/unset, we revert to previous default values for gas sponsorship and account factories.

This comes after a couple patches worth noting:

• Added AuthProvider.Github as a new auth provider option for logging in with In-App or Ecosystem Wallets.
• MetaMaskWallet: GetAddress now enforces returning correctly checksummed address.
• WalletConnectWallet: Closing the modal now throws and interrupts the connection process properly.
• WalletConnect and MetaMask wallet providers now hexify messages passed to IThirdwebWallet.PersonalSign before signing.
  • If you were signing a hash or a string starting with 0x before, nothing changes.
  • If you were signing a raw message like "Hello World" UTF8 String, we'd hexify it before sending it over to the wallet.
  • This fixes display issues on the latest version of MetaMask (specially mobile) which no longer supports plain text parameters for personal_sign.
• Removes latest parameter from eth_estimateGas being used in ThirdwebTransaction.EstimateGasLimit on non-zk chains and methods that use it by extension, fixing issues on chains that do not support that parameter such as Binance Testnet.
• When using WalletConnect, attempts to fetch current active chain if applicable by corresponding wallet and avoid the additional requests to ensure correct network upon connection if unnecessary.

.NET Release | Nuget Release | Unity Release

Docs | Support

We just released an update for ecosystem owners. You can now setup custom authentication, and enable smart account options right from the dashboard.

When enabling account abstraction options, ecosystem wallets will automatically be converted to smart accounts without any code change, allowing for sponsored transactions, session keys, batched transactions and more. Make sure to use the latest version of the SDK.

Custom authentication allows to specify your own endpoint to handle auth verification yourself, opening up for any authentication you can think of.

Let us know what you think!

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

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

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

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

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

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

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(4801), // just need the chainId!
  sponsorGas: true,
});

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

Happy building! 🛠️

• Introduced a fromBlock configuration option for the committer, allowing users to specify a custom starting block. This enhancement provides flexibility in data processing by starting committing from a specific block height.
• Added support for eth_getBlockReceipts RPC method, enhancing transaction data storage and providing additional transaction fields like contract_address, gas_used, and status. The configuration now supports enabling block receipts, improving data collection efficiency.

• Improved poller initialization with enhanced handling of ForceFromBlock configuration.
• Updated storage interfaces to include a range start parameter for precise block range handling, with adjustments made to ClickHouse, memory storage, and mock storage implementations.
• Optimized ClickHouse table schemas for better query performance. Changes include ordering by block number and introducing a function_selector column in the transactions table, along with indexing every log topic to facilitate query-based filtering.
• Removed the FINAL keyword from ClickHouse queries where it was deemed unnecessary.

Learn more about Insight at https://github.com/thirdweb-dev/insight

We've added Twitch as an authentication strategy for all in-app and ecosystem wallets with thirdweb SDK v5.63.0.

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

Include Twitch in the <ConnectButton /> like any other strategy.

<ConnectButton
  client={client}
  wallets={[
    inAppWallet({
      auth: {
        options: ["twitch", "google", "telegram"],
      },
    }),
  ]}
/>;

• Treasure Topaz has been added to the support ZK chains
• Storage improvements for PWA reliability

Say hello to seamless wallet linking and streamlined development with our latest release! We've consolidated key functionality for wallet creation, sign-ins, and message signing, making it easier than ever to build with dynamic K2Nodes. With enhanced asynchronous task handling and updated examples to match the new blueprint nodes, you’ll experience a smoother, more efficient workflow. Plus, we’ve cleaned up unused code, ensuring a leaner and more optimized system for your projects. Dive in and explore the new possibilities!

• Ecosystem Wallet Linking
• Dynamic K2Nodes to consolidate functionality for Creating Wallets, Signing in, and signing messages
• AsyncTaskThirdweb{Purpose}Base files to standardize code
• K2Node_ThirdwebBase to standardize K2Node creation
• Static CountryCode convenience definitions for Phone OTP
• ThirdwebUncookedOnly module to house all K2Node related code

• Examples updated to match changed blueprint nodes
• All networked C++ Functions migrated to UE::Tasks threads with delegate return types
• All Blueprint functions mapped to now-delegate C++ functions converted to AsyncTasks

• EThirdwebAuthenticationMethod dangling unused enum

Marketplace | Documentation | Github Release

We're excited to announce a significant performance upgrade to thirdweb Engine's AWS and GCP Key Management Service (KMS) support. Engine v2.0.22 dramatically improves transaction processing speed and simplifies KMS workflow.

• Massive performance boost: transaction sending time reduced from 5+ minutes (for very high volumes) to sub-seconds
• Internally we removed an ethers dependency, in favour of a native integration with the v5 thirdweb SDK for improved efficiency

• Use multiple wallet types simultaneously within the same Engine instance
• Create different wallet types using the new type parameter in the create backend wallet endpoint

• Simplified import endpoint for AWS KMS
• Only ARN (Amazon Resource Name) required; keyId no longer necessary

• Override global KMS credentials on a per-key basis
• Optionally specify credentials when importing wallets for granular security management

• Lightning-Fast Transactions: Send KMS transactions in seconds instead of minutes regardless of volume, allowing for more responsive dApps.
• Simplified Workflow: Easier setup and management of KMS wallets within Engine.
• Enhanced Flexibility: Multi-wallet support and fine-grained credential control offer more options for managing your blockchain operations.
• Improved Scalability: Handle higher transaction volumes with ease, perfect for high-traffic dApps.

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.

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!

Engine has been updated to v2.0.25 which brings a handful of improvements.

First what is an account salt? The account salt is a unique ID that deterministically predicts a wallet address for a given admin + smart account factory.

This means your backend can provide a unique ID (like your dApp's user ID) as an account salt to Engine, and Engine will consistently reference and/or deploy the same smart account address each time (for the same admin + factory).

Here's an example:

My game has user IDs uid1, uid2, and uid3.

When a user signs up, the user's smart account calls my game contract.

Steps without account salt
1. User signs up.
2. Backend calls Engine to create a smart account.
3. Backend waits for the transaction to be mined.
4. Backend calls Engine with x-account-address: <address from step 2> to call the contract on behalf of the account.

Steps with account salt
1. User signs up.
2. Backend calls Engine with x-account-salt: uid1 to call the contract on behalf of the account.

💡 Bonus: The account is not deployed until a write transaction, deferring gas fees until the account is actually used!

The following endpoints now accept the x-account-salt header (more to come!):

• /contract/:chain/:contractAddress/write
• /contract/:chain/:contractAddress/erc20/claim-to
• /contract/:chain/:contractAddress/erc721/claim-to
• /contract/:chain/:contractAddress/erc1155/claim-to

To deploy a smart account from the account salt, call Create Smart Account and set the extraData arg to the salt.

To predict a smart account address from the account salt without deploying it, call Predict Address and set the extraData arg to the salt.

Our API reference page has moved! 👉 engine-api.thirdweb.com

This new API reference docs make it easier to search for endpoints (try CTRL/⌘+K), see path/query/body params, and view sample code.

You can even test requests right in the API docs page! Select Test Request and provide the following details:

The Send Retry (Synchronous) endpoint now allows retrying any transaction that was sent (either still waiting to be mined or "timed out"). This commonly occurs when a transaction is stuck because of gas spikes or other network congestion.

If a transaction appears stuck, try to resend with aggressive (3-10x) gas fees:

await fetch('https://<YOUR_ENGINE_URL>/transaction/sync-retry', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: 'Bearer <YOUR_SECRET_TOKEN>'
  },
  body: JSON.stringify({
    queueId: '9eb88b00-f04f-409b-9df7-7dcc9003bc35',
    maxFeePerGas: '500000000000', // 500 gwei
    maxPriorityFeePerGas: '100000000000', // 100 gwei
  })
})

• Fixed issue signing messages with Google Cloud KMS and AWS KMS wallets.
• Fixed import of Google Cloud KMS wallets. (Thanks @yukia3e !)
• Fixed 500 response when using an unrecognized backend wallet.
• Updated userOp code to the latest thirdweb SDK -> simpler code and performance optimizations.
• Fix nonce resync worker exiting early when there are multiple wallets sending transactions concurrently.
• Handle errors of different types better to avoid "empty" error messages.
• Fallback if the contract write call is provided an incomplete ABI (missing inputs or outputs fields).
• Updated log lines to be single-line for improved debuggability.
• Added lots of new route tests around signMessage, contract write, and userOps.

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!

Version v0.0.3-beta focuses on data accuracy by introducing handling for reorgs. Other changes include refactoring the RPC component for easier reuse, creating a test setup with initial tests and improving the setup for running Insight locally.

• Reorganization Handling and Storage Enhancements
  • Introduced a new `ReorgHandler` component to detect and handle blockchain reorganizations, with updated metrics to track performance.
  • Added storage support for chain reorganization
  • Configurable reorg handler settings to manage detection intervals and block scans.
• Refactored RPC Client and Modularity Improvements
  • Created an `IRPCClient` interface for better abstraction and testability of the RPC client.
  • Refactored RPC-related functionality into a dedicated `rpc` package to improve code structure and performance.
  • Updated orchestrator components to utilize the enhanced RPC client setup.
  • Simplified RPC interactions with utility functions for data serialization.
• Data Insertion Refactoring
  • Overhauled data insertion logic in the storage layer for configurable batching strategy, enhancing transaction handling across different storage systems.
  • Introduced `InsertDataForBlocks` method in storage interfaces, streamlining data insertion processes.

• API Configuration and Documentation
  • Made the API host configurable, enhancing deployment flexibility across environments.
  • Updated Swagger documentation handling to dynamically generate API docs at the `/openapi.json` endpoint.
• CORS Support
  • Added CORS middleware to API routes, improving cross-origin request handling and enhancing API accessibility.

• Continuous Integration and Testing Setup
  • Established a testing framework using Testify and Mockery, and integrated CI workflows.
• Local Development Enhancements
  • Added an option to disable TLS for ClickHouse and included a Docker Compose setup for easier local development and testing.

Learn more about Insight at https://github.com/thirdweb-dev/insight

It's been a long time coming, but now we're finally here. With the completion of the audit of the refactor of Modular Contracts and the Token Paymaster Gateway, Modular Contracts have officially been released under version v1.0.0

The audit was completed by 0xMacro under the git commit tagged macro-audit-9.
You can read about the full report here and you can read about all the changes introduced from the refactor here

As always, with security being top of mind and with the completion of the audit, modular contracts are now finally in a state ready for production.

So stay tuned for our official release of modular contracts!

We shipped an update to the Connect UI in react native that allows users to select any of the 300+ mobile wallets to connect to.

This is enabled by default when you use the ConnectButton and ConnectEmbed in React Native. You can turn off this behavior by passing showAllWallets: false

As always, you can also connect to any of these wallets headlessly using the react hooks and TypeScript core functions.

Happy building! 🛠️

• Adds MarketplaceV3 extensions.
  • Supports IDirectListings, IEnglishAuctions and IOffers
  • Easier to use than direct ThirdwebContract.Write calls as the extensions are type safe and able to automatically handle approvals and more (opt-in).
  • Full reference here - accessible using contract.Marketplace extensions.
• New Utilities
  • Adds standalone Utils.FetchGasPrice (legacy tx) and Utils.FetchGasFees (eip-1559) functions to retrieve chain gas info if needed.
  • Adds Utils.HexToBigInt converting hex strings to BigInteger directly.

.NET Release | Nuget Release | Unity Release

Docs | Support

We are introducing a massive change to thirdweb dashboard with a focus on Teams and Projects - currently in Beta and available for preview on thirdweb.com/team - Try it out!

The new dashboard adds the following features:

• Organize projects within teams to keep your initiatives organized and secure.
• Invite and Manage team members
• Assign permissions to team members

This new team dashboard will replace the current dashboard by October 21st, 2024.

We shipped an update to make it easier to link multiple identities to the same in-app or ecosystem account on React web and native.

You can now use the useLinkProfiles() to easily link a new identity to the connected account. A great use case for this is to onboard users with strategy: "guest" to reduce friction, then when they've engaged with your app, prompt them to link an email or social account.

const wallet = inAppWallet();
 
// First onboard the user as guest
const OnboardingComponent = () => {
  const { connect } = useConnect();
 
  const loginAsGuest = () => {
    connect(() => {
      await wallet.connect({ client, strategy: "guest" });
      return wallet;
    });
  }
}
 
// Then link a profile once they've engaged with the app
const LoginComponent = () => {
  const { mutate: linkProfile } = useLinkProfile();
 
  const loginWithGoogle = async () => {
    await linkProfile({ client, strategy: "google" });
  }
}

Once a user has linked an identity, they can use that identity to login back to the same account later. So in the example above, the user can now login with google next time they need to login to your app.

Another great feature is linking web3 wallets to the account:

const { mutate: linkProfile } = useLinkProfile();
 
const linkWallet = async () => {
  await linkProfile({
    client,
    strategy: "wallet",
    wallet: createWallet("io.metamask"), // or any wallet
  });
};

This will require a signature, ensuring the user owns that wallet. A great use case is doing read only operations on the linked wallets, like checking social profiles, ownership of an NFT or onchain history.

You can fetch all the linked profiles using the useProfiles() hook.

const { data: profiles } = useProfiles();
 
console.log(profiles[0].type);
// each profile type can have different details
console.log(profiles[0].details.email);

We also update the playground site, see it in action here: https://playground.thirdweb.com/connect/in-app-wallet

You can also view more detailed documentation on our developer portal.

Happy building! 🛠️

The latest updates to Insight API lay the foundation for a scalable API. This release introduces a switch to a more mature web framework, along with significant improvements to API documentation. Here’s a summary of what’s new in this version:

Switch from Chi to Gin Web Framework

To enhance performance and streamline our development, Insight has transitioned from the Chi web framework to Gin. This change sets the foundation for better scalability and more responsive APIs.

Swagger Documentation Integration

Insight now features full Swagger integration! We’ve added Swagger documentation to help developers better understand and interact with Insight’s APIs. Swagger provides an intuitive and interactive user interface for exploring API endpoints, which streamlines the development process. Navigate to /swagger/index.html# to start exploring the swagger documentation and interacting with the API.

New Swagger JSON Endpoint

To further improve Swagger’s functionality, we’ve introduced a dedicated Swagger JSON endpoint. This allows developers to directly fetch the OpenAPI specification in JSON format, making it easier to integrate and generate client code. Navigate to /openapi.json to fetch the openAPI json spec.

learn more about insight at https://github.com/thirdweb-dev/insight

We're continuing to ship further improvements across the board with a focus on enhancing contract metadata retrieval and verification. Before diving into this release’s updates, here’s a quick reminder of this part of the thirdweb platform:

Our contract service is a crucial backend tool for managing smart contracts and contracts-related off-chain interactions within the thirdweb platform and beyond. It streamlines key tasks such as fetching and aggregating comprehensive contract metadata (including ABIs and compilation details) and automates the publishing and verification of contracts on popular blockchain explorers.

By removing the often complex, manual steps involved in contract verification, the service makes it far easier for developers to interact with and deploy smart contracts. We'll be unveiling more information about this service in the future, as we consider making this logic a public good, if you know what we mean ;)

But back to our updates:

• Fix parsing issues with dynamic contracts: Resolved issues with parsing complex dynamic contracts, particularly those utilising the Diamond pattern, improving ABI resolution accuracy.
• Correct propagation of internal 4XX errors: Improved inter-service communication and correct handling of errors caused by , ensuring proper communication of errors to clients.
• Fix logging error messages: Corrected logging issues to enhance observability, ensuring more accurate error tracking and monitoring.
• XrpLedger explorers update: Addressed verification issues on the XrpLedger chain by updating the explorer configurations.
• Clean up tests: Improved the test suite for better reliability and maintainability of the codebase.
• Introduce versioning: Implemented versioning to enhance transparency and accountability, paving the way for future open-source contributions.

As for the remarkable highlight, due to the changes made in recent weeks, this service has witnessed drastic improvements in Service Level Objectives (SLOs):

• Error rate when resolving metadata improved from 62.4% to 97.9%.
• Latency improved from 70.2% to 93.2%.

Stay tuned as we continue refining and expanding features for contract metadata retrievals and verifications.

Version v0.0.2-beta brings with it many reliability improvements to make it more robust and fault-tolerant.

• Added the `poller_last_triggered_block` metric to enhance visibility into poller activity and ensure better progress tracking.
• Enhanced poller logging to report the number of blocks being polled and improved robustness with dynamic slice allocation in serialization.

• Changed the `logs` table engine to `ReplacingMergeTree` for broader compatibility.
• Refined gap detection and handling by introducing a new `handleGap` function, enhancing logging for better gap visibility, and ensuring block failures are recorded for missing blocks.

• Fixed an issue with incorrect poll gaps when `pollUntilBlock` is configured.
• Fixed block number handling to improve metric precision, eliminating the need for temporary division workarounds.

• Removed database prefixes from table creation scripts to allow flexible database organization.

Next release will introduce reorg handling which will ensure data reliability for Insight.

Engine v2.0.19 improves handling of maximum gas fee overrides and introduces timeouts.

• Smarter max gas fees: When the gas prices are high and your backend specifies a maximum gas fee, Engine delays the transaction until prices fall below your override.
• Timeouts: Engine will drop your transaction if it isn't sent within your specified timeout.

• Save gas when sending periodic updates to your onchain database that can tolerate higher latency.
• Set a timeout on your DeFi trades to avoid large changes in token prices.

To specify a transfer transaction that spends up to 30 gwei of gas and tries up to 48 hours, add the following fields:

POST /backend-wallet/8453/transfer
{
  // Arguments for a transfer transaction
  "to": "0xA954fC66de1F90cFB4f29F0ABa391412406820B7",
  "amount": "0.5",
  
  // 👇 Specify these overrides based on your chain's gas settings
  "txOverrides": {
    "maxFeePerGas": "30000000000",
    "maxPriorityFeePerGas": "1000000000",
    "timeoutSeconds": 172800
  }
}

💡 Tip: It is highly recommended to set a timeout when setting a maxFeePerGas. Otherwise if gas prices don't fall, transactions may be in your queue indefinitely.

For details, see Overriding Gas Settings.

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've sped up SmartWallet transactions and optimized various internal flows, resulting in up to 50% speed increases from transaction creation to estimation to a receipt being returned. This applies for all flows

Furthermore, we've added an internal feature to automatically detect if a chain is built on the zkSync stack and unlock zkSync specific functionality such as zkSync specific transaction input or Native Account Abstraction automatically.

Added Utils.GetSocialProfiles - fetch ENS, Farcaster and Lens profiles given a wallet address or ENS as well as their metadata and more.

A single line of code to fetch metadata about a wallet address and display it in game as you please!

SocialProfiles socialProfiles = await Utils.GetSocialProfiles(client, addressOrEns: "joenrv.eth");

Example returned object

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

• Exposes Account Linking functionality (LinkAccount & GetLinkedAccounts) at the IThirdwebWallet level.
• You may now link accounts directly to a SmartWallet signer i.e. personal wallet without needing to fetch the signer with SmartWallet.GetPersonalWallet or deal with casting to the right types.
• External wallets or external wallets being used as SmartWallet signers do not support this feature.

Unity Release | .NET Release | NuGet Release

Docs | Support

Unlock a world of new possibilities with the latest enhancements to our plugin! From a streamlined settings toolbar and external OAuth browser to expanded support for popular platforms like Discord, Telegram, and Coinbase, this release brings powerful tools right to your fingertips. With ecosystem wallet integration, guest login options, and enhanced mobile OAuth support, you're equipped to create dynamic, secure experiences with ease. Plus, enjoy a cleaner setup with updated examples and safer client enforcement!

• Plugin Icon
• Editor Toolbar Button for Settings Quick Access
• ThirdwebEditor Module for editor-only functionality
• External OAuth Browser
• Per-provider OAuth settings config
• Ecosystem Wallets
• Phone Option to OTP auth methods
• JWT, Auth Endpoint, and Guest Sign In methods
• Discord, Farcaster, Telegram, Line, X, and Coinbase OAuth methods
• External OAuth Complete screen
• Static accessors to all Runtime settings

• Google Auth on mobile via external OAuth
• Updated rust core libs
• InApp / Ecosystem Wallets to child structs
• Examples to match changed structs / functions

• Private Key functionality (Superseded by guest login)
• Secret Key runtime setting - Safer to enforce client + bundle

Marketplace | Documentation | Github Release

Engine has been updated to v2.0.18. Here are some notable changes in the past few versions:

For cloud-hosted Engine customers, the primary account* for an Engine can trigger an version update from the dashboard UI.

⚠️ We recommend pausing critical traffic during this time as there may be up to a minute of downtime.

*The account that owns the subscription. We're working on better Engine management for teams in the near future!

All endpoints that accept an EVM address or transaction hash now enforce the type on input, returning a clearer message before the request fails further with a less obvious error (like "Contract not found" when provided a malformed address).

Docker build times have been reduced ~85% down to 7 minutes! This mostly impacts developers building Engine from source.

• Gas withdrawals from a backend wallet are more reliable by calculating the max amount of funds that can be withdrawn with the current gas settings.
• Reduced Redis usage when many jobs that fail to mine.
• More reliable "stuck nonce" health checks that alert our on-call. (Cloud-hosted only)

The team's focus is on internal alerting and deeper observability into all the dependencies of Engine.

Upcoming product improvements include smart accounts capabilities, more granular options to handle gas spikes, API performance improvements with the v5 SDK, improvements to Alert Notifications, and more. Stay tuned for more changelog 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!

We are excited to announce the initial release of Thirdweb Insight - an open source indexer and API for any EVM.

Provide an RPC URL and index the whole blockchain (or choose a range), including all blocks, transactions, logs and traces. It will keep up with the chain in real time and keep indexing as the chain progresses.

During our internal testing we achieved a indexing speed of up to 65k blocks per minute. However, this speed depends on the performance of the RPC and heaviness of the chain.

The service is built with the requirement of only serving complete and correct data. Once the block range is indexed, you can be sure that it contains all the transactions and logs that there are without missing any gaps. This is especially important for querying data aggregations like token balances.

The indexer is designed to recover itself in case of any failures or an unreachable RPC. It will not serve incomplete data and will continue from where the error occurred, once the error has been solved.

The service exposes an HTTP API to query transactions and logs complete with aggregations. Here are just a few examples of what you can query using the API:

• Current and historic token balances
• Historic transactions of a specific wallet
• Transactions to a specific contract
• and much more

This initial release of Thirdweb Insight lays the groundwork for a performant indexing service and API. We look forward to your feedback and contributions as we continue to enhance and expand the functionality of it. Thank you for your support!

https://github.com/thirdweb-dev/insight

We just released a new version of the thirdweb package which unlocks ecosystem wallet support for React Native applications.

You can now connect to any ecosystem wallet from native mobile apps with the same API as the web:

import { ecosystemWallet } from "thirdweb/wallets";
 
const wallet = ecosystemWallet("ecosystem.your-ecosystem");
 
await wallet.connect({
  client,
  strategy: "google", // or any auth method
)};

This means you can now build up a network of web AND mobile apps that all share the same user identity, all while staying within your ecosystem.

Happy building!

In this release, we’ve introduced key enhancements to ABI resolution for composite contracts, improved functionality for managing contract metadata, and made updates to our persistence layer to ensure more robust performance.

We've refactored the ABI resolution process, focusing on better handling of composite contracts like plugin-pattern, base router, and diamond pattern contracts. This included ensuring extra stability by introducing checks to prevent recursive calls and other redundant resources-heavy mechanics.

• Improved the schema for better handling of proxy contracts.
• Added functionality to refresh contract metadata across all persistence layers, simplifying data management.
• Updated persistence-related functions for better error handling and performance, especially in scenarios involving proxies and non-proxy contracts.
• Improved build times and dependency management (could this hint at something bigger, perhaps even... open-sourcing the project s00n? 👀)

With these updates rolling out we get faster ABI resolutions and even more reliable contract data persistence!

• ThirdwebManager inspector is a little more interactive now.

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

.NET Release | NuGet

Unity Release

Documentation | Support

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

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

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

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

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

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

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

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

For more information, you can check our API Reference.

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

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

thirdweb Engine is an open-source server for your app to read, write, and deploy contracts at production scale. Self-host for free or get a cloud-hosted Engine for $99/month.

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!

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

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

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

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

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

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

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!

TypeScript SDK

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

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

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

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

Response format:

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

Learn more about pregenerating user accounts here.

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

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

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

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

• isGetNFTSupported checks for getNFT support on an ERC-1155 contract
• Ecosystem wallets now support guest mode

React SDK

• The details modal now displays the currently logged in auth provider
• The details modal now shows user info such as email when logged into an ecosystem wallet
• The social icon arrangement in the Connect UI now overflows to a new line when using more than 5 auth methods

• Guest accounts are now hidden from the details modal linked profiles screen

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

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

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

• Hide OAuthBrowserWidget from editor

Marketplace | Documentation | Github Release

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

.NET Release | NuGet

Unity Release

Documentation | Support

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

Faster contract-related SDK calls and dashboards

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

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

Additional Improvements

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

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

postscriptum - what is this service about?

Our contract service is a crucial backend tool for managing smart contracts and contracts-related off-chain interactions within the thirdweb platform and beyond. It streamlines key tasks such as fetching and aggregating comprehensive contract metadata (including ABIs and compilation details) and automates the publishing and verification of contracts on popular blockchain explorers.

By removing the often complex, manual steps involved in contract verification, the service makes it far easier for developers to interact with and deploy smart contracts. We'll be unveiling more information about this service in the future, as we consider making this logic a public good, iykwim ;)

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

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

You can find the full release of the audit here.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sendCrossChainTransaction

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

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

onCrossChainTransactionSent

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

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

onCrossChainTransactionReceived

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

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

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

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

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

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

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

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

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

• isGetListingSupported
• isBuyFromListingSupported
• isCreateAuctionSupported
• isGetAuctionSupported
• isGetWinningBidSupported
• isBidInAuctionSupported
• isCancelAuctionSupported
• isCreateAuctionSupported
• isCancelListingSupported

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

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

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

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

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

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

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

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

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

• Adds AuthProvider.X as a login option. Linking supported.

// Unity - InAppWallet
var iawOptions = new WalletOptions(
    provider: WalletProvider.InAppWallet,
    chainId: 421614,
    inAppWalletOptions: new InAppWalletOptions(authprovider: AuthProvider.X)
);
var iaw = await ThirdwebManager.Instance.ConnectWallet(iawOptions) as InAppWallet;
// Unity - EcosystemWallet
var ecoOptions = new WalletOptions(
    provider: WalletProvider.EcosystemWallet,
    chainId: 421614,
    ecosystemWalletOptions: new EcosystemWalletOptions(
        ecosystemId: "ecosystem.the-bonfire",
        authprovider: AuthProvider.X
    )
);
var eco = await ThirdwebManager.Instance.ConnectWallet(ecoOptions) as EcosystemWallet;
// .NET - InAppWallet (Windows Console Example)
var inAppWalletOAuth = await InAppWallet.Create(
  client: client, 
  authProvider: AuthProvider.X
);
if (!await inAppWalletOAuth.IsConnected())
{
    _ = await inAppWalletOAuth.LoginWithOauth(
        isMobile: false,
        (url) =>
        {
            var psi = new ProcessStartInfo { FileName = url, UseShellExecute = true };
            _ = Process.Start(psi);
        },
    );
}
var inAppWalletOAuthAddress = await inAppWalletOAuth.GetAddress();
Console.WriteLine($"InAppWallet OAuth address: {inAppWalletOAuthAddress}");
// .NET - EcosystemWallet (Windows Console Example)
var ecosystemWalletOAuth = await EcosystemWallet.Create(
  ecosystemId: "ecosystem.the-bonfire", 
  client: client, 
  authProvider: AuthProvider.X
);
if (!await ecosystemWalletOAuth.IsConnected())
{
    _ = await ecosystemWalletOAuth.LoginWithOauth(
        isMobile: false,
        (url) =>
        {
            var psi = new ProcessStartInfo { FileName = url, UseShellExecute = true };
            _ = Process.Start(psi);
        }
    );
}
var ecosystemWalletOAuthAddress = await ecosystemWalletOAuth.GetAddress();
Console.WriteLine($"EcosystemWallet OAuth address: {ecosystemWalletOAuthAddress}");

• Fixes edge case when sending two SmartWallet transactions at once from an undeployed account and using EntryPoint 0.7.0 where deployment code would be duplicated causing an error.

.NET Nuget Release | Unity Release

.NET Docs | Unity Docs

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

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

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

• ThirdwebSubsystem

Marketplace | Documentation | Github Release

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

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

This also works for linking accounts to an existing wallet.

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

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

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

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

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

• Specify your preferred provider on the buyWithFiat function using preferredProvider

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

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

This includes linking an account to form a unified identity.

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

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

import { getUser } from "thirdweb/wallets";
 
const user = await getUser({
  client,
  email: "vitalik@ethereum.org",
});

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

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

This also works with unpublished contracts deployed via deployContract.

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

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

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

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

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

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

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

What can you use right now?

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

Improvements since alpha

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

What’s coming up in the next few weeks?

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

Beta Feedback Program

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

Resources

• Pre-built Modular Contracts on Explore
• Modular Contracts Documentation
• Modular Contracts SDK Reference

Feedback

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var linkedAccounts = await ecosystemOrInAppWallet.GetLinkedAccounts();

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

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

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

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

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

.NET Nuget Release | Unity Release

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

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

It's time to ditch external wallets.

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

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

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

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

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

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

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

Fixed ERC20 balance reading when showing the Pay modal

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

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

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

Initial Node Prioritisation with Default Scoring

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

Changes made recently in this regard:

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

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

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

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

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

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

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

import { useSocialProfiles } from "thirdweb/react";
 
const { data: profiles } = useSocialProfiles({
  client,
  address: "0x...",
});

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

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

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

Dynamic Method Based Scoring and Routing for RPC Edge

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

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

First tests are already showing improved latency by 20%!

Error Handling and Logging Updates

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

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

Deprecations
Removed support for deprecated Mumbai RPC.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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!

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

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

A migration guide has been added to the portal here.

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

Take-Flight-Migration.mp4

Google Docs

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

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

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

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

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

For regular minting, the following parameters are now introduced:

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

For signature mints, the following parameters are now introduced:

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

Reference to code:
ClaimableERC721.sol#L196

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

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

Reference to code:
ClaimableERC721.sol#L75

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

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

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

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

You can learn more about the Creator Token Standard here.

Reference to code:
RoyaltiesERC721.sol

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

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

Reference to code:
BatchMetadataERC721.sol#L114

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

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

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

This change was introduced because:

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

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

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

Reference to code:
SequentialTokenIdERC1155.sol

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

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

As previously mentioned:

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

Reference to code:
ERC1155Base.sol#L212

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

Reference to code:
ERC1155Base.sol#L205

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

Reference to code:
ERC1155Base.sol#L230

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

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

Reference to code:
ERC1155Base.sol

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

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

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

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