@zubari/sdk 0.2.7 → 0.3.0

package/dist/services/index.mjs

@@ -13,111 +13,171 @@ var __export = (target, all) => {
 };
 
 // src/config/contracts.ts
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var ZUBARI_CONTRACTS = {
-  testnet: {
-    // Ethereum Sepolia (11155111) - Deployed 2024-12-30
-    registry: "0xe5CE1Eb986f58BE42EEDFe5C18ee5956803b2BDC",
-    nft: "0xCb1AB134a75c4D504792233efC5dE949aDE3f29f",
-    marketplace: "0xfcEfDa6C73aC357b8695E5F8F8d17820750BF207",
-    tips: "0x86a9A306C7fCC9e0B8cd6859f6f15498d0046BB7",
-    subscriptions: "0xaB7F17A85F61d9ab9f96bCB4e73e910D019978F7",
-    payouts: "0x8aaB23Fb2a83A259E965Aae8Ee0938b1400B7E6b",
-    entryPoint: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-    paymaster: ZERO_ADDRESS,
-    // Deploy with: npx hardhat run deploy/deploy.ts --network ethereum-sepolia
-    accountFactory: ZERO_ADDRESS,
-    // Not yet deployed
-    usdt: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0",
-    // USDT on Sepolia
-    weth: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"
-  },
-  mainnet: {
-    // Ethereum Mainnet (1)
-    registry: ZERO_ADDRESS,
-    nft: ZERO_ADDRESS,
-    marketplace: ZERO_ADDRESS,
-    tips: ZERO_ADDRESS,
-    subscriptions: ZERO_ADDRESS,
-    payouts: ZERO_ADDRESS,
-    entryPoint: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-    paymaster: ZERO_ADDRESS,
-    accountFactory: ZERO_ADDRESS,
-    usdt: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
-    // USDT on Ethereum
-    weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-  }
-};
 var PLATFORM_CONFIG = {
   // Default slippage tolerance for swaps (50 = 0.5%)
-  defaultSlippageBps: 50};
-function getContractAddresses(network) {
-  return ZUBARI_CONTRACTS[network];
-}
+  defaultSlippageBps: 50,
+  // Swap deadline in seconds (30 minutes)
+  swapDeadlineSecs: 30 * 60
+};
 
 // src/services/SwapService.ts
