Pyth oracle integration

[project]
name = "my-oracle-project"

[[project.requirements]]
contract_id = "SP3R4F6C1J3JQWWCVZ3S7FRRYPMYG6ZW6RZK31FXY.pyth-oracle-v3"

[[project.requirements]]
contract_id = "SP3R4F6C1J3JQWWCVZ3S7FRRYPMYG6ZW6RZK31FXY.pyth-storage-v3"

[[project.requirements]]
contract_id = "SP3R4F6C1J3JQWWCVZ3S7FRRYPMYG6ZW6RZK31FXY.pyth-pnau-decoder-v2"

[[project.requirements]]
contract_id = "SP3R4F6C1J3JQWWCVZ3S7FRRYPMYG6ZW6RZK31FXY.wormhole-core-v3"

;; Mock Pyth Oracle for testing
(define-map price-feeds
  (buff 32)  ;; price-feed-id
  {
    price: int,
    conf: uint,
    expo: int,
    ema-price: int,
    ema-conf: uint,
    publish-time: uint,
    prev-publish-time: uint
  }
)

;; Set a mock price
(define-public (set-mock-price 
  (feed-id (buff 32))
  (price int)
  (expo int))
  (ok (map-set price-feeds feed-id {
    price: price,
    conf: u1000000,
    expo: expo,
    ema-price: price,
    ema-conf: u1000000,
    publish-time: block-height,
    prev-publish-time: (- block-height u1)
  }))
)

;; Mock get-price function matching real oracle interface
(define-read-only (get-price 
  (feed-id (buff 32))
  (storage-contract principal))
  (ok (unwrap! 
    (map-get? price-feeds feed-id)
    (err u404)))
)

;; Mock verify-and-update-price-feeds (no-op for testing)
(define-public (verify-and-update-price-feeds
  (vaa (buff 8192))
  (params (tuple)))
  (ok u1)
)

import { Cl } from '@stacks/transactions';
import { describe, expect, it } from "vitest";

const accounts = simnet.getAccounts();
const deployer = accounts.get("deployer")!;
const wallet1 = accounts.get("wallet_1")!;

describe("Benjamin Club with Mock Oracle", () => {
  it("should set up mock BTC price", () => {
    // Set BTC price to $100,000 (with 8 decimals)
    const btcFeedId = "0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43";
    const mockPrice = Cl.int(10000000000000); // $100,000.00 * 10^8
    const expo = Cl.int(-8);
    
    const setPriceResponse = simnet.callPublicFn(
      "mock-pyth-oracle",
      "set-mock-price",
      [Cl.bufferFromHex(btcFeedId), mockPrice, expo],
      deployer
    );
    
    expect(setPriceResponse.result).toBeOk(Cl.uint(1));
  });

  it("should calculate correct sBTC amount for $100", () => {
    // With BTC at $100,000, $100 = 0.001 BTC
    const response = simnet.callReadOnlyFn(
      "benjamin-club",
      "get-required-sbtc-amount",
      [],
      wallet1
    );
    
    // 0.001 BTC = 100,000 sats
    expect(response.result).toBeOk(Cl.uint(100000));
  });

  it("should mint NFT when user has enough sBTC", () => {
    // Mock VAA data (can be dummy data for unit tests)
    const mockVaa = Cl.bufferFromHex("00".repeat(100));
    
    // Give user 1 BTC worth of sBTC
    simnet.callPublicFn(
      "sbtc-token",
      "mint",
      [Cl.uint(100000000), Cl.principal(wallet1)],
      deployer
    );
    
    const mintResponse = simnet.callPublicFn(
      "benjamin-club",
      "mint-for-hundred-dollars",
      [mockVaa],
      wallet1
    );
    
    expect(mintResponse.result).toBeOk(Cl.uint(1));
  });
});

import { buildDevnetNetworkOrchestrator } from "@hirosystems/clarinet-sdk";
import { Cl } from '@stacks/transactions';
import { PriceServiceConnection } from '@pythnetwork/price-service-client';
import { describe, expect, it } from "vitest";

describe("Benjamin Club with Mainnet Oracle", () => {
  let orchestrator: any;
  
  beforeAll(async () => {
    orchestrator = buildDevnetNetworkOrchestrator({
      // Point to a mainnet fork
      manifest: "./Clarinet.toml",
      networkId: 1 // Mainnet
    });
  });

  it("should interact with real Pyth oracle", async () => {
    // Fetch real VAA from Pyth
    const pythClient = new PriceServiceConnection(
      "https://hermes.pyth.network",
      { priceFeedRequestConfig: { binary: true } }
    );
    
    const btcFeedId = "e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43";
    const vaas = await pythClient.getLatestVaas([btcFeedId]);
    const vaaHex = Buffer.from(vaas[0], 'base64').toString('hex');
    
    // Use mainnet execution to test with real oracle
    const response = await orchestrator.callPublicFn(
      "benjamin-club",
      "get-current-btc-price",
      [Cl.bufferFromHex(vaaHex)],
      "wallet_1"
    );
    
    expect(response.result).toBeOk();
    
    // Verify price is reasonable (between $10k and $200k)
    const priceData = response.result.value;
    const price = priceData.data.price.value;
    expect(price).toBeGreaterThan(1000000000000); // $10k
    expect(price).toBeLessThan(20000000000000);   // $200k
  });
});