@1llet.xyz/erc4337-gasless-sdk 0.4.31 → 0.4.33

package/dist/index.d.mts

@@ -75,6 +75,8 @@ declare class AccountAbstraction {
         owner: Address;
         smartAccount: Address;
     }>;
+    isAccountDeployed(): Promise<boolean>;
+    deployAccount(): Promise<UserOpReceipt>;
     /**
      * Get the Smart Account address for an owner
      */
@@ -83,6 +85,18 @@ declare class AccountAbstraction {
     getBalance(token: string | Address): Promise<bigint>;
     getEoaBalance(token: string | Address): Promise<bigint>;
     getAllowance(token?: string | Address): Promise<bigint>;
+    /**
+     * Get comprehensive state of the account for a specific token
+     * Useful for UI initialization
+     */
+    getAccountState(token: string | Address): Promise<{
+        owner: `0x${string}`;
+        smartAccount: `0x${string}`;
+        balance: bigint;
+        eoaBalance: bigint;
+        allowance: bigint;
+        isDeployed: boolean;
+    }>;
     sendTransaction(tx: {
         target: Address;
         value?: bigint;
@@ -94,6 +108,18 @@ declare class AccountAbstraction {
         data?: Hex;
     }[]): Promise<UserOpReceipt>;
     deposit(amount: bigint): Promise<Hash>;
+    /**
+     * Smart Transfer: Automatically chooses best method (SA vs EOA) based on balances.
+     * Supports strict fee handling.
+     */
+    smartTransfer(token: Address | string, recipient: Address, amount: bigint, fee?: {
+        amount: bigint;
+        recipient: Address;
+    }): Promise<UserOpReceipt | {
+        receipt: {
+            transactionHash: Hash;
+        };
+    }>;
     transfer(token: Address | string, recipient: Address, amount: bigint): Promise<UserOpReceipt>;
     /**
      * Approve a token for the Smart Account

package/dist/index.d.ts

@@ -75,6 +75,8 @@ declare class AccountAbstraction {
         owner: Address;
         smartAccount: Address;
     }>;
+    isAccountDeployed(): Promise<boolean>;
+    deployAccount(): Promise<UserOpReceipt>;
     /**
      * Get the Smart Account address for an owner
      */
@@ -83,6 +85,18 @@ declare class AccountAbstraction {
     getBalance(token: string | Address): Promise<bigint>;
     getEoaBalance(token: string | Address): Promise<bigint>;
     getAllowance(token?: string | Address): Promise<bigint>;
+    /**
+     * Get comprehensive state of the account for a specific token
+     * Useful for UI initialization
+     */
+    getAccountState(token: string | Address): Promise<{
+        owner: `0x${string}`;
+        smartAccount: `0x${string}`;
+        balance: bigint;
+        eoaBalance: bigint;
+        allowance: bigint;
+        isDeployed: boolean;
+    }>;
     sendTransaction(tx: {
         target: Address;
         value?: bigint;
@@ -94,6 +108,18 @@ declare class AccountAbstraction {
         data?: Hex;
     }[]): Promise<UserOpReceipt>;
     deposit(amount: bigint): Promise<Hash>;
+    /**
+     * Smart Transfer: Automatically chooses best method (SA vs EOA) based on balances.
+     * Supports strict fee handling.
+     */
+    smartTransfer(token: Address | string, recipient: Address, amount: bigint, fee?: {
+        amount: bigint;
+        recipient: Address;
+    }): Promise<UserOpReceipt | {
+        receipt: {
+            transactionHash: Hash;
+        };
+    }>;
     transfer(token: Address | string, recipient: Address, amount: bigint): Promise<UserOpReceipt>;
     /**
      * Approve a token for the Smart Account

package/dist/index.js

@@ -358,6 +358,16 @@ var TokenService = class {
       args: [recipient, amount]
     });
   }
+  /**
+   * Encode transferFrom data
+   */
+  encodeTransferFrom(sender, recipient, amount) {
+    return viem.encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transferFrom",
+      args: [sender, recipient, amount]
+    });
+  }
   /**
    * Encode approve data
    */
@@ -570,6 +580,20 @@ var AccountAbstraction = class {
       smartAccount: this.smartAccountAddress
     };
   }
+  // --- Account Management ---
+  async isAccountDeployed() {
+    if (!this.smartAccountAddress) return false;
+    const code = await this.publicClient.getBytecode({ address: this.smartAccountAddress });
+    return code !== void 0;
+  }
+  async deployAccount() {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    return this.sendTransaction({
+      target: this.smartAccountAddress,
+      value: 0n,
+      data: "0x"
+    });
+  }
   /**
    * Get the Smart Account address for an owner
    */
@@ -598,6 +622,30 @@ var AccountAbstraction = class {
     if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
     return this.tokenService.getAllowance(token, this.owner, this.smartAccountAddress);
   }
+  /**
+   * Get comprehensive state of the account for a specific token
+   * Useful for UI initialization
+   */
+  async getAccountState(token) {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    const tokenAddress = this.getTokenAddress(token);
+    const isNative = tokenAddress === "0x0000000000000000000000000000000000000000";
+    const [balance, eoaBalance, allowance, isDeployed] = await Promise.all([
+      this.getBalance(token),
+      this.getEoaBalance(token),
+      isNative ? 0n : this.getAllowance(token).catch(() => 0n),
+      // Handle native/error gracefully
+      this.isAccountDeployed()
+    ]);
+    return {
+      owner: this.owner,
+      smartAccount: this.smartAccountAddress,
+      balance,
+      eoaBalance,
+      allowance,
+      isDeployed
+    };
+  }
   // --- Transactions ---
   async sendTransaction(tx) {
     return this.sendBatchTransaction([tx]);
@@ -641,6 +689,77 @@ var AccountAbstraction = class {
       }]
     });
   }
