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": 5.697469727711138e+76,
      "s": 4.108079250701892e+76,
      "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": 2.178643681991461e+76,
            "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,
  },
});