@zyfai/sdk 0.2.26 → 0.2.28

package/dist/index.mjs

@@ -24,6 +24,7 @@ var ENDPOINTS = {
   PROTOCOLS: (chainId) => chainId ? `/protocols?chainId=${chainId}` : "/protocols",
   // Data (v1)
   DATA_POSITION: (walletAddress) => `/data/position?walletAddress=${walletAddress}`,
+  DATA_PORTFOLIO: (walletAddress) => `/data/wallet-portfolio?walletAddress=${walletAddress}`,
   DATA_HISTORY: (walletAddress, chainId) => `/data/history?walletAddress=${walletAddress}&chainId=${chainId}`,
   DATA_TVL: "/data/usd-tvl",
   DATA_VOLUME: (assetType) => `/data/volume?assetType=${assetType}`,
@@ -164,7 +165,7 @@ var HttpClient = class {
             case 429:
               throw new Error("Rate limit exceeded. Please try again later.");
             case 500:
-              throw new Error("Internal server error. Please try again later.");
+              throw new Error(data?.message || data?.error || "Internal server error. Please try again later.");
             default:
               throw new Error(data.message || "An error occurred");
           }
@@ -348,6 +349,89 @@ var IDENTITY_REGISTRY_ABI = parseAbi([
   "function register(string tokenUri, (string key, bytes value)[] metadata) external returns (uint256 agentId)"
 ]);
 var IDENTITY_REGISTRY_ADDRESS = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
+var VAULT_ABI = [
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "assets", type: "uint256" },
+      { name: "receiver", type: "address" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }]
+  },
+  {
+    name: "requestRedeem",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "shares", type: "uint256" },
+      { name: "controller", type: "address" },
+      { name: "owner", type: "address" }
+    ],
+    outputs: [{ name: "requestId", type: "uint256" }]
+  },
+  {
+    name: "claim",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "withdrawKey", type: "bytes32" }],
+    outputs: [{ name: "assets", type: "uint256" }]
+  },
+  {
+    name: "getWithdrawKey",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "nonce", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bytes32" }]
+  },
+  {
+    name: "nonces",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "isClaimable",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "withdrawKey", type: "bytes32" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "isClaimed",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "withdrawKey", type: "bytes32" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "maxRequestRedeem",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+];
+var VAULT_ADDRESS = "0xD580071c47d4a667858B5FafAb85BC9C609beC5D";
 
 // src/core/ZyfaiSDK.ts
 import { privateKeyToAccount } from "viem/accounts";
@@ -747,6 +831,13 @@ function convertStrategyToPublic(obj) {
     return result;
   }
 }