+  /**
+   * Smart Transfer: Automatically chooses best method (SA vs EOA) based on balances.
+   * Supports strict fee handling.
+   */
+  async smartTransfer(token, recipient, amount, fee) {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    const tokenAddress = this.getTokenAddress(token);
+    const isNative = tokenAddress === "0x0000000000000000000000000000000000000000";
+    const [saBal, eoaBal, allowance] = await Promise.all([
+      this.getBalance(token),
+      this.getEoaBalance(token),
+      isNative ? 0n : this.getAllowance(token).catch(() => 0n)
+    ]);
+    const totalNeeded = amount + (fee?.amount || 0n);
+    if (saBal >= totalNeeded) {
+      const txs = [];
+      if (isNative) {
+        txs.push({ target: recipient, value: amount, data: "0x" });
+      } else {
+        txs.push({ target: tokenAddress, value: 0n, data: this.tokenService.encodeTransfer(recipient, amount) });
+      }
+      if (fee && fee.amount > 0n) {
+        if (isNative) {
+          txs.push({ target: fee.recipient, value: fee.amount, data: "0x" });
+        } else {
+          txs.push({ target: tokenAddress, value: 0n, data: this.tokenService.encodeTransfer(fee.recipient, fee.amount) });
+        }
+      }
+      console.log("SmartTransfer: Using Smart Account");
+      return this.sendBatchTransaction(txs);
+    }
+    if (eoaBal >= totalNeeded) {
+      if (isNative) {
+        console.log("SmartTransfer: Using EOA (Native)");
+        if (this.walletClient) {
+          const hash2 = await this.walletClient.sendTransaction({
+            account: this.walletClient.account,
+            to: recipient,
+            value: amount,
+            chain: this.chainConfig.chain
+          });
+          return { receipt: { transactionHash: hash2 } };
+        }
+        const hash = await window.ethereum.request({
+          method: "eth_sendTransaction",
+          params: [{ from: this.owner, to: recipient, value: "0x" + amount.toString(16) }]
+        });
+        return { receipt: { transactionHash: hash } };
+      } else {
+        console.log("SmartTransfer: Using EOA (Pull)");
+        if (allowance < totalNeeded) {
+          throw new Error(`Approval required. Please approve ${token} usage.`);
+        }
+        const txs = [];
+        txs.push({
+          target: tokenAddress,
+          value: 0n,
+          data: this.tokenService.encodeTransferFrom(this.owner, recipient, amount)
+        });
+        if (fee && fee.amount > 0n) {
+          txs.push({
+            target: tokenAddress,
+            value: 0n,
+            data: this.tokenService.encodeTransferFrom(this.owner, fee.recipient, fee.amount)
+          });
+        }
+        return this.sendBatchTransaction(txs);
+      }
+    }
+    throw new Error(`Insufficient funds.`);
+  }
   async transfer(token, recipient, amount) {
     const tokenAddress = this.getTokenAddress(token);
     if (tokenAddress === "0x0000000000000000000000000000000000000000") {