Fusion refactor limit order v4

sdk-clients/aggregation/examples/approve_and_swap/main.go

@@ -0,0 +1,148 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"math/big"
+	"os"
+	"time"
+
+	"github.com/1inch/1inch-sdk-go/constants"
+	"github.com/1inch/1inch-sdk-go/sdk-clients/aggregation"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+var (
+	privateKey     = os.Getenv("WALLET_KEY")
+	nodeUrl        = os.Getenv("NODE_URL")
+	devPortalToken = os.Getenv("DEV_PORTAL_TOKEN")
+)
+
+const (
+	UsdcBase   = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+	WethBase   = "0x4200000000000000000000000000000000000006"
+	amountUsdc = "100000" // 0.1 USDC (6 decimals)
+)
+
+func main() {
+	config, err := aggregation.NewConfiguration(aggregation.ConfigurationParams{
+		NodeUrl:    nodeUrl,
+		PrivateKey: privateKey,
+		ChainId:    constants.BaseChainId,
+		ApiUrl:     "https://api.1inch.dev",
+		ApiKey:     devPortalToken,
+	})
+	if err != nil {
+		log.Fatalf("Failed to create configuration: %v\n", err)
+	}
+	client, err := aggregation.NewClient(config)
+	if err != nil {
+		log.Fatalf("Failed to create client: %v\n", err)
+	}
+	ctx := context.Background()
+
+	walletAddr := client.Wallet.Address().Hex()
+
+	// Step 1: Check Allowance
+	allowanceData, err := client.GetApproveAllowance(ctx, aggregation.GetAllowanceParams{
+		TokenAddress:  UsdcBase,
+		WalletAddress: walletAddr,
+	})
+	if err != nil {
+		log.Fatalf("Failed to get allowance: %v\n", err)
+	}
+	allowance := new(big.Int)
+	allowance.SetString(allowanceData.Allowance, 10)
+
+	amountToSwap := new(big.Int)
+	amountToSwap.SetString(amountUsdc, 10)
+
+	// Step 2: Approve if needed
+	if allowance.Cmp(amountToSwap) < 0 {
+		fmt.Println("Insufficient allowance. Approving...")
+		approveData, err := client.GetApproveTransaction(ctx, aggregation.GetApproveParams{
+			TokenAddress: UsdcBase,
+			Amount:       amountUsdc,
+		})
+		if err != nil {
+			log.Fatalf("Failed to get approve data: %v\n", err)
+		}
+		data, err := hexutil.Decode(approveData.Data)
+		if err != nil {
+			log.Fatalf("Failed to decode approve data: %v\n", err)
+		}
+		to := common.HexToAddress(approveData.To)
+
+		tx, err := client.TxBuilder.New().SetData(data).SetTo(&to).Build(ctx)
+		if err != nil {
+			log.Fatalf("Failed to build approve transaction: %v\n", err)
+		}
+		signedTx, err := client.Wallet.Sign(tx)
+		if err != nil {
+			log.Fatalf("Failed to sign approve transaction: %v\n", err)
+		}
+		err = client.Wallet.BroadcastTransaction(ctx, signedTx)
+		if err != nil {
+			log.Fatalf("Failed to broadcast approve transaction: %v\n", err)
+		}
+
+		fmt.Printf("Approve transaction sent: https://basescan.org/tx/%s\n", signedTx.Hash().Hex())
+
+		// Wait for approval to be mined
+		for {
+			receipt, _ := client.Wallet.TransactionReceipt(ctx, signedTx.Hash())
+			if receipt != nil {
+				fmt.Println("Approve transaction confirmed.")
+				break
+			}
+			time.Sleep(2 * time.Second)
+		}
+	} else {
+		fmt.Println("Sufficient allowance already present.")
+	}
+
+	// Step 3: Perform Swap
+	swapData, err := client.GetSwap(ctx, aggregation.GetSwapParams{
+		Src:      UsdcBase,
+		Dst:      WethBase,
+		Amount:   amountUsdc,
+		From:     walletAddr,
+		Slippage: 1, // 1% slippage
+	})
+	if err != nil {
+		log.Fatalf("Failed to get swap data: %v\n", err)
+	}
+
+	tx, err := client.TxBuilder.New().
+		SetData(swapData.TxNormalized.Data).
+		SetTo(&swapData.TxNormalized.To).
+		SetGas(swapData.TxNormalized.Gas).
+		SetValue(swapData.TxNormalized.Value).
+		Build(ctx)
+	if err != nil {
+		log.Fatalf("Failed to build transaction: %v\n", err)
+	}
+	signedTx, err := client.Wallet.Sign(tx)
+	if err != nil {
+		log.Fatalf("Failed to sign transaction: %v\n", err)
+	}
+
+	err = client.Wallet.BroadcastTransaction(ctx, signedTx)
+	if err != nil {
+		log.Fatalf("Failed to broadcast transaction: %v\n", err)
+	}
+
+	fmt.Printf("Swap transaction sent: https://basescan.org/tx/%s\n", signedTx.Hash().Hex())
+
+	// Wait for swap transaction to be mined
+	for {
+		receipt, _ := client.Wallet.TransactionReceipt(ctx, signedTx.Hash())
+		if receipt != nil {
+			fmt.Println("Swap transaction confirmed!")
+			break
+		}
+		time.Sleep(2 * time.Second)
+	}
+}

