Quick Start

npm install @domfi/sdk viem

pnpm add @domfi/sdk viem

yarn add @domfi/sdk viem

bun add @domfi/sdk viem

npm install viem

npm install ethers

curl -L https://foundry.paradigm.xyz | bash
foundryup

const price = await client.readContract({
  address: '0x1aB9c3A2E1A09f2D06bf4A75d1721c7e113B8D4D',
  abi: [{
    name: 'getPrice',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: 'pairIndex', type: 'uint16' }],
    outputs: [{ name: '', type: 'uint256' }],
  }],
  functionName: 'getPrice',
  args: [0], // 0 = BTCDOM
});

console.log('BTCDOM price:', Number(price) / 1e18);
// Expected: ~52.5 (Bitcoin dominance percentage)

import { Contract, JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://mainnet.base.org');
const oracle = new Contract(
  '0x1aB9c3A2E1A09f2D06bf4A75d1721c7e113B8D4D',
  [{
    name: 'getPrice',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: 'pairIndex', type: 'uint16' }],
    outputs: [{ name: '', type: 'uint256' }],
  }],
  provider,
);

const price = await oracle.getPrice(0);

console.log('BTCDOM price:', Number(price) / 1e18);
// Expected: ~52.5 (Bitcoin dominance percentage)

// ReadPrice.s.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Script, console} from "forge-std/Script.sol";

interface IDomfiOracle {
    function getPrice(uint16 pairIndex) external view returns (uint256);
}

contract ReadPrice is Script {
    function run() external view {
        IDomfiOracle oracle = IDomfiOracle(
            0x1aB9c3A2E1A09f2D06bf4A75d1721c7e113B8D4D
        );

        uint256 price = oracle.getPrice(0); // 0 = BTCDOM
        console.log("BTCDOM price (18 decimals):", price);
        // Expected: ~52500000000000000000 (52.5%)
    }
}

forge script ReadPrice.s.sol --rpc-url https://mainnet.base.org

cast call 0x1aB9c3A2E1A09f2D06bf4A75d1721c7e113B8D4D \
  "getPrice(uint16)(uint256)" \
  0 \
  --rpc-url https://mainnet.base.org
# Returns: 52500000000000000000 (18 decimals → 52.5% BTCDOM)

import { createPublicClient, createWalletClient, http, parseUnits } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const USDC_ADDRESS = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const TRADING_ADDRESS = '0x7447cb5350a096364A13bEAf77916dfB35db9445';
const TRADING_STORAGE_ADDRESS = '0x608ff95777F419040a3b1E42ed73dD3EFf42Cc24';
const PAIRS_STORAGE_ADDRESS = '0x444079DDCaFd4feE3812E2fF79c5F74a1F4f9Be1';

const erc20Abi = [{
  name: 'approve',
  type: 'function',
  stateMutability: 'nonpayable',
  inputs: [
    { name: 'spender', type: 'address' },
    { name: 'amount', type: 'uint256' },
  ],
  outputs: [{ name: '', type: 'bool' }],
}] as const;

const pairsStorageAbi = [{
  name: 'pairOracleFee',
  type: 'function',
  stateMutability: 'view',
  inputs: [{ name: 'pairIndex', type: 'uint16' }],
  outputs: [{ name: '', type: 'uint256' }],
}] as const;

const tradingAbi = [{
  name: 'openTrade',
  type: 'function',
  stateMutability: 'nonpayable',
  inputs: [
    {
      name: 't',
      type: 'tuple',
      components: [
        { name: 'collateral', type: 'uint256' },
        { name: 'openPrice', type: 'uint192' },
        { name: 'tp', type: 'uint192' },
        { name: 'sl', type: 'uint192' },
        { name: 'trader', type: 'address' },
        { name: 'leverage', type: 'uint32' },
        { name: 'pairIndex', type: 'uint16' },
        { name: 'index', type: 'uint8' },
        { name: 'buy', type: 'bool' },
      ],
    },
    { name: 'orderType', type: 'uint8' },
    { name: 'slippageP', type: 'uint256' },
  ],
  outputs: [],
}] as const;

