Publish Prices

pip install 'pragma-sdk[miden]'

import asyncio
from pragma_sdk.miden.client import PragmaMidenClient

async def main():
    client = PragmaMidenClient(
        network="testnet",
        oracle_id="0x0d39e78df12351510ec5047670b40e",  # Pragma oracle on the 0.17 testnet
    )
    await client.initialize()
    print(f"Your publisher ID: {client.publisher_id}")

asyncio.run(main())

balance = await client.maintain_fee_balance()   # below the threshold -> asks the faucet for one note
print(balance)                                  # e.g. 9_881 after consuming a 10_000 note (119 fee)

{
  "networks": {
    "testnet": {
      "publisher_account_ids": ["0x<your-publisher-id>"]
    }
  }
}

import asyncio
from pragma_sdk.miden.client import PragmaMidenClient, MidenEntry

async def main():
    client = PragmaMidenClient(network="testnet")   # oracle_id read from pragma_miden.json
    await client.initialize()

    entries = [
        MidenEntry(pair="1:0", price=8_500_000_000_000, decimals=8),  # BTC/USD = $85,000.00
        MidenEntry(pair="2:0", price=220_000_000_000,   decimals=8),  # ETH/USD = $2,200.00
    ]

    results = await client.publish_entries(entries)
    print(results)  # [True, True]

asyncio.run(main())

price-pusher \
  --config-file config.yaml \
  --network mainnet \
  --private-key plain:0x... \
  --publisher-name MY_PUBLISHER \
  --publisher-address 0x... \
  --miden-network testnet \
  --miden-publish-interval 3 \
  --miden-config-path /path/to/pragma_miden.json \
  --miden-storage-path /path/to/miden_storage \
  --miden-keystore-path /path/to/keystore

- pairs:
    spot:
      - ZEC/USD
      - XAUT/USD
  time_difference: 1800
  price_deviation: 0.01
  miden_only: true

class PragmaMidenClient:
    def __init__(
        self,
        network: str = "testnet",                 # "testnet" | "devnet" | "local"
        oracle_id: str | None = None,             # read from pragma_miden.json if omitted
        storage_path: str | None = None,
        keystore_path: str | None = None,
        config_path: str | Path | None = None,    # path to pragma_miden.json
    ): ...

    async def initialize(self) -> None: ...                                  # idempotent
    async def publish_entries(self, entries: list[MidenEntry]) -> list[bool]: ...
    async def get_entry(self, pair: str) -> MidenEntry | None: ...           # None on failure
    async def sync(self) -> None: ...
    async def fee_balance(self) -> int: ...                                  # base units of the fee asset
    async def maintain_fee_balance(self, threshold: int = FEE_REFILL_THRESHOLD) -> int | None: ...  # faucet refill below threshold

class MidenEntry:
    pair: str       # faucet_id, e.g. "1:0"
    price: int      # integer scaled by 10**decimals
    decimals: int
    timestamp: int  # unix timestamp, defaults to now

    @classmethod
    def from_starknet_entry(cls, entry) -> MidenEntry | None:
        """Convert a Starknet Entry. Returns None if the pair is unsupported on Miden
        or if its decimals cannot be resolved."""