Instant Login

Instant Login for Instant Open/Close

Before you can perform instant open or instant close actions, your sub‑account must delegate access to the solver (Party B) for these functions. Once delegated, you must obtain an access token through a two-step SIWE (Sign-In With Ethereum) login flow. This process ensures that you are authorized to execute instant actions and that your request includes a validated expiration date.

Flow Overview

1. Delegate Access: First, delegate access from your sub‑account to the solver’s address so that they can call functions (such as open, request to close, or cancel close) on your behalf.

2. Fetch a Nonce: Query the hedger’s nonce endpoint using your sub‑account address. The nonce ensures the uniqueness of your SIWE message and prevents replay attacks.

3. Build and Sign the SIWE Message: Construct a SIWE message that includes your wallet address, the nonce, a statement (the sub-account), and timestamps (issued and expiration). This message must be signed by your wallet to confirm your intent.

4. Send Login Request: Submit your signed SIWE message to the hedger’s /login endpoint. Upon successful verification, you will receive an access token. This token is then used for subsequent instant open or close operations.

Delegating Access

To enable instant actions on the frontend, users must delegate specific functions to solvers so they can perform actions on the user's behalf without requiring signatures for each request.

Front-ends should ensure that the following functions are delegated to the solver addresses through the delegateAccesses() method on the MultiAccount contract, passing these function signatures.:

• sendQuote: 0x7f2755b2

• sendQuoteWithAffiliate: 0x40f1310c

• requestToClosePosition: 0x501e891f

• requestToCancelQuote: 0xa8ffc7ab

• requestToCancelCloseRequest: 0xa63b9363

• allocate: 0x90ca796b

After Delegating Access you can proceed with the login process.

Example Script

Below is a Node.js script (using ethers and axios) that demonstrates the nonce fetch and instant login flow:

Delegation of Access: Ensure that your sub‑account has already delegated access to the solver for instant actions before starting the login flow.

require("dotenv").config();
const { ethers } = require("ethers");
const axios = require("axios");

// Replace these values with your environment settings.
const PRIVATE_KEY = process.env.PRIVATE_KEY;
const activeAccount = ethers.getAddress(process.env.activeAccount); //!!Address should be Checksummed with Rasa
const wallet = new ethers.Wallet(PRIVATE_KEY);
const SOLVER_BASE_URL = "https://base-hedger82.rasa.capital"; //replace with your preferred solver base url
const DOMAIN = "localhost"; 
const ORIGIN = "http://localhost:3000";
const CHAIN_ID = 8453; //Base Chain
const LOGIN_URI = `${SOLVER_BASE_URL}/login`; 

// Define issued and expiration timestamps (ISO format)
const ISSUED_AT = new Date().toISOString();
const EXPIRATION_DATE = new Date(Date.now() + (24 * 3600 * 1000 * 10)).toISOString(); // 10 days until expiry

// Function to fetch a nonce from the hedger endpoint
async function getNonce(address) {
  const url = `${SOLVER_BASE_URL}/nonce/${address}`;
  const { data } = await axios.get(url);
  return data.nonce; 
}

// Function to build a SIWE message using EIP-4361 format
function buildSiweMessage({
  domain,
  address,
  statement,
  uri,
  version,
  chainId,
  nonce,
  issuedAt,
  expirationTime
}) {
  return `${domain} wants you to sign in with your Ethereum account:
${address}

${statement}

URI: ${uri}
Version: ${version}
Chain ID: ${chainId}
Nonce: ${nonce}
Issued At: ${issuedAt}
Expiration Time: ${expirationTime}`;
}

(async function main() {
  try {
    console.log(`\n[1/4] Wallet Address: ${wallet.address}`); 
    console.log(`[1.5/4] Active Account (Checksum): ${activeAccount}`);
    
    // Step 1: Fetch the nonce for your active account
    const nonce = await getNonce(activeAccount);
    console.log(`[2/4] Got nonce: ${nonce}`);
    
    // Step 2: Build the SIWE message
    const siweMessage = buildSiweMessage({
      domain: DOMAIN,
      address: wallet.address,        
      statement: `msg: ${activeAccount}`, 
      uri: LOGIN_URI,
      version: "1", //Fo
      chainId: CHAIN_ID,
      nonce,
      issuedAt: ISSUED_AT,
      expirationTime: EXPIRATION_DATE,
    });
    
    console.log("\n[3/4] SIWE message to sign:\n", siweMessage);
    // Sign the SIWE message with your wallet
    const signature = await wallet.signMessage(siweMessage);
    console.log("\nSignature:", signature);
    // Step 3: Prepare the login request body
    const body = {
      account_address: activeAccount, 
      expiration_time: EXPIRATION_DATE,
      issued_at: ISSUED_AT,
      signature,
      nonce
    };

    const headers = {
      "Content-Type": "application/json",
      Origin: ORIGIN,
      Referer: ORIGIN, 
    };
    
    console.log("\n[4/4] Sending login request...");
    const response = await axios.post(
      LOGIN_URI,
      body,
      { headers }
    );
    console.log("Login response:", response.data);

    // The login response should include an access token that you'll use for instant open/close actions.
  } catch (err) {
    console.error("Error in SIWE login flow:", err.response?.data || err.message);
  }
})();

Upon successful login, the response includes an access token. This token must be attached in the headers of any instant open or close requests that you subsequently send.