const account = privateKeyToAccount('0xYOUR_PRIVATE_KEY');
const publicClient = createPublicClient({
  chain: base,
  transport: http('https://mainnet.base.org'),
});
const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http('https://mainnet.base.org'),
});

const collateral = parseUnits('100', 6);

// Step 1: Read the per-pair oracle fee (USDC, 6 decimals)
const oracleFee = await publicClient.readContract({
  address: PAIRS_STORAGE_ADDRESS,
  abi: pairsStorageAbi,
  functionName: 'pairOracleFee',
  args: [0], // 0 = BTCDOM
});

// Step 2: Approve collateral + oracle fee to TradingStorage (not Trading)
const approvalHash = await walletClient.writeContract({
  address: USDC_ADDRESS,
  abi: erc20Abi,
  functionName: 'approve',
  args: [TRADING_STORAGE_ADDRESS, collateral + oracleFee],
});

await publicClient.waitForTransactionReceipt({ hash: approvalHash });

// Step 3: Submit a 10x long on BTCDOM — the oracle fee is pulled from the USDC approval
await walletClient.writeContract({
  address: TRADING_ADDRESS,
  abi: tradingAbi,
  functionName: 'openTrade',
  args: [
    {
      trader: account.address,
      pairIndex: 0,
      index: 0,
      collateral,
      openPrice: 0n,
      buy: true,
      leverage: 1000,
      tp: 0n,
      sl: 0n,
    },
    0,
    50,
  ],
});

// OpenTrade.s.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Script} from "forge-std/Script.sol";

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
}

interface IDomfiTrading {
    struct Trade {
        uint256 collateral;
        uint192 openPrice;
        uint192 tp;
        uint192 sl;
        address trader;
        uint32 leverage;
        uint16 pairIndex;
        uint8 index;
        bool buy;
    }
    function openTrade(Trade calldata t, uint8 orderType, uint256 slippageP) external;
}

interface IDomfiPairsStorage {
    function pairOracleFee(uint16 pairIndex) external view returns (uint256);
}

contract OpenTrade is Script {
    address constant USDC = 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913;
    address constant TRADING = 0x7447cb5350a096364A13bEAf77916dfB35db9445;
    address constant TRADING_STORAGE = 0x608ff95777F419040a3b1E42ed73dD3EFf42Cc24;
    address constant PAIRS_STORAGE = 0x444079DDCaFd4feE3812E2fF79c5F74a1F4f9Be1;

    function run() external {
        vm.startBroadcast();

        // Step 1: Read the per-pair oracle fee (USDC, 6 decimals)
        uint256 oracleFee = IDomfiPairsStorage(PAIRS_STORAGE).pairOracleFee(0); // 0 = BTCDOM

        // Step 2: Approve collateral + oracle fee to TradingStorage (not Trading)
        IERC20(USDC).approve(TRADING_STORAGE, 100e6 + oracleFee); // 100 USDC + oracle fee

        // Step 3: Submit a 10x long on BTCDOM (oracle fee taken from the USDC approval)
        IDomfiTrading(TRADING).openTrade(
            IDomfiTrading.Trade({
                collateral: 100e6,   // 100 USDC (6 decimals)
                openPrice: 0,        // market order — filled by oracle
                tp: 0,               // no take profit
                sl: 0,               // no stop loss
                trader: msg.sender,
                leverage: 1000,      // 10x (2 decimal precision)
                pairIndex: 0,        // BTCDOM
                index: 0,            // first trade slot
                buy: true            // long
            }),
            0,  // 0 = market order
            50  // 0.5% slippage (2 decimals)
        );

        vm.stopBroadcast();
    }
}

forge script OpenTrade.s.sol \
  --rpc-url https://mainnet.base.org \
  --private-key 0xYOUR_PRIVATE_KEY \
  --broadcast