@decibeltrade/sdk 0.1.1

package/src/abi/types.ts

@@ -0,0 +1,23 @@
+import { MoveFunction, MoveFunctionId } from "@aptos-labs/ts-sdk";
+
+export type ABIs = Record<MoveFunctionId, MoveFunction>;
+
+export interface ABIData {
+  packageAddress: string;
+  network: string;
+  fullnodeUrl: string;
+  fetchedAt: string;
+  abis: ABIs;
+  errors: Array<{
+    module: string;
+    function: string;
+    error: string;
+  }>;
+  summary: {
+    totalModules: number;
+    totalFunctions: number;
+    successful: number;
+    failed: number;
+  };
+  modules: string[];
+}

package/src/admin.ts

@@ -0,0 +1,284 @@
+import { AccountAddress, createObjectAddress } from "@aptos-labs/ts-sdk";
+
+import { BaseSDK } from "./base";
+import { getMarketAddr } from "./utils";
+
+export class DecibelAdminDex extends BaseSDK {
+  /**
+   * Initialize the global vault system. Only callable by the admin account.
+   */
+  async initialize(
+    collateralTokenAddr: string,
+    collateralBalanceDecimals: number,
+    backstopLiquidatorAddr: string,
+  ) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::initialize`,
+      typeArguments: [],
+      functionArguments: [collateralTokenAddr, collateralBalanceDecimals, backstopLiquidatorAddr],
+    });
+  }
+
+  getProtocolVaultAddress(): AccountAddress {
+    const vaultConfigObjectAddr = createObjectAddress(
+      AccountAddress.fromString(this.config.deployment.package),
+      "GlobalVaultConfig",
+    );
+    const protocolVaultObjectAddr = createObjectAddress(
+      vaultConfigObjectAddr,
+      "Decibel Protocol Vault",
+    );
+
+    return protocolVaultObjectAddr;
+  }
+
+  async initializeProtocolVault(collateralTokenAddr: string, initialFunding: number) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::vault::create_and_fund_vault`,
+      typeArguments: [],
+      functionArguments: [
+        collateralTokenAddr,
+        "Decibel Protocol Vault",
+        "(description)",
+        [],
+        "DPV",
+        "",
+        "",
+        0, // fee_bps
+        0, // fee_interval
+        3 * 24 * 60 * 60, // contribution_lockup_duration_s
+        initialFunding, // initial_funding
+        true, // accepts_contributions
+        false, // delegate_to_creator
+      ],
+    });
+  }
+
+  async delegateProtocolVaultTradingTo(vaultAddress: string, accountToDelegateTo: string) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::vault::delegate_dex_actions_to`,
+      typeArguments: [],
+      functionArguments: [vaultAddress, accountToDelegateTo, undefined],
+    });
+  }
+
+  async authorizeOracleAndMarkUpdate(internalOracleUpdater: string) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::add_oracle_and_mark_update_permission`,
+      typeArguments: [],
+      functionArguments: [internalOracleUpdater],
+    });
+  }
+
+  async registerMarketWithInternalOracle(
+    name: string,
+    szDecimals: number,
+    minSize: number,
+    lotSize: number,
+    tickerSize: number,
+    maxOpenInterest: number,
+    maxLeverage: number,
+    taker_in_next_block = true,
+    initial_oracle_price = 1,
+    max_staleness_secs = 60,
+  ) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::register_market_with_internal_oracle`,
+      typeArguments: [],
+      functionArguments: [
+        name,
+        szDecimals,
+        minSize,
+        lotSize,
+        tickerSize,
+        maxOpenInterest,
+        maxLeverage,
+        taker_in_next_block,
+        initial_oracle_price,
+        max_staleness_secs,
+      ],
+    });
+  }
+
+  async registerMarketWithPythOracle(
+    name: string,
+    szDecimals: number,
+    minSize: number,
+    lotSize: number,
+    tickerSize: number,
+    maxOpenInterest: number,
+    maxLeverage: number,
+    taker_in_next_block = true,
+    pythIdentifierBytes: number[],
+    pythMaxStalenessSecs: number,
+    pythConfidenceIntervalThreshold: number,
+    pythDecimals: number,
+  ) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::register_market_with_pyth_oracle`,
+      typeArguments: [],
+      functionArguments: [
+        name,
+        szDecimals,
+        minSize,
+        lotSize,
+        tickerSize,
+        maxOpenInterest,
+        maxLeverage,
+        taker_in_next_block,
+        pythIdentifierBytes,
+        pythMaxStalenessSecs,
+        pythConfidenceIntervalThreshold,
+        pythDecimals,
+      ],
+    });
+  }
+
+  async registerMarketWithCompositeOraclePrimaryPyth(
+    name: string,
+    szDecimals: number,
+    minSize: number,
+    lotSize: number,
+    tickerSize: number,
+    maxOpenInterest: number,
+    maxLeverage: number,
+    taker_in_next_block = true,
+    pythIdentifierBytes: number[],
+    pythMaxStalenessSecs: number,
+    pythConfidenceIntervalThreshold: number,
+    pythDecimals: number,
+    internalInitialPrice: number,
+    internalMaxStalenessSecs: number,
+    oraclesDeviationBps: number,
+    consecutiveDeviationCount: number,
+  ) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::register_market_with_composite_oracle_primary_pyth`,
+      typeArguments: [],
+      functionArguments: [
+        name,
+        szDecimals,
+        minSize,
+        lotSize,
+        tickerSize,
+        maxOpenInterest,
+        maxLeverage,
+        taker_in_next_block,
+        pythIdentifierBytes,
+        pythMaxStalenessSecs,
+        pythConfidenceIntervalThreshold,
+        pythDecimals,
+        internalInitialPrice,
+        internalMaxStalenessSecs,
+        oraclesDeviationBps,
+        consecutiveDeviationCount,
+      ],
+    });
+  }
+
+  async registerMarketWithCompositeOraclePrimaryChainlink(
+    name: string,
+    szDecimals: number,
+    minSize: number,
+    lotSize: number,
+    tickerSize: number,
+    maxOpenInterest: number,
+    maxLeverage: number,
+    taker_in_next_block = true,
+    rescaleDecimals: number,
+    chainlinkFeedIdBytes: number[],
+    chainlinkMaxStalenessSecs: number,
+    internalMaxStalenessSecs: number,
+    internalInitialPrice: number,
+    oraclesDeviationBps: number,
+    consecutiveDeviationCount: number,
+  ) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::register_market_with_composite_oracle_primary_chainlink`,
+      typeArguments: [],
+      functionArguments: [
+        name,
+        szDecimals,
+        minSize,
+        lotSize,
+        tickerSize,
+        maxOpenInterest,
+        maxLeverage,
+        taker_in_next_block,
+        chainlinkFeedIdBytes,
+        chainlinkMaxStalenessSecs,
+        rescaleDecimals,
+        internalInitialPrice,
+        internalMaxStalenessSecs,
+        oraclesDeviationBps,
+        consecutiveDeviationCount,
+      ],
+    });
+  }
+
+  async updateInternalOraclePrice(marketName: string, oraclePrice: number) {
+    const marketAddr = getMarketAddr(marketName, this.config.deployment.perpEngineGlobal);
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::update_mark_for_internal_oracle`,
+      typeArguments: [],
+      functionArguments: [marketAddr, oraclePrice, [], true],
+    });
+  }
+
+  async updatePythOraclePrice(marketName: string, vaa: number[]) {
+    const marketAddr = getMarketAddr(marketName, this.config.deployment.perpEngineGlobal);
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::admin_apis::update_mark_for_pyth_oracle`,
+      typeArguments: [],
+      functionArguments: [marketAddr, vaa, [], true],
+    });
+  }
+
+  async updatePriceToPythOnly(vaas: number[][]) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::pyth::update_price_feeds_with_funder`,
+      typeArguments: [],
+      functionArguments: [vaas],
+    });
+  }
+
+  async updatePriceToChainlinkOnly(signedReport: number[]) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::chainlink_state::verify_and_store_single_price`,
+      typeArguments: [],
+      functionArguments: [signedReport],
+    });
+  }
+
+  async mintUsdc(toAddr: AccountAddress, amount: number) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::usdc::mint`,
+      typeArguments: [],
+      functionArguments: [toAddr, amount],
+    });
+  }
+
+  async setPublicMinting(allow: boolean) {
+    return await this.sendTx({
+      function: `${this.config.deployment.package}::usdc::set_public_minting`,
+      typeArguments: [],
+      functionArguments: [allow],
+    });
+  }
+
+  /**
+   * Get the balance of USDC for an account
+   * @param addr The account address to get the balance for
+   * @returns The balance of USDC for the account
+   */
+  async usdcBalance(addr: AccountAddress) {
+    const balance = await this.aptos.view<[number]>({
+      payload: {
+        function: `0x1::primary_fungible_store::balance`,
+        typeArguments: [`0x1::fungible_asset::Metadata`],
+        functionArguments: [addr, this.config.deployment.usdc],
+      },
+    });
+    return balance[0];
+  }
+}

package/src/base.ts

@@ -0,0 +1,218 @@
+import {
+  Account,
+  AccountAddress,
+  AccountAuthenticator,
+  Aptos,
+  AptosConfig,
+  InputEntryFunctionData,
+  InputGenerateTransactionPayloadData,
+  MoveFunction,
+  MoveFunctionId,
+  PendingTransactionResponse,
+  SimpleTransaction,
+} from "@aptos-labs/ts-sdk";
+
+import netnaAbis from "./abi/json/netna.json";
+import testnetAbis from "./abi/json/testnet.json";
+import { ABIData } from "./abi/types";
+import { DecibelConfig, NETNA_CONFIG, TESTNET_CONFIG } from "./constants";
+import { submitFeePaidTransaction } from "./fee-pay";
+import { GasPriceManager } from "./gas/gas-price-manager";
+import { buildSimpleTransactionSync } from "./transaction-builder";
+import { generateRandomReplayProtectionNonce } from "./utils";
+
+export interface Options {
+  skipSimulate?: boolean;
+  noFeePayer?: boolean;
+  nodeApiKey?: string;
+  gasPriceManager?: GasPriceManager;
+  /**
+   * Time delta in milliseconds to add to Date.now() for expiration timestamps.
+   * Used to sync with server time when client clock is incorrect.
+   */
+  timeDeltaMs?: number;
+}
+
+const chainIdToAbi: Record<number, ABIData> = {};
+if (NETNA_CONFIG.chainId) chainIdToAbi[NETNA_CONFIG.chainId] = netnaAbis as ABIData;
+if (TESTNET_CONFIG.chainId) chainIdToAbi[TESTNET_CONFIG.chainId] = testnetAbis as ABIData;
+
+export class BaseSDK {
+  readonly aptos: Aptos;
+  readonly skipSimulate: boolean;
+  readonly noFeePayer: boolean;
+  private readonly chainId: number | undefined;
+  private readonly abi = netnaAbis as ABIData;
+  private readonly gasPriceManager: GasPriceManager | undefined;
+  /**
+   * Time delta in milliseconds to add to Date.now() for expiration timestamps.
+   */
+  public timeDeltaMs: number;
+
+  constructor(
+    readonly config: DecibelConfig,
+    /**
+     * The main account
+     */
+    readonly account: Account,
+    opts?: Options,
+  ) {
+    const abi = config.chainId ? chainIdToAbi[config.chainId] : null;
+    if (abi) {
+      this.abi = abi;
+    } else {
+      this.abi = netnaAbis as ABIData;
+      console.warn(
+        "Using NETNA ABI for unsupported chain id, this might cause issues with the transaction builder",
+      );
+    }
+
+    const aptosConfig = new AptosConfig({
+      network: config.network,
+      fullnode: config.fullnodeUrl,
+      clientConfig: { API_KEY: opts?.nodeApiKey },
+    });
+    this.aptos = new Aptos(aptosConfig);
+    this.skipSimulate = opts?.skipSimulate ?? false;
+    this.noFeePayer = opts?.noFeePayer ?? false;
+    this.chainId = config.chainId;
+    this.gasPriceManager = opts?.gasPriceManager;
+    this.timeDeltaMs = opts?.timeDeltaMs ?? 0;
+  }
+
+  private getABI(functionId: MoveFunctionId): MoveFunction | null {
+    return this.abi.abis[functionId] ?? null;
+  }
+
+  private async getSimulatedTx(
+    payload: InputGenerateTransactionPayloadData,
+    sender: AccountAddress,
+  ) {
+    const transaction = await this.aptos.transaction.build.simple({
+      sender,
+      data: payload,
+    });
+    const [sim] = await this.aptos.transaction.simulate.simple({
+      transaction,
+      options: {
+        estimateMaxGasAmount: true,
+        estimateGasUnitPrice: true,
+      },
+    });
+
+    if (typeof sim === "undefined") {
+      throw new Error("Transaction simulation returned no results");
+    }
+
+    if (!sim.max_gas_amount || !sim.gas_unit_price) {
+      throw new Error("Transaction simulation returned no results");
+    }
+
+    return await this.aptos.transaction.build.simple({
+      sender,
+      data: payload,
+      options: {
+        maxGasAmount: Number(sim.max_gas_amount),
+        gasUnitPrice: Number(sim.gas_unit_price),
+      },
+    });
+  }
+
+  public async submitTx(
+    transaction: SimpleTransaction,
+    senderAuthenticator: AccountAuthenticator,
+  ): Promise<PendingTransactionResponse> {
+    if (this.noFeePayer) {
+      return await this.aptos.transaction.submit.simple({
+        transaction,
+        senderAuthenticator,
+      });
+    } else {
+      return await submitFeePaidTransaction(this.config, transaction, senderAuthenticator);
+    }
+  }
+
+  public async buildTx(payload: InputGenerateTransactionPayloadData, sender: AccountAddress) {
+    const functionAbi = "function" in payload ? this.getABI(payload.function) : undefined;
+    const withFeePayer = !this.noFeePayer;
+
+    const replayProtectionNonce = generateRandomReplayProtectionNonce();
+
+    // This should never happen, but just in case
+    if (!replayProtectionNonce) {
+      throw new Error("Unable to generate replayProtectionNonce");
+    }
+
+    let transaction: SimpleTransaction;
+
+    // If we have functionAbi and chainId, we can use the sync function to generate the transaction
+    // This is faster than the async function
+    if (functionAbi && this.chainId) {
+      let gasUnitPrice: number;
+
+      if (this.gasPriceManager) {
+        // 1. Try getting from cache
+        // 2. If not available, try fetching from gasmanager, this also sets the gas price in the cache for future use
+        gasUnitPrice =
+          this.gasPriceManager.getGasPrice() ?? (await this.gasPriceManager.fetchAndSetGasPrice());
+      } else {
+        // 1. Fetch from network, this is a fallback, should only happen if gasPriceManager is not set
+        gasUnitPrice = (await this.aptos.getGasPriceEstimation()).gas_estimate;
+      }
+
+      transaction = buildSimpleTransactionSync({
+        aptosConfig: this.aptos.config,
+        sender,
+        data: payload as InputEntryFunctionData,
+        withFeePayer,
+        replayProtectionNonce,
+        abi: functionAbi,
+        chainId: this.chainId,
+        gasUnitPrice,
+        timeDeltaMs: this.timeDeltaMs,
+      });
+    } else {
+      // This is a fallback, should not happen, but works if due to any issues, functionAbi or chainId is not present
+      // @Todo: Pass in Abi ideally, once we update aptos-ts-sdk to not refetch abi if abi is passed in payload
+      transaction = await this.aptos.transaction.build.simple({
+        sender,
+        data: payload,
+        withFeePayer,
+        options: {
+          replayProtectionNonce,
+        },
+      });
+    }
+
+    return transaction;
+  }
+
+  protected async sendTx(payload: InputGenerateTransactionPayloadData, accountOverride?: Account) {
+    const signer = accountOverride ?? this.account;
+    const sender = signer.accountAddress;
+    if (!this.skipSimulate) {
+      const transaction = await this.getSimulatedTx(payload, sender);
+      const senderAuthenticator = this.aptos.transaction.sign({
+        signer,
+        transaction,
+      });
+      const pendingTransaction = await this.submitTx(transaction, senderAuthenticator);
+      return await this.aptos.waitForTransaction({
+        transactionHash: pendingTransaction.hash,
+      });
+    } else {
+      const transaction = await this.buildTx(payload, sender);
+
+      const senderAuthenticator = this.aptos.transaction.sign({
+        signer,
+        transaction,
+      });
+
+      const pendingTransaction = await this.submitTx(transaction, senderAuthenticator);
+
+      return await this.aptos.waitForTransaction({
+        transactionHash: pendingTransaction.hash,
+      });
+    }
+  }
+}

package/src/constants.ts

@@ -0,0 +1,118 @@
+import { AccountAddress, Aptos, createObjectAddress, Network } from "@aptos-labs/ts-sdk";
+
+import { DecibelWsSubscription } from "./read/ws-subscription";
+
+export function getUsdcAddress(publisherAddr: string) {
+  return createObjectAddress(
+    AccountAddress.fromString(publisherAddr),
+    new TextEncoder().encode("USDC"),
+  );
+}
+
+export function getTestcAddress(publisherAddr: string) {
+  return createObjectAddress(
+    AccountAddress.fromString(publisherAddr),
+    new TextEncoder().encode("TESTC"),
+  );
+}
+
+export function getPerpEngineGlobalAddress(publisherAddr: string) {
+  return createObjectAddress(
+    AccountAddress.fromString(publisherAddr),
+    new TextEncoder().encode("GlobalPerpEngine"),
+  );
+}
+
+export interface DecibelConfig {
+  network: Network;
+  fullnodeUrl: string;
+  tradingHttpUrl: string;
+  tradingWsUrl: string;
+  gasStationUrl: string;
+  deployment: Deployment;
+  chainId?: number;
+}
+
+export interface DecibelReaderDeps {
+  aptos: Aptos;
+  ws: DecibelWsSubscription;
+  config: DecibelConfig;
+  apiKey?: string;
+}
+
+export interface Deployment {
+  package: string;
+  usdc: string;
+  testc: string;
+  perpEngineGlobal: string;
+}
+
+const NETNA_PACKAGE = "0xb8a5788314451ce4d2fbbad32e1bad88d4184b73943b7fe5166eab93cf1a5a95";
+export const NETNA_DEPLOYMENT: Deployment = {
+  package: NETNA_PACKAGE,
+  usdc: getUsdcAddress(NETNA_PACKAGE).toString(),
+  testc: getTestcAddress(NETNA_PACKAGE).toString(),
+  perpEngineGlobal: getPerpEngineGlobalAddress(NETNA_PACKAGE).toString(),
+};
+
+export const NETNA_CONFIG: DecibelConfig = {
+  network: Network.CUSTOM,
+  fullnodeUrl: "https://api.netna.aptoslabs.com/v1",
+  tradingHttpUrl: "https://api.netna.aptoslabs.com/decibel",
+  tradingWsUrl: "wss://api.netna.aptoslabs.com/decibel/ws",
+  gasStationUrl: "https://fee-payer-dev-netna-us-central1-410192433417.us-central1.run.app",
+  deployment: NETNA_DEPLOYMENT,
+  chainId: 205,
+};
+
+const TESTNET_PACKAGE = "0x1f513904b7568445e3c291a6c58cb272db017d8a72aea563d5664666221d5f75";
+export const TESTNET_DEPLOYMENT: Deployment = {
+  package: TESTNET_PACKAGE,
+  usdc: getUsdcAddress(TESTNET_PACKAGE).toString(),
+  testc: getTestcAddress(TESTNET_PACKAGE).toString(),
+  perpEngineGlobal: getPerpEngineGlobalAddress(TESTNET_PACKAGE).toString(),
+};
+
+export const TESTNET_CONFIG: DecibelConfig = {
+  network: Network.TESTNET,
+  fullnodeUrl: "https://api.testnet.aptoslabs.com/v1",
+  tradingHttpUrl: "https://api.testnet.aptoslabs.com/decibel",
+  tradingWsUrl: "wss://api.testnet.aptoslabs.com/decibel/ws",
+  gasStationUrl: "https://fee-payer-staging-testnet-us-central1-502735673999.us-central1.run.app",
+  deployment: TESTNET_DEPLOYMENT,
+  chainId: 2,
+};
+
+export const LOCAL_CONFIG: DecibelConfig = {
+  network: Network.CUSTOM,
+  fullnodeUrl: "http://localhost:8080/v1",
+  tradingHttpUrl: "http://localhost:8084",
+  tradingWsUrl: "ws://localhost:8083",
+  gasStationUrl: "http://localhost:8085",
+  deployment: NETNA_DEPLOYMENT,
+};
+
+export const DOCKER_CONFIG: DecibelConfig = {
+  network: Network.CUSTOM,
+  fullnodeUrl: "http://tradenet:8080/v1",
+  tradingHttpUrl: "http://trading-api-http:8080",
+  // nosemgrep: javascript.lang.security.detect-insecure-websocket.detect-insecure-websocket
+  tradingWsUrl: "ws://trading-api-ws:8080",
+  gasStationUrl: "http://fee-payer:8080",
+  deployment: NETNA_DEPLOYMENT,
+};
+
+export const NAMED_CONFIGS: Record<string, DecibelConfig | undefined> = {
+  netna: NETNA_CONFIG,
+  local: LOCAL_CONFIG,
+  docker: DOCKER_CONFIG,
+  testnet: TESTNET_CONFIG,
+};
+
+export const QUERY_PARAM_KEYS = {
+  offset: "offset",
+  limit: "limit",
+  sortKey: "sort_key",
+  sortDir: "sort_dir",
+  searchTerm: "search_term",
+};

package/src/fee-pay.ts

@@ -0,0 +1,39 @@
+import {
+  AccountAuthenticator,
+  PendingTransactionResponse,
+  SimpleTransaction,
+} from "@aptos-labs/ts-sdk";
+
+import { DecibelConfig } from "./constants";
+
+/**
+ * Submit a transaction with fee payer support
+ * @param config The Decibel configuration containing the gas station URL
+ * @param transaction The transaction to submit
+ * @param senderAuthenticator The sender's authenticator
+ * @returns A promise that resolves to the pending transaction response
+ */
+export async function submitFeePaidTransaction(
+  config: DecibelConfig,
+  transaction: SimpleTransaction,
+  senderAuthenticator: AccountAuthenticator,
+): Promise<PendingTransactionResponse> {
+  const signatureBcs = Array.from(senderAuthenticator.bcsToBytes());
+  const transactionBcs = Array.from(transaction.rawTransaction.bcsToBytes());
+  const body = JSON.stringify({
+    signature: signatureBcs,
+    transaction: transactionBcs,
+  });
+  const response = await fetch(config.gasStationUrl + "/transactions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body,
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  // TODO(bl): Error handling
+  return (await response.json()) as PendingTransactionResponse;
+}