+var UNISWAP_ADDRESSES = {
+  mainnet: {
+    swapRouter: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+    quoter: "0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6",
+    factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984"
+  },
+  sepolia: {
+    swapRouter: "0x3bFA4769FB09eefC5a80d6E87c3B9C650f7Ae48E",
+    quoter: "0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3",
+    factory: "0x0227628f3F023bb0B980b67D528571c95c6DaC1c"
+  }
+};
+var UNISWAP_SELECTORS = {
+  quoteExactInputSingle: "0xf7729d43",
+  // quoteExactInputSingle(address,address,uint24,uint256,uint160)
+  exactInputSingle: "0x414bf389"
+  // exactInputSingle((address,address,uint24,address,uint256,uint256,uint256,uint160))
+};
+var TOKENS = {
+  mainnet: {
+    WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+  },
+  sepolia: {
+    WETH: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+    USDT: "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06",
+    USDC: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+  }
+};
+var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
 var SwapService = class {
-  _chainId;
+  chainId;
   isTestnet;
+  addresses;
+  tokens;
   constructor(chainId, isTestnet = false) {
-    this._chainId = chainId;
+    this.chainId = chainId;
     this.isTestnet = isTestnet;
+    this.addresses = isTestnet ? UNISWAP_ADDRESSES.sepolia : UNISWAP_ADDRESSES.mainnet;
+    this.tokens = isTestnet ? TOKENS.sepolia : TOKENS.mainnet;
   }
   /**
-   * Get a swap quote
+   * Get a swap quote from Uniswap V3 Quoter
    */
-  async getQuote(tokenIn, tokenOut, amountIn) {
+  async getQuote(tokenIn, tokenOut, amountIn, provider) {
     if (amountIn <= 0n) {
       throw new Error("Amount must be greater than 0");
     }
-    return {
-      tokenIn,
-      tokenOut,
-      amountIn,
-      amountOut: BigInt(0),
-      priceImpact: 0,
-      route: [tokenIn, tokenOut],
-      estimatedGas: BigInt(0)
-    };
+    const actualTokenIn = tokenIn === ETH_ADDRESS ? this.tokens.WETH : tokenIn;
+    const actualTokenOut = tokenOut === ETH_ADDRESS ? this.tokens.WETH : tokenOut;
+    if (!provider) {
+      console.warn("No provider for quote, returning estimate");
+      return {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        amountOut: amountIn * BigInt(95) / BigInt(100),
+        // Rough estimate
+        priceImpact: 0.5,
+        route: [tokenIn, tokenOut],
+        estimatedGas: BigInt(15e4)
+      };
+    }
+    try {
+      const encodedTokenIn = actualTokenIn.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedTokenOut = actualTokenOut.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedFee = 3e3.toString(16).padStart(64, "0");
+      const encodedAmountIn = amountIn.toString(16).padStart(64, "0");
+      const encodedSqrtPriceLimit = "0".padStart(64, "0");
+      const data = `${UNISWAP_SELECTORS.quoteExactInputSingle}${encodedTokenIn}${encodedTokenOut}${encodedFee}${encodedAmountIn}${encodedSqrtPriceLimit}`;
+      const result = await provider.call({
+        to: this.addresses.quoter,
+        data
+      });
+      const amountOut = BigInt(result);
+      const priceImpact = this.calculatePriceImpact(amountIn, amountOut, tokenIn, tokenOut);
+      return {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        amountOut,
+        priceImpact,
+        route: [tokenIn, tokenOut],
+        estimatedGas: BigInt(15e4)
+      };
+    } catch (error) {
+      console.error("Failed to get quote:", error);
+      throw new Error(`Quote failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
-   * Execute a swap with slippage protection
+   * Execute a swap with slippage protection via Uniswap V3 SwapRouter
    */
-  async executeSwap(quote, slippageToleranceBps = PLATFORM_CONFIG.defaultSlippageBps) {
-    quote.amountOut - quote.amountOut * BigInt(slippageToleranceBps) / BigInt(1e4);
+  async executeSwap(quote, signer, recipient, slippageToleranceBps = PLATFORM_CONFIG.defaultSlippageBps) {
+    const minAmountOut = quote.amountOut - quote.amountOut * BigInt(slippageToleranceBps) / BigInt(1e4);
+    const deadline = Math.floor(Date.now() / 1e3) + PLATFORM_CONFIG.swapDeadlineSecs;
     if (quote.priceImpact > 5) {
       console.warn(`High price impact: ${quote.priceImpact}%`);
     }
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+    const actualTokenIn = quote.tokenIn === ETH_ADDRESS ? this.tokens.WETH : quote.tokenIn;
+    const actualTokenOut = quote.tokenOut === ETH_ADDRESS ? this.tokens.WETH : quote.tokenOut;
+    const isETHIn = quote.tokenIn === ETH_ADDRESS;
+    try {
+      const encodedTokenIn = actualTokenIn.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedTokenOut = actualTokenOut.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedFee = 3e3.toString(16).padStart(64, "0");
+      const encodedRecipient = recipient.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedDeadline = deadline.toString(16).padStart(64, "0");
+      const encodedAmountIn = quote.amountIn.toString(16).padStart(64, "0");
+      const encodedMinAmountOut = minAmountOut.toString(16).padStart(64, "0");
+      const encodedSqrtPriceLimit = "0".padStart(64, "0");
+      const data = `${UNISWAP_SELECTORS.exactInputSingle}${encodedTokenIn}${encodedTokenOut}${encodedFee}${encodedRecipient}${encodedDeadline}${encodedAmountIn}${encodedMinAmountOut}${encodedSqrtPriceLimit}`;
+      const tx = await signer.sendTransaction({
+        to: this.addresses.swapRouter,
+        data,
+        value: isETHIn ? `0x${quote.amountIn.toString(16)}` : "0x0"
+      });
+      return {
+        hash: tx.hash,
+        network: "ethereum",
+        status: "pending",
+        metadata: {
+          tokenIn: quote.tokenIn,
+          tokenOut: quote.tokenOut,
+          amountIn: quote.amountIn.toString(),
+          minAmountOut: minAmountOut.toString(),
+          deadline
+        }
+      };
+    } catch (error) {
+      console.error("Failed to execute swap:", error);
+      throw new Error(`Swap failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
    * Convert earnings to USDT, keeping some ETH for gas
    */
-  async convertEarningsToStable(ethBalance, reserveForGas = BigInt("10000000000000000")) {
+  async convertEarningsToStable(ethBalance, signer, recipient, provider, reserveForGas = BigInt("10000000000000000")) {
     const amountToSwap = ethBalance - reserveForGas;
     if (amountToSwap <= 0n) {
       throw new Error("Insufficient balance after gas reserve");
     }
-    const contracts = getContractAddresses(this.isTestnet ? "testnet" : "mainnet");
     const quote = await this.getQuote(
-      "0x0000000000000000000000000000000000000000",
-      // ETH
-      contracts.usdt,
-      // USDT on Ethereum
-      amountToSwap
+      ETH_ADDRESS,
+      this.tokens.USDT,
+      amountToSwap,
+      provider
     );
-    return this.executeSwap(quote);
+    return this.executeSwap(quote, signer, recipient);
   }
   /**
    * Check if a swap route exists
    */
-  async hasRoute(tokenIn, tokenOut) {
+  async hasRoute(tokenIn, tokenOut, provider) {
     try {
-      const quote = await this.getQuote(tokenIn, tokenOut, BigInt(1));
+      const quote = await this.getQuote(tokenIn, tokenOut, BigInt(10 ** 18), provider);
       return quote.amountOut > 0n;
     } catch {
       return false;
@@ -127,7 +187,28 @@ var SwapService = class {
    * Get supported tokens for swapping
    */
   async getSupportedTokens() {
-    return [];
+    return [
+      { address: ETH_ADDRESS, symbol: "ETH", decimals: 18, name: "Ether" },
+      { address: this.tokens.WETH, symbol: "WETH", decimals: 18, name: "Wrapped Ether" },
+      { address: this.tokens.USDT, symbol: "USDT", decimals: 6, name: "Tether USD" },
+      { address: this.tokens.USDC, symbol: "USDC", decimals: 6, name: "USD Coin" }
+    ];
+  }
+  /**
+   * Get Uniswap router address for approvals
+   */
+  getRouterAddress() {
+    return this.addresses.swapRouter;
+  }
+  /**
+   * Calculate price impact (simplified)
+   */
+  calculatePriceImpact(amountIn, amountOut, _tokenIn, _tokenOut) {
+    if (amountIn === 0n || amountOut === 0n) return 0;
+    const expectedOut = amountIn;
+    const actualRatio = Number(amountOut) / Number(expectedOut);
+    const impact = (1 - actualRatio) * 100;
+    return Math.max(0, impact);
   }
 };