sdk-clients/aggregation/examples/swap/main.go

@@ -24,17 +24,17 @@ var (
 )
 
 const (
-	PolygonPol  = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
-	PolygonUsdc = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
-	amountPol   = "1000000000000000000"
-	amountUsdc  = "100000"
+	UsdcBase   = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+	WethBase   = "0x4200000000000000000000000000000000000006"
+	amountWeth = "10000000000000000"
+	amountUsdc = "100000"
 )
 
 func main() {
 	config, err := aggregation.NewConfiguration(aggregation.ConfigurationParams{
 		NodeUrl:    nodeUrl,
 		PrivateKey: privateKey,
-		ChainId:    constants.PolygonChainId,
+		ChainId:    constants.BaseChainId,
 		ApiUrl:     "https://api.1inch.dev",
 		ApiKey:     devPortalToken,
 	})
@@ -48,8 +48,8 @@ func main() {
 	ctx := context.Background()
 
 	swapData, err := client.GetSwap(ctx, aggregation.GetSwapParams{
-		Src:      PolygonUsdc,
-		Dst:      PolygonPol,
+		Src:      UsdcBase,
+		Dst:      WethBase,
 		Amount:   amountUsdc,
 		From:     client.Wallet.Address().Hex(),
 		Slippage: 1,

sdk-clients/orderbook/api.go

@@ -12,7 +12,7 @@ import (
 
 // CreateOrder creates an order in the Limit Order Protocol
 func (api *api) CreateOrder(ctx context.Context, params CreateOrderParams) (*CreateOrderResponse, error) {
-	u := fmt.Sprintf("/orderbook/v4.0/%d", api.chainId)
+	u := fmt.Sprintf("/orderbook/v4.1/%d", api.chainId)
 
 	err := params.Validate()
 	if err != nil {
@@ -49,8 +49,6 @@ func (api *api) CreateOrder(ctx context.Context, params CreateOrderParams) (*Cre
 	return &createOrderResponse, nil
 }
 
-// TODO Reusing the same request/response objects until the openapi spec is updated to include the correct object definitions
-
 // GetOrdersByCreatorAddress returns all orders created by a given address in the Limit Order Protocol
 func (api *api) GetOrdersByCreatorAddress(ctx context.Context, params GetOrdersByCreatorAddressParams) ([]*OrderResponse, error) {
 	u := fmt.Sprintf("/orderbook/v4.0/%d/address/%s", api.chainId, params.CreatorAddress)
@@ -77,7 +75,7 @@ func (api *api) GetOrdersByCreatorAddress(ctx context.Context, params GetOrdersB
 
 // GetOrder returns an order from Limit Order Protocol that matches a specific hash
 func (api *api) GetOrder(ctx context.Context, params GetOrderParams) (*GetOrderByHashResponseExtended, error) {
-	u := fmt.Sprintf("/orderbook/v4.0/%d/order/%s", api.chainId, params.OrderHash)
+	u := fmt.Sprintf("/orderbook/v4.1/%d/order/%s", api.chainId, params.OrderHash)
 
 	err := params.Validate()
 	if err != nil {
@@ -99,6 +97,30 @@ func (api *api) GetOrder(ctx context.Context, params GetOrderParams) (*GetOrderB
 	return NormalizeGetOrderByHashResponse(getOrderByHashResponse)
 }
 
+// GetOrderCount returns the number of orders for a given trading pair with a specific status
+func (api *api) GetOrderCount(ctx context.Context, params GetOrderCountParams) (*GetOrderCountResponse, error) {
+	u := fmt.Sprintf("/orderbook/v4.1/%d/count", api.chainId)
+
+	err := params.Validate()
+	if err != nil {
+		return nil, err
+	}
+
+	payload := common.RequestPayload{
+		Method: "GET",
+		Params: params,
+		U:      u,
+	}
+
+	var response GetOrderCountResponse
+	err = api.httpExecutor.ExecuteRequest(ctx, payload, &response)
+	if err != nil {
+		return nil, err
+	}
+
+	return &response, nil
+}
+
 // GetOrderWithSignature first looks up an order by hash, then does a second request to get the signature data
 func (api *api) GetOrderWithSignature(ctx context.Context, params GetOrderParams) (*OrderExtendedWithSignature, error) {
 
@@ -115,7 +137,7 @@ func (api *api) GetOrderWithSignature(ctx context.Context, params GetOrderParams
 
 	// Second, lookup all orders by that creator (these orders will contain the signature data)
 	allOrdersByCreator, err := api.GetOrdersByCreatorAddress(ctx, GetOrdersByCreatorAddressParams{
-		CreatorAddress: order.OrderMaker,
+		CreatorAddress: order.Data.Maker,
 	})
 	if err != nil {
 		return nil, err
@@ -136,8 +158,8 @@ func (api *api) GetOrderWithSignature(ctx context.Context, params GetOrderParams
 }
 
 // GetAllOrders returns all orders in the Limit Order Protocol
-func (api *api) GetAllOrders(ctx context.Context, params GetAllOrdersParams) ([]OrderResponse, error) {
-	u := fmt.Sprintf("/orderbook/v3.0/%d/all", api.chainId)
+func (api *api) GetAllOrders(ctx context.Context, params GetAllOrdersParams) (*Orders, error) {
+	u := fmt.Sprintf("/orderbook/v4.1/%d/all", api.chainId)
 
 	err := params.Validate()
 	if err != nil {
@@ -150,92 +172,17 @@ func (api *api) GetAllOrders(ctx context.Context, params GetAllOrdersParams) ([]
 		U:      u,
 	}
 
-	var allOrdersResponse []OrderResponse
+	var allOrdersResponse Orders
 	err = api.httpExecutor.ExecuteRequest(ctx, payload, &allOrdersResponse)
 	if err != nil {
 		return nil, err
 	}
 
-	return allOrdersResponse, nil
-}
-
-// GetCount returns the number of orders in the Limit Order Protocol
-func (api *api) GetCount(ctx context.Context, params GetCountParams) (*CountResponse, error) {
-	u := fmt.Sprintf("/orderbook/v3.0/%d/count", api.chainId)
-
-	err := params.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	payload := common.RequestPayload{
-		Method: "GET",
-		Params: params,
-		U:      u,
-	}
-
-	var count CountResponse
-	err = api.httpExecutor.ExecuteRequest(ctx, payload, &count)
-	if err != nil {
-		return nil, err
-	}
-
-	return &count, nil
+	return &allOrdersResponse, nil
 }
 
-// GetEvent returns an event in the Limit Order Protocol by order hash
-func (api *api) GetEvent(ctx context.Context, params GetEventParams) (*EventResponse, error) {
-	u := fmt.Sprintf("/orderbook/v3.0/%d/events/%s", api.chainId, params.OrderHash)
-
-	err := params.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	payload := common.RequestPayload{
-		Method: "GET",
-		Params: params,
-		U:      u,
-	}
-
-	var event EventResponse
-	err = api.httpExecutor.ExecuteRequest(ctx, payload, &event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &event, nil
-}
-
-// GetEvents returns all events in the Limit Order Protocol
-func (api *api) GetEvents(ctx context.Context, params GetEventsParams) ([]EventResponse, error) {
-	u := fmt.Sprintf("/orderbook/v3.0/%d/events", api.chainId)
-
-	err := params.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	payload := common.RequestPayload{
-		Method: "GET",
-		Params: params,
-		U:      u,
-	}
-
-	var events []EventResponse
-	err = api.httpExecutor.ExecuteRequest(ctx, payload, &events)
-	if err != nil {
-		return nil, err
-	}
-
-	return events, nil
-}
-
-// TODO untested endpoint
-
-// GetActiveOrdersWithPermit returns all orders in the Limit Order Protocol that are active and have a valid permit
-func (api *api) GetActiveOrdersWithPermit(ctx context.Context, params GetActiveOrdersWithPermitParams) ([]OrderResponse, error) {
-	u := fmt.Sprintf("/orderbook/v3.0/%d/has-active-orders-with-permit/%s/%s", api.chainId, params.Token, params.Wallet)
+func (api *api) GetFeeInfo(ctx context.Context, params GetFeeInfoParams) (*FeeInfoResponse, error) {
+	u := fmt.Sprintf("/orderbook/v4.0/%d/fee-info", api.chainId)
 
 	err := params.Validate()
 	if err != nil {
@@ -248,11 +195,11 @@ func (api *api) GetActiveOrdersWithPermit(ctx context.Context, params GetActiveO
 		U:      u,
 	}
 
-	var orders []OrderResponse
-	err = api.httpExecutor.ExecuteRequest(ctx, payload, &orders)
+	var feeInfo *FeeInfoResponse
+	err = api.httpExecutor.ExecuteRequest(ctx, payload, &feeInfo)
 	if err != nil {
 		return nil, err
 	}
 
-	return orders, nil
+	return feeInfo, nil
 }