Client Library

#!/usr/bin/env python

import asyncio
import logging
import time

from bluefin_pro_sdk import BluefinProSdk, Environment, RpcUrl
from crypto_helpers.signature import SuiWallet

# Set up logging
logging.basicConfig(level=logging.INFO)
log = logging.getLogger(__name__)


def now():
    """Return the current time in milliseconds since the Epoch."""
    return int(time.time() * 1000)


async def main():
    """
    Example showing how to adjust margin on a position for an account using the Bluefin Pro API
    using the PRODUCTION environment.
    """
    # Create a wallet with your private key
    sui_wallet = SuiWallet(
        mnemonic="dilemma salmon lake ceiling moral glide cute that ginger float area aunt vague remind cage mother concert inch dizzy present proud program time urge"
    )

    log.info(f"Using wallet address: {sui_wallet.sui_address}")

    # Initialize the Bluefin Pro SDK client with PRODUCTION environment and RPC
    async with BluefinProSdk(
            sui_wallet=sui_wallet,
            contracts=None,  # Not needed for this example
            rpc_url=RpcUrl.PROD,
            env=Environment.PRODUCTION,
            debug=False  # Set to True for more verbose output
    ) as client:
        try:
            # Initialize the client, which will handle authentication
            await client.init()

            # ========= Withdraw ==========
            log.info("Adjusting Margin")
            await client.adjust_isolated_margin("ETH-PERP", "10000000000", True)

        except Exception as e:
            log.error(f"Error adjusting margin: {e}")
            raise


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        log.info("Exiting due to keyboard interrupt")

use bluefin_api::apis::configuration::Configuration;
use bluefin_api::apis::trade_api::put_adjust_isolated_margin;
use bluefin_api::models::LoginRequest;
use bluefin_api::models::{
    AdjustIsolatedMarginRequest, AdjustIsolatedMarginRequestSignedFields, AdjustMarginOperation,
};
use bluefin_pro::prelude::*;
use chrono::Utc;
use hex::FromHex;
use rand::random;
use sui_sdk_types::SignatureScheme;

type Error = Box<dyn std::error::Error>;
type Result<T> = std::result::Result<T, Error>;

async fn send_request(signed_request: AdjustIsolatedMarginRequest, auth_token: &str) -> Result<()> {
    println!("Sending request...");
    // Send request and get back order hash
    let mut config = Configuration::new();
    config.bearer_access_token = Some(auth_token.into());
    config.base_path = trade::mainnet::URL.into();

    put_adjust_isolated_margin(&config, signed_request).await?;

    Ok(())
}

#[tokio::main]
async fn main() -> Result<()> {
    // We construct an authentication request to obtain a token.
    let request = LoginRequest {
        account_address: "INSERT_ACCOUNT_ADDRESS_HERE",
        audience: auth::mainnet::AUDIENCE.into(),
        signed_at_millis: Utc::now().timestamp_millis(),
    };

    // Next, we generate a signature for the request.
    let signature = request.signature(
        SignatureScheme::Ed25519,
        PrivateKey::from_hex("INSERT_HEX_ENCODED_PRIVATE_KEY_HERE")?,
    )?;

    // Then, we submit our authentication request to the API for the desired environment.
    let auth_token = request
        .authenticate(&signature, Environment::Mainnet)
        .await?
        .access_token;

    // We get the exchange info to fetch the IDS_ID
    let contracts_info = exchange::info::contracts_config(Environment::Mainnet).await?;

    // Next, we construct an unsigned request.
    let request = AdjustIsolatedMarginRequest {
        signed_fields: AdjustIsolatedMarginRequestSignedFields {
            symbol: symbols::perps::ETH.into(),
            account_address: "INSERT_ACCOUNT_ADDRESS_HERE",
            operation: AdjustMarginOperation::Add,
            quantity_e9: (1.e9()).to_string(),
            salt: random::<u64>().to_string(),
            ids_id: contracts_info.ids_id,
            signed_at_millis: Utc::now().timestamp_millis(),
        },
        ..AdjustIsolatedMarginRequest::default()
    };

    // Then, we sign our order.
    let request = request.sign(
        PrivateKey::from_hex("INSERT_HEX_ENCODED_PRIVATE_KEY_HERE")?,
        SignatureScheme::Ed25519,
    )?;

    send_request(request, &auth_token).await?;

    // Finally, we check that we've received the expected order hash.
    println!("Margin Adjusted");
    Ok(())
}

HTTPs

Alternatively, call the PUT /trade/adjustIsolatedMargin endpoint using the integrated editor on the right or locally from any language supporting HTTPs network calls.

Request & Response

400Bad Request. The request was invalid or malformed.

401Unauthorized. Authentication is required or invalid. Signature is invalid

403Forbidden.

404Not Found. The requested account was not found.

500Internal Server Error. An unexpected error occurred on the server.

503Service Unavailable. The service is currently unavailable.