[SmartWallet] expose new send/execute smart wallet functions

.changeset/new-books-notice.md

@@ -0,0 +1,5 @@
+---
+"@thirdweb-dev/sdk": patch
+---
+
+Expose getCompositeABI for dynamic contracts

.changeset/olive-impalas-knock.md

@@ -0,0 +1,19 @@
+---
+"@thirdweb-dev/wallets": patch
+---
+
+Expose new Smart Wallet transaction functions
+
+Snding raw transactions:
+
+```
+smartWallet.sendRaw(tx);
+smartWallet.executeRaw(tx); // waits for confirmations
+```
+
+Sending raw batched transactions
+
+```
+smartWallet.sendBatchRaw(tx);
+smartWallet.executeBatchRaw(tx); // waits for confirmations
+```

packages/sdk/src/evm/common/index.ts

@@ -29,6 +29,7 @@ export * from "./feature-detection/assertEnabled";
 export * from "./feature-detection/detectContractFeature";
 export * from "./feature-detection/hasFunction";
 export * from "./plugin/joinABIs";
+export * from "./plugin/getCompositePluginABI";
 
 export * from "./version-checker";
 export * from "./fetchSourceFilesFromMetadata";

packages/sdk/src/evm/common/plugin/getCompositePluginABI.ts

@@ -5,7 +5,7 @@ import {
 import { ContractWrapper } from "../../core/classes/contract-wrapper";
 import { Abi, AbiSchema } from "../../schema/contracts/custom";
 import { SDKOptions } from "../../schema/sdk-options";
-import { isFeatureEnabled } from "../feature-detection/isFeatureEnabled";
+import { isExtensionEnabled } from "../feature-detection/isFeatureEnabled";
 import { ThirdwebStorage } from "@thirdweb-dev/storage";
 import { providers } from "ethers";
 import { joinABIs } from "./joinABIs";
@@ -14,7 +14,7 @@ import { getPluginABI } from "./getPluginABI";
 /**
  * @internal
  */
-export async function getCompositePluginABI(
+export async function getCompositeABI(
   address: string,
   abi: Abi,
   provider: providers.Provider,
@@ -25,11 +25,11 @@ export async function getCompositePluginABI(
 
   try {
     // check if contract is plugin-pattern
-    const isPluginRouter: boolean = isFeatureEnabled(
+    const isPluginRouter: boolean = isExtensionEnabled(
       AbiSchema.parse(abi),
       "PluginRouter",
     );
-    const isbaseRouter: boolean = isFeatureEnabled(
+    const isbaseRouter: boolean = isExtensionEnabled(
       AbiSchema.parse(abi),
       "DynamicContract",
     );

packages/sdk/src/evm/contracts/index.ts

@@ -7,7 +7,7 @@ import {
 import { getPrebuiltInfo } from "../common/legacy";
 import { fetchAbiFromAddress } from "../common/metadata-resolver";
 import { getCompositeABIfromRelease } from "../common/plugin/getCompositeABIfromRelease";
-import { getCompositePluginABI } from "../common/plugin/getCompositePluginABI";
+import { getCompositeABI } from "../common/plugin/getCompositePluginABI";
 import { ALL_ROLES } from "../common/role";
 import { getSignerAndProvider } from "../constants/urls";
 import type { NetworkInput } from "../core/types";
@@ -239,14 +239,14 @@ export const MarketplaceV3Initializer = {
 
     const abi = await fetchAbiFromAddress(address, provider, storage);
     if (abi) {
-      return await getCompositePluginABI(address, abi, provider, {}, storage);
+      return await getCompositeABI(address, abi, provider, {}, storage);
     }
 
     // Deprecated - only needed for backwards compatibility with non-published contracts - should remove in v4
     const localAbi = (
       await import("@thirdweb-dev/contracts-js/dist/abis/MarketplaceV3.json")
     ).default;
-    return await getCompositePluginABI(
+    return await getCompositeABI(
       address,
       AbiSchema.parse(localAbi || []),
       provider,

packages/sdk/src/evm/core/sdk.ts

@@ -1,6 +1,6 @@
 import { getAllDetectedExtensionNames } from "../common/feature-detection/getAllDetectedFeatureNames";
 import { resolveAddress } from "../common/ens/resolveAddress";
-import { getCompositePluginABI } from "../common/plugin/getCompositePluginABI";
+import { getCompositeABI } from "../common/plugin/getCompositePluginABI";
 import { createStorage } from "../common/storage";
 import { getChainProvider, isChainConfig } from "../constants/urls";
 import { setSupportedChains } from "../constants/chains/supportedChains";
@@ -842,7 +842,7 @@ export class ThirdwebSDK extends RPCConnectionHandler {
     const contract = new SmartContract(
       this.getSignerOrProvider(),
       resolvedAddress,
-      await getCompositePluginABI(
+      await getCompositeABI(
         resolvedAddress,
         AbiSchema.parse(parsedABI),
         provider,

packages/sdk/src/evm/functions/getContractFromAbi.ts

@@ -1,5 +1,5 @@
 import { resolveAddress } from "../common/ens/resolveAddress";
-import { getCompositePluginABI } from "../common/plugin/getCompositePluginABI";
+import { getCompositeABI } from "../common/plugin/getCompositePluginABI";
 import { SmartContract } from "../contracts/smart-contract";
 import { NetworkInput } from "../core/types";
 import { AddressOrEns } from "../schema/shared/AddressOrEnsSchema";
@@ -44,7 +44,7 @@ export async function getContractFromAbi(
   const contract = new SmartContract(
     signer || provider,
     resolvedAddress,
-    await getCompositePluginABI(
+    await getCompositeABI(
       resolvedAddress,
       AbiSchema.parse(parsedAbi),
       provider,

packages/wallets/src/evm/connectors/smart-wallet/index.ts

@@ -13,7 +13,7 @@ import {
 import { ENTRYPOINT_ADDRESS } from "./lib/constants";
 import { EVMWallet } from "../../interfaces";
 import { ERC4337EthersSigner } from "./lib/erc4337-signer";
-import { BigNumber, ethers, providers } from "ethers";
+import { BigNumber, ethers, providers, utils } from "ethers";
 import {
   ChainOrRpcUrl,
   getChainProvider,
@@ -25,6 +25,7 @@ import {
   TransactionResult,
 } from "@thirdweb-dev/sdk";
 import { AccountAPI } from "./lib/account";
+import { AddressZero } from "@account-abstraction/utils";
 
 export class SmartWalletConnector extends Connector<SmartWalletConnectionArgs> {
   private config: SmartWalletConfig;
@@ -164,23 +165,57 @@ export class SmartWalletConnector extends Connector<SmartWalletConnectionArgs> {
   }
 
   /**
-   * Execute a single transaction
+   * Send a single transaction without waiting for confirmations
    * @param transactions
-   * @returns the transaction receipt
+   * @returns the awaitable transaction
    */
-  async execute(transaction: Transaction): Promise<TransactionResult> {
+  async send(transaction: Transaction): Promise<providers.TransactionResponse> {
     const signer = await this.getSigner();
-    const tx = await signer.sendTransaction({
+    return signer.sendTransaction({
       to: transaction.getTarget(),
       data: transaction.encode(),
       value: await transaction.getValue(),
     });
+  }
+
+  /**
+   * Execute a single transaction (waiting for confirmations)
+   * @param transactions
+   * @returns the transaction receipt
+   */
+  async execute(transaction: Transaction): Promise<TransactionResult> {
+    const tx = await this.send(transaction);
     const receipt = await tx.wait();
     return {
       receipt,
     };
   }
 
+  async sendBatch(
+    transactions: Transaction<any>[],
+  ): Promise<providers.TransactionResponse> {
+    if (!this.accountApi) {
+      throw new Error("Personal wallet not connected");
+    }
+    const signer = await this.getSigner();
+    const targets = transactions.map((tx) => tx.getTarget());
+    const data = transactions.map((tx) => tx.encode());
+    const values = await Promise.all(transactions.map((tx) => tx.getValue()));
+    const callData = await this.accountApi.encodeExecuteBatch(
+      targets,
+      values,
+      data,
+    );
+    return await signer.sendTransaction(
+      {
+        to: await signer.getAddress(),
+        data: callData,
+        value: 0,
+      },
+      true, // batched tx flag
+    );
+  }
+
   /**
    * Execute multiple transactions in a single batch
    * @param transactions
@@ -189,26 +224,67 @@ export class SmartWalletConnector extends Connector<SmartWalletConnectionArgs> {
   async executeBatch(
     transactions: Transaction<any>[],
   ): Promise<TransactionResult> {
+    const tx = await this.sendBatch(transactions);
+    const receipt = await tx.wait();
+    return {
+      receipt,
+    };
+  }
+
+  async sendRaw(
+    transaction: utils.Deferrable<providers.TransactionRequest>,
+  ): Promise<providers.TransactionResponse> {
     if (!this.accountApi) {
       throw new Error("Personal wallet not connected");
     }
     const signer = await this.getSigner();
-    const targets = transactions.map((tx) => tx.getTarget());
-    const data = transactions.map((tx) => tx.encode());
-    const values = transactions.map(() => BigNumber.from(0)); // TODO check if we can handle multiple values
+    return signer.sendTransaction(transaction);
+  }
+
+  async executeRaw(
+    transaction: utils.Deferrable<providers.TransactionRequest>,
+  ) {
+    const tx = await this.sendRaw(transaction);
+    const receipt = await tx.wait();
+    return {
+      receipt,
+    };
+  }
+
+  async sendBatchRaw(
+    transactions: utils.Deferrable<providers.TransactionRequest>[],
+  ) {
+    if (!this.accountApi) {
+      throw new Error("Personal wallet not connected");
+    }
+    const signer = await this.getSigner();
+    const resolvedTxs = await Promise.all(
+      transactions.map((transaction) =>
+        ethers.utils.resolveProperties(transaction),
+      ),
+    );
+    const targets = resolvedTxs.map((tx) => tx.to || AddressZero);
+    const data = resolvedTxs.map((tx) => tx.data || "0x");
+    const values = resolvedTxs.map((tx) => tx.value || BigNumber.from(0));
     const callData = await this.accountApi.encodeExecuteBatch(
       targets,
       values,
       data,
     );
-    const tx = await signer.sendTransaction(
+    return signer.sendTransaction(
       {
         to: await signer.getAddress(),
         data: callData,
         value: 0,
       },
       true, // batched tx flag
     );
+  }
+
+  async executeBatchRaw(
+    transactions: utils.Deferrable<providers.TransactionRequest>[],
+  ) {
+    const tx = await this.sendBatchRaw(transactions);
     const receipt = await tx.wait();
     return {
       receipt,

packages/wallets/src/evm/connectors/smart-wallet/lib/account.ts

@@ -1,5 +1,5 @@
 import { LOCAL_NODE_PKEY, SmartContract, ThirdwebSDK } from "@thirdweb-dev/sdk";
-import { BigNumberish, BigNumber, ethers, utils } from "ethers";
+import { BigNumberish, BigNumber, ethers, utils, BytesLike } from "ethers";
 import { AccountApiParams } from "../types";
 import { BaseAccountAPI } from "./base-api";
 import { ACCOUNT_CORE_ABI } from "./constants";
@@ -121,10 +121,10 @@ export class AccountAPI extends BaseAccountAPI {
   async encodeExecuteBatch(
     targets: string[],
     values: BigNumberish[],
-    datas: string[],
+    datas: BytesLike[],
   ): Promise<string> {
     const accountContract = await this.getAccountContract();
-    const tx = await accountContract.prepare("executeBatch", [
+    const tx = accountContract.prepare("executeBatch", [
       targets,
       values,
       datas,

packages/wallets/src/evm/wallets/smart-wallet.ts

@@ -23,6 +23,7 @@ import {
 import { WalletConnectV2Handler } from "../../core/WalletConnect/WalletConnectV2Handler";
 import { NoOpWalletConnectHandler } from "../../core/WalletConnect/constants";
 import { getValidChainRPCs } from "@thirdweb-dev/chains";
+import { providers, utils } from "ethers";
 
 // export types and utils for convenience
 export * from "../connectors/smart-wallet/types";
@@ -106,7 +107,17 @@ export class SmartWallet
   }
 
   /**
-   * Execute a single transaction
+   * Send a single transaction without waiting for confirmations
+   * @param transactions
+   * @returns the transaction result
+   */
+  async send(transaction: Transaction): Promise<providers.TransactionResponse> {
+    const connector = await this.getConnector();
+    return connector.send(transaction);
+  }
+
+  /**
+   * Execute a single transaction and wait for confirmations
    * @param transactions
    * @returns the transaction receipt
    */
@@ -116,7 +127,19 @@ export class SmartWallet
   }
 
   /**
-   * Execute multiple transactions in a single batch
+   * Send a multiple transaction in a batch without waiting for confirmations
+   * @param transactions
+   * @returns the transaction result
+   */
+  async sendBatch(
+    transactions: Transaction[],
+  ): Promise<providers.TransactionResponse> {
+    const connector = await this.getConnector();
+    return connector.sendBatch(transactions);
+  }
+
+  /**
+   * Execute multiple transactions in a single batch and wait for confirmations
    * @param transactions
    * @returns the transaction receipt
    */
@@ -127,6 +150,54 @@ export class SmartWallet
     return connector.executeBatch(transactions);
   }
 
+  /**
+   * Send a single raw transaction without waiting for confirmations
+   * @param transaction
+   * @returns the transaction result
+   */
+  async sendRaw(
+    transaction: utils.Deferrable<providers.TransactionRequest>,
+  ): Promise<providers.TransactionResponse> {
+    const connector = await this.getConnector();
+    return connector.sendRaw(transaction);
+  }
+
+  /**
+   * Execute a single raw transaction and wait for confirmations
+   * @param transaction
+   * @returns the transaction receipt
+   */
+  async executeRaw(
+    transaction: utils.Deferrable<providers.TransactionRequest>,
+  ): Promise<TransactionResult> {
+    const connector = await this.getConnector();
+    return connector.executeRaw(transaction);
+  }
+
+  /**
+   * Send multiple raw transaction in a batch without waiting for confirmations
+   * @param transaction
+   * @returns the transaction result
+   */
+  async sendBatchRaw(
+    transactions: utils.Deferrable<providers.TransactionRequest>[],
+  ): Promise<providers.TransactionResponse> {
+    const connector = await this.getConnector();
+    return connector.sendBatchRaw(transactions);
+  }
+
+  /**
+   * Execute multiple raw transactions in a single batch and wait for confirmations
+   * @param transaction
+   * @returns the transaction receipt
+   */
+  async executeBatchRaw(
+    transactions: utils.Deferrable<providers.TransactionRequest>[],
+  ): Promise<TransactionResult> {
+    const connector = await this.getConnector();
+    return connector.executeBatchRaw(transactions);
+  }
+
   /**
    * Manually deploy the smart wallet contract. If already deployed this will throw an error.
    * Note that this is not necessary as the smart wallet will be deployed automatically on the first transaction the user makes.