Curated Packs

package packs

import (
    "context"
    "fmt"
    "os"
    "strconv"
    "time"

    "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

func newClient() *limitless.Client {
    return limitless.NewClient(limitless.WithHMACCredentials(limitless.HMACCredentials{
        TokenID: os.Getenv("LMTS_TOKEN_ID"),
        Secret: os.Getenv("LMTS_TOKEN_SECRET"),
    }))
}

func checkVaultApproval(ctx context.Context, client *limitless.Client, profileID int) error {
    state, err := client.PartnerAccounts.CheckAllowances(ctx, profileID)
    if err != nil {
        return err
    }
    for _, target := range state.Targets {
        if target.Type == "USDC_ALLOWANCE" && target.Label == "parlay-treasury-vault" {
            if target.Confirmed && target.Status == "confirmed" {
                return nil
            }
        }
    }
    return fmt.Errorf("confirm the Pack vault allowance before preparing a buy")
}

func preparePurchase(
    ctx context.Context, client *limitless.Client,
    profileID int, packID, purchaseKey string,
) (limitless.PackBuyParams, error) {
    if err := checkVaultApproval(ctx, client, profileID); err != nil {
        return limitless.PackBuyParams{}, err
    }
    quote, err := client.Packs.Quote(ctx, limitless.PackQuoteParams{
        PackID: packID, StakeAmount: "10000000",
    })
    if err != nil {
        return limitless.PackBuyParams{}, err
    }
    if !quote.Eligible {
        return limitless.PackBuyParams{}, fmt.Errorf("ineligible: %v", quote.IneligibleReasons)
    }
    minimum, err := limitless.PackMinPayout(quote.PotentialPayout, 100)
    if err != nil {
        return limitless.PackBuyParams{}, err
    }
    return limitless.PackBuyParams{
        OnBehalfOf: profileID,
        PackID: packID,
        StakeAmount: "10000000", // 10 USDC
        MinPayoutAmount: minimum,
        Deadline: strconv.FormatInt(time.Now().Unix()+120, 10),
        IdempotencyKey: purchaseKey,
    }, nil
}

func submitSavedPurchase(
    ctx context.Context, client *limitless.Client, saved limitless.PackBuyParams,
) (*limitless.PackPosition, error) {
    buy, err := client.Packs.Buy(ctx, saved)
    if err != nil {
        return nil, err
    }
    return client.Packs.WaitForPosition(ctx, saved.OnBehalfOf, buy.Position.ID)
}

func claimWinningPosition(
    ctx context.Context, client *limitless.Client, profileID int, positionID string,
) (*limitless.PackClaimResponse, error) {
    position, err := client.Packs.GetPosition(ctx, profileID, positionID)
    if err != nil {
        return nil, err
    }
    if position.Status != "WON" {
        return nil, fmt.Errorf("position is not WON")
    }
    return client.Packs.Claim(ctx, profileID, positionID)
}