Swift (off-chain signed orders)

import {
  getMarketOrderParams, MarketType, PositionDirection, isVariant
} from "@velocity-exchange/sdk";
 
const marketIndex = 0; // SOL-PERP
 
const oracleInfo = velocityClient.getOracleDataForPerpMarket(marketIndex);
const direction = PositionDirection.LONG;
 
// Set auction price range around the current oracle price
const highPrice = oracleInfo.price.muln(101).divn(100); // oracle + 1%
const lowPrice = oracleInfo.price;
 
const orderParams = getMarketOrderParams({
  marketIndex,
  marketType: MarketType.PERP,
  direction,
  baseAssetAmount: velocityClient.convertToPerpPrecision(0.1), // 0.1 SOL
  auctionStartPrice: isVariant(direction, "long") ? lowPrice : highPrice,
  auctionEndPrice: isVariant(direction, "long") ? highPrice : lowPrice,
  auctionDuration: 50, // slots for market makers to compete
});

import { generateSignedMsgUuid } from "@velocity-exchange/sdk";
 
const slot = await velocityClient.connection.getSlot();
 
const orderMessage = {
  signedMsgOrderParams: orderParams,
  subAccountId: velocityClient.activeSubAccountId,
  slot: new BN(slot),
  uuid: generateSignedMsgUuid(), // unique ID for deduplication
  stopLossOrderParams: null,
  takeProfitOrderParams: null,
};
 
const { orderParams: message, signature } =
  velocityClient.signSignedMsgOrderParamsMessage(orderMessage);

const swiftUrl = "https://swift.velocity.exchange/orders";
 
const response = await fetch(swiftUrl, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    market_index: orderParams.marketIndex,
    market_type: "perp",
    message: message.toString("hex"),
    signature: signature.toString("hex"),
    taker_authority: velocityClient.wallet.publicKey.toBase58(),
    // signing_authority: delegatePublicKey.toBase58(), // only needed for delegate flows
  }),
});
 
if (!response.ok) {
  const errorText = await response.text();
  throw new Error("Swift error: " + response.status + " " + errorText);
}

import { getSignedMsgUserAccountPublicKey } from "@velocity-exchange/sdk";
 
// Derive the PDA for the signed message orders account
const pda = getSignedMsgUserAccountPublicKey(velocityClient.program.programId, authority);

// Initialize the signed message orders account for `authority`
// with space for 8 concurrent orders
const [txSig, signedMsgUserAccount] =
  await velocityClient.initializeSignedMsgUserOrders(authority, 8);

const signedMessage = velocityClient.decodeSignedMsgOrderParamsMessage(
  Buffer.from(orderMessageHex, "hex"),
  isDelegateSigner  // true if the message was signed by a delegate
);

// Used by keeper bots to submit a taker's signed Swift order on-chain
const ixs = await velocityClient.getPlaceSignedMsgTakerPerpOrderIxs(
  { orderParams: orderMessageHex, signature },
  marketIndex,
  takerInfo
);

// Used by market makers to fill a taker's Swift order with their own maker quote
const ixs = await velocityClient.getPlaceAndMakeSignedMsgPerpOrderIxs(
  signedMsgOrderParams,
  signedMsgOrderUuid,
  takerInfo,
  makerOrderParams,
  subAccountId,
  [], // precedingIxs
  undefined, // overrideCustomIxIndex
  takerEscrow // optional; required when the taker's order needs it
);

import { generateSignedMsgUuid } from "@velocity-exchange/sdk";
 
const uuid = generateSignedMsgUuid();

import { digestSignature } from "@velocity-exchange/sdk";
 
const hash = digestSignature(Uint8Array.from(signature));

import { getUserStatsAccountPublicKey } from "@velocity-exchange/sdk";
 
const userStats = getUserStatsAccountPublicKey(
  velocityClient.program.programId,
  authority
);