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

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

npm install thirdweb

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

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

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

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

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

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

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

Happy Building! 🛠️

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

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

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

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

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

Happy building! 🛠️

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

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

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

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

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

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

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

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

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

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

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

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

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

Contract Analytics on thirdweb dashboard is now powered by thirdweb Insight

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

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

View this contract analytics on dashboard

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

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

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

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

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

The following endpoints now support multichain queries:

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

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

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

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

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

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

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

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

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

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

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

For example, to query latest events on Optimism

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

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

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

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

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

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

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

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

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

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

.NET Releases | NuGet Release | Unity Release

Support | Docs

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

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

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

To send sponsored transactions:

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

The header:

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

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

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

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

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

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

• Removed some leftover unnecessary logging.

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

Flag under ThirdwebManager > Preferences.

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

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

Any failure during this entire flow should not throw.

.NET Release | NuGet Release | Unity Releases

Support | Documentation

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

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

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

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

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

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

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

Features 🚀

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

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

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

Added deploySmartAccount function to explicitly deploy smart account contracts.

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

Improvements 🔧

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

Features 🚀

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

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

Improvements 🔧

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

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

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

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

Bug Fixes 🐛

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

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

Removals and Deprecations 🗑️

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

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

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

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

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

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

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

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

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

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

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

.NET Release | NuGet Release | Unity Release

Docs | Support

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

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

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

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

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

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

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

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

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

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

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

Merry Christmas and happy holidays!

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

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

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

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

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

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

Advanced usage to manage wallet nonces

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

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

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

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

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

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

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

npm install thirdweb @thirdweb-dev/wagmi-adapter

Make sure you're running wagmi 2.14.1 or above.

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

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

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

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

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

Happy building! 🛠️

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

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

• Fixed a caching issue in our new headless components

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Decoding for events and transactions in the API

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

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

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

We can do the following query to insight

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

and receive a response

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

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

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

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

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

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

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

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

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

thirdweb: The complete web3 development platform

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

thirdweb

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

thirdweb: The complete web3 development platform

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

thirdweb

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

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

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

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

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

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

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

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

Happy building! 🛠️

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

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

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

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

Happy building! 🛠️

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

AppChain: RPC and Chain Settings

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

Metal L2: RPC and Chain Settings

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

Xsolla ZK Sepolia Testnet: RPC and Chain Settings

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

Funki Sepolia Sandbox: RPC and Chain Settings

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

Sanko: RPC and Chain Settings

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

DOS Tesnet: RPC and Chain Settings

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

DOS Chain: RPC and Chain Settings

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

BOB: RPC and Chain Settings

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

BOB Sepolia: RPC and Chain Settings

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

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

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

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

Happy building! 🛠️

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

.NET Release | NuGet Release | Unity Release

Docs | Support

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

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

Example:

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

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

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

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

• intrinsic build errors
• OAuthBrowserWidget Error being empty

• Moved BuildPlugin to its own repo

Marketplace | Documentation | Github Release

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.NET Release | NuGet Release | Unity Release

Docs | Support

We supported pregeneration for enclave wallets a while back.

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

What does this mean?

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

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

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

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

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

Here's what that would look like:

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

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

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

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

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

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

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

For example, to query Avalanche data:

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

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

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

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

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

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

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!