+function removeUnusedFields(obj) {
+  const result = { ...obj };
+  if ("hasStaleBalance" in result) {
+    delete result.hasStaleBalance;
+  }
+  return result;
+}
 function convertAssetInternally(asset) {
   if (asset === "USDC") {
     return "usdc";
@@ -1378,6 +1469,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * @param userAddress - User's EOA address (the connected EOA, not the smart wallet address)
    * @param chainId - Target chain ID
    * @param strategy - Optional strategy selection: "conservative" (default) or "aggressive"
+   * @param createSessionKey - If true, automatically creates a session key after deployment (default: false)
    * @returns Deployment response with Safe address and transaction hash
    *
    * @example
@@ -1387,9 +1479,12 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    *
    * // Deploy with aggressive strategy
    * await sdk.deploySafe(userAddress, 8453, "aggressive");
+   *
+   * // Deploy and automatically create session key
+   * await sdk.deploySafe(userAddress, 8453, "conservative", true);
    * ```
    */
-  async deploySafe(userAddress, chainId, strategy) {
+  async deploySafe(userAddress, chainId, strategy, createSessionKey) {
     try {
       if (!userAddress) {
         throw new Error("User address is required");
@@ -1421,11 +1516,24 @@ var _ZyfaiSDK = class _ZyfaiSDK {
         }
       }
       if (alreadyDeployed) {
+        let sessionKeyCreated2 = false;
+        if (createSessionKey) {
+          try {
+            await this.createSessionKey(userAddress, chainId);
+            sessionKeyCreated2 = true;
+          } catch (sessionKeyError) {
+            console.warn(
+              "Failed to create session key:",
+              sessionKeyError.message
+            );
+          }
+        }
         return {
           success: true,
           safeAddress,
           txHash: "0x0",
-          status: "deployed"
+          status: "deployed",
+          sessionKeyCreated: sessionKeyCreated2
         };
       }
       const internalStrategy = strategy ? toInternalStrategy(strategy) : "safe_strategy";
@@ -1447,11 +1555,24 @@ var _ZyfaiSDK = class _ZyfaiSDK {
           initError.message
         );
       }
+      let sessionKeyCreated = false;
+      if (createSessionKey) {
+        try {
+          await this.createSessionKey(userAddress, chainId);
+          sessionKeyCreated = true;
+        } catch (sessionKeyError) {
+          console.warn(
+            "Failed to create session key after Safe deployment:",
+            sessionKeyError.message
+          );
+        }
+      }
       return {
         success: true,
         safeAddress: deploymentResult.safeAddress,
         txHash: deploymentResult.txHash || "0x0",
-        status: "deployed"
+        status: "deployed",
+        sessionKeyCreated
       };
     } catch (error) {
       console.error("Safe deployment failed:", error);
@@ -1979,6 +2100,49 @@ var _ZyfaiSDK = class _ZyfaiSDK {
       throw new Error(`Failed to get positions: ${error.message}`);
     }
   }
+  /**
+   * Get all active positions and portfolio for a user
+   *
+   * @param userAddress - User's EOA address
+   * @param chainId - Optional: Filter by specific chain ID
+   * @returns User's positions across all protocols
+   *
+   * @example
+   * ```typescript
+   * // Get all positions across all chains
+   * const positions = await sdk.getPositions(userAddress);
+   *
+   * // Get positions on a specific chain
+   * const basePositions = await sdk.getPositions(userAddress, 8453);
+   * ```
+   */
+  async getPortfolio(userAddress) {
+    try {
+      if (!userAddress) {
+        throw new Error("User address is required");
+      }
+      const smartWalletInfo = await this.getSmartWalletByEOA(userAddress);
+      if (!smartWalletInfo.smartWallet) {
+        return {
+          success: true,
+          userAddress,
+          portfolio: {}
+        };
+      }
+      console.log("Getting portfolio for", smartWalletInfo.smartWallet);
+      const response = await this.httpClient.get(
+        ENDPOINTS.DATA_PORTFOLIO(smartWalletInfo.smartWallet)
+      );
+      const convertedResponse = removeUnusedFields(response);
+      return {
+        success: true,
+        userAddress,
+        portfolio: convertedResponse
+      };
+    } catch (error) {
+      throw new Error(`Failed to get positions: ${error.message}`);
+    }
+  }
   // ============================================================================
   // User Details Methods
   // ============================================================================
@@ -2297,9 +2461,6 @@ var _ZyfaiSDK = class _ZyfaiSDK {
         data: {
           walletAddress,
           totalEarningsByToken: response.total_earnings_by_token || {},
-          lifetimeEarningsByToken: response.lifetime_earnings_by_token || {},
-          currentEarningsByChain: response.current_earnings_by_chain || {},
-          unrealizedEarnings: response.unrealized_earnings || {},
           lastCheckTimestamp: response.last_check_timestamp,
           lastLogDate: response.last_log_date
         }
@@ -2338,9 +2499,6 @@ var _ZyfaiSDK = class _ZyfaiSDK {
         data: {
           walletAddress,
           totalEarningsByToken: data.total_earnings_by_token || {},
-          lifetimeEarningsByToken: data.lifetime_earnings_by_token || {},
-          currentEarningsByChain: data.current_earnings_by_chain || {},
-          unrealizedEarnings: data.unrealized_earnings || {},
           lastCheckTimestamp: data.last_check_timestamp,
           lastLogDate: data.last_log_date
         }
@@ -2373,10 +2531,17 @@ var _ZyfaiSDK = class _ZyfaiSDK {
       const response = await this.httpClient.dataGet(
         DATA_ENDPOINTS.DAILY_EARNINGS(walletAddress, startDate, endDate)
       );
+      const filteredData = (response.data || []).map((entry) => ({
+        wallet_address: entry.wallet_address,
+        snapshot_date: entry.snapshot_date,
+        total_earnings_by_token: entry.total_earnings_by_token,
+        daily_total_delta_by_token: entry.daily_total_delta_by_token,
+        created_at: entry.created_at
+      }));
       return {
         success: true,
         walletAddress,
-        data: response.data || [],
+        data: filteredData,
         count: response.count || 0,
         filters: {
           startDate: startDate || null,
@@ -2981,6 +3146,338 @@ var _ZyfaiSDK = class _ZyfaiSDK {
       );
     }
   }
+  // ============================================
+  // Vault Methods (Base only)
+  // ============================================
+  /**
+   * Deposit assets into the Zyfai Vault
+   * Currently only supports USDC on Base chain
+   *
+   * @param amount - Amount to deposit (in human readable format, e.g., "100" for 100 USDC)
+   * @param asset - Asset to deposit (default: "USDC")
+   * @returns Deposit transaction result
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.vaultDeposit("100", "USDC");
+   * console.log("Deposited:", result.txHash);
+   * ```
+   */
+  async vaultDeposit(amount, asset = "USDC", chainId = 8453) {
+    if (!this.walletClient?.account) {
+      throw new Error("Wallet not connected. Call connectAccount first.");
+    }
+    const userAddress = this.walletClient.account.address;
+    const chainConfig = getChainConfig(chainId, this.rpcUrls);
+    const tokenAddress = getDefaultTokenAddress(chainId, asset);
+    const decimals = 6;
+    const parsedAmount = BigInt(Math.floor(parseFloat(amount) * 10 ** decimals));
+    try {
+      const allowance = await chainConfig.publicClient.readContract({
+        address: tokenAddress,
+        abi: ERC20_ABI,
+        functionName: "allowance",
+        args: [userAddress, VAULT_ADDRESS]
+      });
+      if (allowance < parsedAmount) {
+        const approveTx = await this.walletClient.writeContract({
+          address: tokenAddress,
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [VAULT_ADDRESS, parsedAmount],
+          chain: chainConfig.chain,
+          account: this.walletClient.account
+        });
+        await chainConfig.publicClient.waitForTransactionReceipt({
+          hash: approveTx
+        });
+      }
+      const depositTx = await this.walletClient.writeContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "deposit",
+        args: [parsedAmount, userAddress],
+        chain: chainConfig.chain,
+        account: this.walletClient.account
+      });
+      const receipt = await chainConfig.publicClient.waitForTransactionReceipt({
+        hash: depositTx
+      });
+      if (receipt.status !== "success") {
+        throw new Error("Vault deposit transaction failed");
+      }
+      return {
+        success: true,
+        txHash: depositTx,
+        amount,
+        asset,
+        vaultAddress: VAULT_ADDRESS
+      };
+    } catch (error) {
+      throw new Error(`Vault deposit failed: ${error.message}`);
+    }
+  }
+  /**
+   * Request withdrawal from the Zyfai Vault
+   * Withdrawals are async - use getVaultWithdrawStatus and vaultClaim after
+   *
+   * @param shares - Amount of shares to redeem (optional, defaults to all shares)
+   * @returns Withdraw request result with withdrawKey
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.vaultWithdraw();
+   * console.log("Withdraw key:", result.withdrawKey);
+   * // Later, check status and claim
+   * ```
+   */
+  async vaultWithdraw(shares, chainId = 8453) {
+    if (!this.walletClient?.account) {
+      throw new Error("Wallet not connected. Call connectAccount first.");
+    }
+    const userAddress = this.walletClient.account.address;
+    const chainConfig = getChainConfig(chainId, this.rpcUrls);
+    try {
+      let sharesToRedeem;
+      if (shares) {
+        sharesToRedeem = BigInt(shares);
+      } else {
+        const maxShares = await chainConfig.publicClient.readContract({
+          address: VAULT_ADDRESS,
+          abi: VAULT_ABI,
+          functionName: "maxRequestRedeem",
+          args: [userAddress]
+        });
+        if (maxShares === 0n) {
+          throw new Error("No shares available to redeem or withdrawals are paused");
+        }
+        sharesToRedeem = maxShares;
+      }
+      const redeemTx = await this.walletClient.writeContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "requestRedeem",
+        args: [sharesToRedeem, userAddress, userAddress],
+        chain: chainConfig.chain,
+        account: this.walletClient.account
+      });
+      await chainConfig.publicClient.waitForTransactionReceipt({
+        hash: redeemTx
+      });
+      const nonceResult = await chainConfig.publicClient.readContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "nonces",
+        args: [userAddress]
+      });
+      const nonce = BigInt(nonceResult);
+      if (nonce === 0n) {
+        throw new Error("Nonce is 0 after requestRedeem - unexpected state");
+      }
+      const withdrawKey = await chainConfig.publicClient.readContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "getWithdrawKey",
+        args: [userAddress, nonce - 1n]
+      });
+      const isClaimable = await chainConfig.publicClient.readContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "isClaimable",
+        args: [withdrawKey]
+      });
+      return {
+        success: true,
+        txHash: redeemTx,
+        withdrawKey,
+        status: isClaimable ? "claimable" : "pending"
+      };
+    } catch (error) {
+      throw new Error(`Vault withdraw request failed: ${error.message}`);
+    }
+  }
+  /**
+   * Get the status of a pending withdrawal
+   *
+   * @param withdrawKey - The withdraw key to check (optional, gets latest if not provided)
+   * @returns Withdraw status
+   *
+   * @example
+   * ```typescript
+   * const status = await sdk.getVaultWithdrawStatus();
+   * if (status.isClaimable) {
+   *   await sdk.vaultClaim(status.withdrawKey);
+   * }
+   * ```
+   */
+  async getVaultWithdrawStatus(withdrawKey, chainId = 8453) {
+    if (!this.walletClient?.account) {
+      throw new Error("Wallet not connected. Call connectAccount first.");
+    }
+    const userAddress = this.walletClient.account.address;
+    const chainConfig = getChainConfig(chainId, this.rpcUrls);
+    try {
+      const nonceResult = await chainConfig.publicClient.readContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "nonces",
+        args: [userAddress]
+      });
+      const nonce = BigInt(nonceResult);
+      if (nonce === 0n) {
+        return {
+          success: true,
+          withdrawKey: null,
+          isClaimable: false,
+          isPending: false,
+          nonce: 0n
+        };
+      }
+      let keyToCheck = withdrawKey;
+      if (!keyToCheck) {
+        keyToCheck = await chainConfig.publicClient.readContract({
+          address: VAULT_ADDRESS,
+          abi: VAULT_ABI,
+          functionName: "getWithdrawKey",
+          args: [userAddress, nonce - 1n]
+        });
+      }
+      const [isClaimable, isClaimed] = await Promise.all([
+        chainConfig.publicClient.readContract({
+          address: VAULT_ADDRESS,
+          abi: VAULT_ABI,
+          functionName: "isClaimable",
+          args: [keyToCheck]
+        }),
+        chainConfig.publicClient.readContract({
+          address: VAULT_ADDRESS,
+          abi: VAULT_ABI,
+          functionName: "isClaimed",
+          args: [keyToCheck]
+        })
+      ]);
+      if (isClaimed) {
+        return {
+          success: true,
+          withdrawKey: null,
+          isClaimable: false,
+          isPending: false,
+          nonce
+        };
+      }
+      return {
+        success: true,
+        withdrawKey: keyToCheck,
+        isClaimable,
+        isPending: !isClaimable,
+        nonce
+      };
+    } catch (error) {
+      throw new Error(`Failed to get withdraw status: ${error.message}`);
+    }
+  }
+  /**
+   * Claim a completed withdrawal from the Zyfai Vault
+   *
+   * @param withdrawKey - The withdraw key to claim
+   * @returns Claim transaction result
+   *
+   * @example
+   * ```typescript
+   * const status = await sdk.getVaultWithdrawStatus();
+   * if (status.isClaimable) {
+   *   const claim = await sdk.vaultClaim(status.withdrawKey);
+   *   console.log("Claimed:", claim.txHash);
+   * }
+   * ```
+   */
+  async vaultClaim(withdrawKey, chainId = 8453) {
+    if (!this.walletClient?.account) {
+      throw new Error("Wallet not connected. Call connectAccount first.");
+    }
+    if (!withdrawKey) {
+      throw new Error("Withdraw key is required");
+    }
+    const chainConfig = getChainConfig(chainId, this.rpcUrls);
+    try {
+      const isClaimable = await chainConfig.publicClient.readContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "isClaimable",
+        args: [withdrawKey]
+      });
+      if (!isClaimable) {
+        const isClaimed = await chainConfig.publicClient.readContract({
+          address: VAULT_ADDRESS,
+          abi: VAULT_ABI,
+          functionName: "isClaimed",
+          args: [withdrawKey]
+        });
+        if (isClaimed) {
+          throw new Error("This withdrawal has already been claimed");
+        }
+        throw new Error("Withdrawal is not yet claimable. Please wait for processing.");
+      }
+      const claimTx = await this.walletClient.writeContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "claim",
+        args: [withdrawKey],
+        chain: chainConfig.chain,
+        account: this.walletClient.account
+      });
+      const receipt = await chainConfig.publicClient.waitForTransactionReceipt({
+        hash: claimTx
+      });
+      if (receipt.status !== "success") {
+        throw new Error("Vault claim transaction failed");
+      }
+      return {
+        success: true,
+        txHash: claimTx,
+        claimed: true
+      };
+    } catch (error) {
+      throw new Error(`Vault claim failed: ${error.message}`);
+    }
+  }
+  /**
+   * Get vault shares info for the connected wallet
+   *
+   * @param userAddress - Optional user address (defaults to connected wallet)
+   * @returns Vault shares balance and token symbol
+   *
+   * @example
+   * ```typescript
+   * const { shares, symbol } = await sdk.getVaultShares();
+   * console.log(`Balance: ${shares} ${symbol}`);
+   * ```
+   */
+  async getVaultShares(userAddress, chainId = 8453) {
+    const address = userAddress || this.walletClient?.account?.address;
+    if (!address) {
+      throw new Error("User address required. Provide address or connect wallet first.");
+    }
+    const chainConfig = getChainConfig(chainId, this.rpcUrls);
+    const [shareBalance, tokenSymbol] = await Promise.all([
+      chainConfig.publicClient.readContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "balanceOf",
+        args: [address]
+      }),
+      chainConfig.publicClient.readContract({
+        address: VAULT_ADDRESS,
+        abi: VAULT_ABI,
+        functionName: "symbol"
+      })
+    ]);
+    return {
+      success: true,
+      shares: shareBalance,
+      symbol: tokenSymbol
+    };
+  }
 };
 // ============================================================================
 // Agent Identity Registry
@@ -2990,9 +3487,177 @@ var _ZyfaiSDK = class _ZyfaiSDK {
  */
 _ZyfaiSDK.IDENTITY_REGISTRY_CHAIN_IDS = [8453, 42161];
 var ZyfaiSDK = _ZyfaiSDK;
+
+// src/providers/bankr.ts
+function createBankrProvider(config) {
+  const {
+    apiKey,
+    baseUrl = "https://api.bankr.bot",
+    chainId = 8453
+  } = config;
+  if (!apiKey) {
+    throw new Error("Bankr API key is required");
+  }
+  let cachedWalletAddress = null;
+  const fetchBankr = async (endpoint, body) => {
+    const response = await fetch(`${baseUrl}${endpoint}`, {
+      method: body ? "POST" : "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": apiKey
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.message || errorData.error || `Bankr API error: ${response.status}`);
+    }
+    return response.json();
+  };
+  const getWalletAddress = async () => {
+    if (cachedWalletAddress) {
+      return cachedWalletAddress;
+    }
+    const data = await fetchBankr("/agent/me");
+    const evmWallet = data.wallets?.find((w) => w.chain === "evm");
+    if (!evmWallet?.address) {
+      throw new Error("No EVM wallet found in Bankr account");
+    }
+    cachedWalletAddress = evmWallet.address;
+    return evmWallet.address;
+  };
+  const provider = {
+    /**
+     * EIP-1193 request method
+     * Routes RPC calls to appropriate Bankr API endpoints
+     */
+    async request({ method, params }) {
+      switch (method) {
+        case "eth_requestAccounts":
+        case "eth_accounts": {
+          const address = await getWalletAddress();
+          return [address];
+        }
+        case "eth_chainId": {
+          return `0x${chainId.toString(16)}`;
+        }
+        case "net_version": {
+          return chainId.toString();
+        }
+        case "personal_sign": {
+          const [messageHex, address] = params || [];
+          let message = messageHex;
+          if (typeof messageHex === "string" && messageHex.startsWith("0x")) {
+            const isRawHash = messageHex.length === 66;
+            if (!isRawHash) {
+              try {
+                message = Buffer.from(messageHex.slice(2), "hex").toString("utf8");
+              } catch {
+                message = messageHex;
+              }
+            }
+          }
+          const data = await fetchBankr("/agent/sign", {
+            signatureType: "personal_sign",
+            message
+          });
+          if (!data.success || !data.signature) {
+            throw new Error(data.error || "Bankr signing failed");
+          }
+          return data.signature;
+        }
+        case "eth_signTypedData":
+        case "eth_signTypedData_v4": {
+          const [address, typedDataString] = params || [];
+          const typedData = typeof typedDataString === "string" ? JSON.parse(typedDataString) : typedDataString;
+          const data = await fetchBankr("/agent/sign", {
+            signatureType: "eth_signTypedData_v4",
+            typedData
+          });
+          if (!data.success || !data.signature) {
+            throw new Error(data.error || "Bankr typed data signing failed");
+          }
+          return data.signature;
+        }
+        case "eth_sendTransaction": {
+          const [tx] = params || [];
+          const signData = await fetchBankr("/agent/sign", {
+            signatureType: "eth_signTransaction",
+            transaction: {
+              to: tx.to,
+              chainId: tx.chainId ? parseInt(tx.chainId, 16) : chainId,
+              value: tx.value || "0",
+              data: tx.data || "0x",
+              gas: tx.gas,
+              gasLimit: tx.gasLimit,
+              maxFeePerGas: tx.maxFeePerGas,
+              maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+              nonce: tx.nonce
+            }
+          });
+          if (!signData.success || !signData.signature) {
+            throw new Error(signData.error || "Bankr transaction signing failed");
+          }
+          const submitData = await fetchBankr("/agent/submit", {
+            signedTransaction: signData.signature,
+            chainId: tx.chainId ? parseInt(tx.chainId, 16) : chainId
+          });
+          if (!submitData.success) {
+            throw new Error(submitData.error || "Bankr transaction submission failed");
+          }
+          return submitData.transactionHash || submitData.txHash;
+        }
+        case "eth_signTransaction": {
+          const [tx] = params || [];
+          const data = await fetchBankr("/agent/sign", {
+            signatureType: "eth_signTransaction",
+            transaction: {
+              to: tx.to,
+              chainId: tx.chainId ? parseInt(tx.chainId, 16) : chainId,
+              value: tx.value || "0",
+              data: tx.data || "0x",
+              gas: tx.gas,
+              gasLimit: tx.gasLimit,
+              maxFeePerGas: tx.maxFeePerGas,
+              maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+              nonce: tx.nonce
+            }
+          });
+          if (!data.success || !data.signature) {
+            throw new Error(data.error || "Bankr transaction signing failed");
+          }
+          return data.signature;
+        }
+        case "wallet_switchEthereumChain": {
+          return null;
+        }
+        default:
+          throw new Error(`Unsupported method: ${method}. Bankr provider supports: eth_requestAccounts, eth_accounts, eth_chainId, personal_sign, eth_signTypedData_v4, eth_sendTransaction, eth_signTransaction`);
+      }
+    },
+    /**
+     * Event listener stub (required by EIP-1193)
+     * Bankr API doesn't support real-time events
+     */
+    on: (event, callback) => {
+    },
+    /**
+     * Remove event listener stub (required by EIP-1193)
+     */
+    removeListener: (event, callback) => {
+    },
+    /**
+     * Check if this is a Bankr provider
+     */
+    isBankr: true
+  };
+  return provider;
+}
 export {
   DEFAULT_TOKEN_ADDRESSES,
+  VAULT_ADDRESS,
   ZyfaiSDK,
+  createBankrProvider,
   getChainConfig,
   getDefaultTokenAddress,
   getSupportedChainIds,