@nadohq/shared 0.1.0-alpha.4

package/src/eip712/getNadoEIP712Values.ts

@@ -0,0 +1,248 @@
+import { subaccountToHex } from '../utils/bytes32';
+import { addDecimals, toIntegerString } from '../utils/math';
+import {
+  EIP712BurnNlpValues,
+  EIP712LeaderboardAuthenticationValues,
+  EIP712LinkSignerValues,
+  EIP712LiquidateSubaccountValues,
+  EIP712ListTriggerOrdersValues,
+  EIP712MintNlpValues,
+  EIP712OrderCancellationValues,
+  EIP712OrderValues,
+  EIP712ProductOrdersCancellationValues,
+  EIP712TransferQuoteValues,
+  EIP712WithdrawCollateralValues,
+  SignableRequestTypeToEIP712Values,
+} from './eip712ValueTypes';
+import {
+  SignableRequestType,
+  SignableRequestTypeToParams,
+} from './signableRequestType';
+import {
+  EIP712BurnNlpParams,
+  EIP712CancelOrdersParams,
+  EIP712CancelProductOrdersParams,
+  EIP712LeaderboardAuthenticationParams,
+  EIP712LinkSignerParams,
+  EIP712LiquidateSubaccountParams,
+  EIP712ListTriggerOrdersParams,
+  EIP712MintNlpParams,
+  EIP712OrderParams,
+  EIP712TransferQuoteParams,
+  EIP712WithdrawCollateralParams,
+} from './signatureParamTypes';
+
+/**
+ * Returns the EIP712 compatible values for signing.
+ *
+ * Note: We use the string representation of bigint to be compatible with JSON.stringify
+ *
+ * @param requestType
+ * @param params
+ */
+export function getNadoEIP712Values<TReqType extends SignableRequestType>(
+  requestType: TReqType,
+  params: SignableRequestTypeToParams[TReqType],
+): SignableRequestTypeToEIP712Values[TReqType] {
+  // Typescript does not yet support type narrowing + generic lookup types, hence the hacks here
+  let values: SignableRequestTypeToEIP712Values[keyof SignableRequestTypeToEIP712Values];
+  switch (requestType) {
+    case 'withdraw_collateral':
+      values = getWithdrawCollateralValues(
+        params as EIP712WithdrawCollateralParams,
+      );
+      break;
+    case 'place_order':
+      values = getOrderValues(params as EIP712OrderParams);
+      break;
+    case 'list_trigger_orders':
+      values = getListTriggerOrdersValues(
+        params as EIP712ListTriggerOrdersParams,
+      );
+      break;
+    case 'cancel_orders':
+      values = getOrderCancellationValues(params as EIP712CancelOrdersParams);
+      break;
+    case 'cancel_product_orders':
+      values = getProductOrdersCancellationValues(
+        params as EIP712CancelProductOrdersParams,
+      );
+      break;
+    case 'liquidate_subaccount':
+      values = getLiquidateSubaccountValues(
+        params as EIP712LiquidateSubaccountParams,
+      );
+      break;
+    case 'link_signer':
+      values = getLinkSignerValues(params as EIP712LinkSignerParams);
+      break;
+    case 'transfer_quote':
+      values = getTransferQuoteValues(params as EIP712TransferQuoteParams);
+      break;
+    case 'leaderboard_authentication':
+      values = getLeaderboardAuthenticationValues(
+        params as EIP712LeaderboardAuthenticationParams,
+      );
+      break;
+    case 'mint_nlp':
+      values = getMintNlpValues(params as EIP712MintNlpParams);
+      break;
+    case 'burn_nlp':
+      values = getBurnNlpValues(params as EIP712BurnNlpParams);
+      break;
+    default:
+      throw new Error(`Unsupported request type: ${requestType}`);
+  }
+
+  return values as SignableRequestTypeToEIP712Values[TReqType];
+}
+
+function getWithdrawCollateralValues(
+  params: EIP712WithdrawCollateralParams,
+): EIP712WithdrawCollateralValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    productId: params.productId,
+    amount: toIntegerString(params.amount),
+    nonce: params.nonce,
+  };
+}
+
+function getOrderValues(params: EIP712OrderParams): EIP712OrderValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    priceX18: toIntegerString(addDecimals(params.price)),
+    amount: toIntegerString(params.amount),
+    expiration: toIntegerString(params.expiration),
+    nonce: params.nonce,
+    appendix: toIntegerString(params.appendix),
+  };
+}
+
+function getListTriggerOrdersValues(
+  params: EIP712ListTriggerOrdersParams,
+): EIP712ListTriggerOrdersValues {
+  return {
+    recvTime: toIntegerString(params.recvTime),
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+  };
+}
+
+function getOrderCancellationValues(
+  params: EIP712CancelOrdersParams,
+): EIP712OrderCancellationValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    productIds: params.productIds,
+    digests: params.digests,
+    nonce: params.nonce,
+  };
+}
+
+function getProductOrdersCancellationValues(
+  params: EIP712CancelProductOrdersParams,
+): EIP712ProductOrdersCancellationValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    productIds: params.productIds,
+    nonce: params.nonce,
+  };
+}
+
+function getLiquidateSubaccountValues(
+  params: EIP712LiquidateSubaccountParams,
+): EIP712LiquidateSubaccountValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    liquidatee: subaccountToHex({
+      subaccountOwner: params.liquidateeOwner,
+      subaccountName: params.liquidateeName,
+    }),
+    mode: params.mode,
+    healthGroup: toIntegerString(params.healthGroup),
+    amount: toIntegerString(params.amount),
+    nonce: params.nonce,
+  };
+}
+
+function getLinkSignerValues(
+  params: EIP712LinkSignerParams,
+): EIP712LinkSignerValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    signer: params.signer,
+    nonce: params.nonce,
+  };
+}
+
+function getTransferQuoteValues(
+  params: EIP712TransferQuoteParams,
+): EIP712TransferQuoteValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    recipient: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.recipientSubaccountName,
+    }),
+    amount: toIntegerString(params.amount),
+    nonce: params.nonce,
+  };
+}
+
+function getLeaderboardAuthenticationValues(
+  params: EIP712LeaderboardAuthenticationParams,
+): EIP712LeaderboardAuthenticationValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    expiration: toIntegerString(params.expiration),
+  };
+}
+
+function getMintNlpValues(params: EIP712MintNlpParams): EIP712MintNlpValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    quoteAmount: toIntegerString(params.quoteAmount),
+    nonce: params.nonce,
+  };
+}
+
+function getBurnNlpValues(params: EIP712BurnNlpParams): EIP712BurnNlpValues {
+  return {
+    sender: subaccountToHex({
+      subaccountOwner: params.subaccountOwner,
+      subaccountName: params.subaccountName,
+    }),
+    nlpAmount: toIntegerString(params.nlpAmount),
+    nonce: params.nonce,
+  };
+}

package/src/eip712/getOrderVerifyingAddress.ts

@@ -0,0 +1,9 @@
+import { Address, toHex } from 'viem';
+
+/**
+ * The EIP712 verifying address for an order is defined as `address(uint160(productId))`
+ * @param productId
+ */
+export function getOrderVerifyingAddress(productId: number): Address {
+  return toHex(productId, { size: 20 });
+}

package/src/eip712/getSignedTransactionRequest.ts

@@ -0,0 +1,30 @@
+import { WalletClientWithAccount } from '../types/viemTypes';
+import { getNadoEIP712Domain } from './getNadoEIP712Domain';
+import { getNadoEIP712PrimaryType } from './getNadoEIP712PrimaryType';
+import { getNadoEIP712Types } from './getNadoEIP712Types';
+import { getNadoEIP712Values } from './getNadoEIP712Values';
+import {
+  SignableRequestType,
+  SignableRequestTypeToParams,
+} from './signableRequestType';
+
+interface Params<TReqType extends SignableRequestType> {
+  requestType: TReqType;
+  requestParams: SignableRequestTypeToParams[TReqType];
+  // Allow explicit definition of `chainId` to enable signing for different chains
+  chainId: number;
+  // Orderbook for orders, Sequencer for other requests
+  verifyingContract: string;
+  walletClient: WalletClientWithAccount;
+}
+
+export function getSignedTransactionRequest<
+  TReqType extends SignableRequestType,
+>(params: Params<TReqType>) {
+  return params.walletClient.signTypedData({
+    domain: getNadoEIP712Domain(params.verifyingContract, params.chainId),
+    types: getNadoEIP712Types(params.requestType),
+    primaryType: getNadoEIP712PrimaryType(params.requestType),
+    message: getNadoEIP712Values(params.requestType, params.requestParams),
+  });
+}

package/src/eip712/index.ts

@@ -0,0 +1,10 @@
+export * from './getSignedTransactionRequest';
+export * from './getNadoEIP712Values';
+export * from './getNadoEIP712Types';
+export * from './getNadoEIP712PrimaryType';
+export * from './getNadoEIP712Domain';
+export * from './orderDigest';
+export * from './signableRequestType';
+export * from './signatureParamTypes';
+export * from './eip712ValueTypes';
+export * from './getOrderVerifyingAddress';

package/src/eip712/orderDigest.ts

@@ -0,0 +1,28 @@
+import { hashTypedData } from 'viem';
+import { getNadoEIP712Domain } from './getNadoEIP712Domain';
+import { getNadoEIP712PrimaryType } from './getNadoEIP712PrimaryType';
+import { getNadoEIP712Types } from './getNadoEIP712Types';
+import { getNadoEIP712Values } from './getNadoEIP712Values';
+import { getOrderVerifyingAddress } from './getOrderVerifyingAddress';
+import { EIP712OrderParams } from './signatureParamTypes';
+
+interface OrderDigestParams {
+  order: EIP712OrderParams;
+  chainId: number;
+  productId: number;
+}
+
+/**
+ * Returns the EIP712 digest for an order
+ *
+ * @param params
+ */
+export function getOrderDigest(params: OrderDigestParams): string {
+  const { chainId, order, productId } = params;
+  return hashTypedData({
+    domain: getNadoEIP712Domain(getOrderVerifyingAddress(productId), chainId),
+    message: getNadoEIP712Values('place_order', order),
+    primaryType: getNadoEIP712PrimaryType('place_order'),
+    types: getNadoEIP712Types('place_order'),
+  });
+}

package/src/eip712/signableRequestType.ts

@@ -0,0 +1,32 @@
+import {
+  EIP712BurnNlpParams,
+  EIP712CancelOrdersParams,
+  EIP712CancelProductOrdersParams,
+  EIP712LeaderboardAuthenticationParams,
+  EIP712LinkSignerParams,
+  EIP712LiquidateSubaccountParams,
+  EIP712ListTriggerOrdersParams,
+  EIP712MintNlpParams,
+  EIP712OrderParams,
+  EIP712TransferQuoteParams,
+  EIP712WithdrawCollateralParams,
+} from './signatureParamTypes';
+
+/**
+ * All possible requests to be signed, to the expected params
+ */
+export interface SignableRequestTypeToParams {
+  burn_nlp: EIP712BurnNlpParams;
+  cancel_orders: EIP712CancelOrdersParams;
+  cancel_product_orders: EIP712CancelProductOrdersParams;
+  leaderboard_authentication: EIP712LeaderboardAuthenticationParams;
+  link_signer: EIP712LinkSignerParams;
+  liquidate_subaccount: EIP712LiquidateSubaccountParams;
+  list_trigger_orders: EIP712ListTriggerOrdersParams;
+  mint_nlp: EIP712MintNlpParams;
+  place_order: EIP712OrderParams;
+  transfer_quote: EIP712TransferQuoteParams;
+  withdraw_collateral: EIP712WithdrawCollateralParams;
+}
+
+export type SignableRequestType = keyof SignableRequestTypeToParams;

package/src/eip712/signatureParamTypes.ts

@@ -0,0 +1,84 @@
+import { Address } from 'viem';
+import { Subaccount } from '../types/subaccountTypes';
+import { BigDecimalish } from '../utils';
+
+export interface SignedTx<TBaseTx> {
+  tx: TBaseTx;
+  signature: string;
+}
+
+export interface SignedEIP712OrderParams {
+  order: EIP712OrderParams;
+  signature: string;
+}
+
+export interface EIP712WithdrawCollateralParams extends Subaccount {
+  productId: number;
+  amount: BigDecimalish;
+  nonce: string;
+}
+
+export interface EIP712LiquidateSubaccountParams extends Subaccount {
+  // Subaccount being liquidated
+  liquidateeOwner: string;
+  liquidateeName: string;
+  // 0 = spread, 1 = long, 2 = short
+  mode: number;
+  // Spot & perp pair
+  healthGroup: BigDecimalish;
+  amount: BigDecimalish;
+  nonce: string;
+}
+
+export interface EIP712OrderParams extends Subaccount {
+  // Expiration time in seconds, with order type encoded if relevant
+  expiration: BigDecimalish;
+  // Limit price
+  price: BigDecimalish;
+  // Positive for buy, negative for sell
+  amount: BigDecimalish;
+  // A unique nonce to identify the order
+  nonce: string;
+  // Packed order appendix (uint128) to encode order details such as order execution behavior, isolated, etc.
+  appendix: BigDecimalish;
+}
+
+export interface EIP712ListTriggerOrdersParams extends Subaccount {
+  recvTime: BigDecimalish;
+}
+
+export interface EIP712CancelOrdersParams extends Subaccount {
+  productIds: number[];
+  digests: string[];
+  nonce: string;
+}
+
+export interface EIP712CancelProductOrdersParams extends Subaccount {
+  productIds: number[];
+  nonce: string;
+}
+
+export interface EIP712LinkSignerParams extends Subaccount {
+  signer: Address;
+  nonce: string;
+}
+
+export interface EIP712TransferQuoteParams extends Subaccount {
+  recipientSubaccountName: string;
+  amount: BigDecimalish;
+  nonce: string;
+}
+
+export interface EIP712LeaderboardAuthenticationParams extends Subaccount {
+  expiration: BigDecimalish;
+}
+
+export interface EIP712MintNlpParams extends Subaccount {
+  quoteAmount: BigDecimalish;
+  nonce: string;
+}
+
+export interface EIP712BurnNlpParams extends Subaccount {
+  nlpAmount: BigDecimalish;
+  nonce: string;
+}

package/src/encoding/encoding.ts

@@ -0,0 +1,50 @@
+import { encodeAbiParameters, parseAbiParameters } from 'viem';
+import {
+  EIP712WithdrawCollateralParams,
+  SignedEIP712OrderParams,
+  SignedTx,
+} from '../eip712';
+import { addDecimals, toBigInt } from '../utils';
+
+export function encodeSignedWithdrawCollateralTx(
+  signed: SignedTx<EIP712WithdrawCollateralParams>,
+) {
+  return encodeAbiParameters(
+    parseAbiParameters(
+      '(tuple(address sender, string subaccountName, uint32 productId, uint128 amount, uint64 nonce), bytes signature)',
+    ),
+    [
+      [
+        [
+          signed.tx.subaccountOwner,
+          signed.tx.subaccountName,
+          signed.tx.productId,
+          signed.tx.amount,
+          signed.tx.nonce,
+        ],
+        signed.signature,
+      ],
+    ],
+  );
+}
+
+export function encodeSignedOrder(signed: SignedEIP712OrderParams) {
+  return encodeAbiParameters(
+    parseAbiParameters(
+      '(tuple(tuple(address sender, string subaccountName, int128 priceX18, int128 amount, uint64 expiration, uint64 nonce), bytes signature))',
+    ),
+    [
+      [
+        [
+          signed.order.subaccountOwner,
+          signed.order.subaccountName,
+          toBigInt(addDecimals(signed.order.price)),
+          signed.order.amount,
+          signed.order.expiration,
+          signed.order.nonce,
+        ],
+        signed.signature,
+      ],
+    ],
+  );
+}

package/src/encoding/index.ts

@@ -0,0 +1 @@
+export * from './encoding';

package/src/execute/approveDepositAllowance.ts

@@ -0,0 +1,20 @@
+import { ERC20_ABI } from '../abis';
+import { WithContract } from '../types/nadoContractTypes';
+import { WriteableContractInstance } from '../types/viemTypes';
+import { BigDecimalish, toBigInt } from '../utils';
+
+export interface ApproveDepositAllowanceParams {
+  amount: BigDecimalish;
+  tokenContract: WriteableContractInstance<typeof ERC20_ABI>;
+}
+
+/**
+ * Approves the endpoint contract to spend the amount of tokens specified
+ */
+export function approveDepositAllowance({
+  endpoint,
+  amount,
+  tokenContract,
+}: WithContract<'endpoint', ApproveDepositAllowanceParams>) {
+  return tokenContract.write.approve([endpoint.address, toBigInt(amount)]);
+}

package/src/execute/depositCollateral.ts

@@ -0,0 +1,43 @@
+import { toHex } from 'viem';
+import { WithContract } from '../types/nadoContractTypes';
+import { BigDecimalish, subaccountNameToBytes12, toBigInt } from '../utils';
+
+export interface DepositCollateralParams {
+  subaccountName: string;
+  productId: number;
+  amount: BigDecimalish;
+  referralCode?: string;
+}
+
+/**
+ * Deposits collateral through the Endpoint contract, which will be picked up automatically by the sequencer and
+ * submitted.
+ *
+ */
+export async function depositCollateral({
+  endpoint,
+  subaccountName,
+  productId,
+  amount,
+  referralCode,
+}: WithContract<'endpoint', DepositCollateralParams>) {
+  const subaccountNameHex = toHex(subaccountNameToBytes12(subaccountName));
+  if (referralCode) {
+    return endpoint.write.depositCollateralWithReferral([
+      // bytes12
+      subaccountNameHex,
+      // uint32
+      productId,
+      // uint128
+      toBigInt(amount),
+      // string
+      referralCode,
+    ]);
+  } else {
+    return endpoint.write.depositCollateral([
+      subaccountNameHex,
+      productId,
+      toBigInt(amount),
+    ]);
+  }
+}

package/src/execute/index.ts

@@ -0,0 +1,2 @@
+export * from './approveDepositAllowance';
+export * from './depositCollateral';

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './abis';
+export * from './consts';
+export * from './deployments';
+export * from './eip712';
+export * from './encoding';
+export * from './execute';
+export * from './types';
+export * from './utils';

package/src/types/ChainEnv.ts

@@ -0,0 +1,13 @@
+export const LOCAL_CHAIN_ENVS = ['local'] as const satisfies string[];
+
+export const TESTNET_CHAIN_ENVS = ['inkTestnet'] as const satisfies string[];
+
+export const MAINNET_CHAIN_ENVS = ['arbitrum'] as const satisfies string[];
+
+export const ALL_CHAIN_ENVS = [
+  ...LOCAL_CHAIN_ENVS,
+  ...TESTNET_CHAIN_ENVS,
+  ...MAINNET_CHAIN_ENVS,
+] as const satisfies string[];
+
+export type ChainEnv = (typeof ALL_CHAIN_ENVS)[number];

package/src/types/OrderExecutionType.ts

@@ -0,0 +1,8 @@
+/**
+ * Execution behavior of an order that can be sent to the engine:
+ * - `default`: Limit order
+ * - `ioc`: Immediate or Cancel order
+ * - `fok`: Fill or Kill order
+ * - `post_only`: Post Only order (will not match against existing orders)
+ */
+export type OrderExecutionType = 'default' | 'ioc' | 'fok' | 'post_only';

package/src/types/balanceTypes.ts

@@ -0,0 +1,47 @@
+import { BigDecimal } from '../utils/math';
+import { HealthType } from './healthTypes';
+import { PerpProduct, ProductEngineType, SpotProduct } from './productTypes';
+
+export type BalanceSide = 'long' | 'short';
+
+export type BalanceHealthContributions = Record<HealthType, BigDecimal>;
+
+/**
+ * Shared properties of a product balance
+ */
+interface BaseBalance {
+  type: ProductEngineType;
+  productId: number;
+  // Amount for the balance
+  amount: BigDecimal;
+  // Contributions to subaccount health
+  healthContributions: BalanceHealthContributions;
+}
+
+/**
+ * Balance for a perp product
+ */
+export interface PerpBalance extends BaseBalance {
+  type: ProductEngineType.PERP;
+  /**
+   * As there is no "quote" product for the perp engine, this is a representation of the net quote balance
+   * associated with the position. The entry cost and funding is rolled into this.
+   */
+  vQuoteBalance: BigDecimal;
+}
+
+export type PerpBalanceWithProduct = PerpBalance & PerpProduct;
+
+/**
+ * Balance for a spot product
+ */
+export interface SpotBalance extends BaseBalance {
+  type: ProductEngineType.SPOT;
+}
+
+export type SpotBalanceWithProduct = SpotBalance & SpotProduct;
+
+export type Balance = PerpBalance | SpotBalance;
+export type BalanceWithProduct =
+  | SpotBalanceWithProduct
+  | PerpBalanceWithProduct;

package/src/types/bytes.ts

@@ -0,0 +1 @@
+export type Bytes = Uint8Array;

package/src/types/healthTypes.ts

@@ -0,0 +1,17 @@
+import { BigDecimal } from '../utils/math';
+
+export type HealthType = 'maintenance' | 'initial' | 'unweighted';
+
+export interface HealthStatus {
+  health: BigDecimal;
+  assets: BigDecimal;
+  liabilities: BigDecimal;
+}
+
+export type HealthStatusByType = Record<HealthType, HealthStatus>;
+
+// Represents a "linked" pair of spot & perp product IDs used for spread health calculations
+export interface HealthGroup {
+  spotProductId: number;
+  perpProductId: number;
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+export * from './balanceTypes';
+export * from './bytes';
+export * from './ChainEnv';
+export * from './healthTypes';
+export * from './marketTypes';
+export * from './productTypes';
+export * from './subaccountTypes';
+export * from './nadoContractTypes';
+export * from './viemTypes';
+export * from './OrderExecutionType';
+export * from './orderAppendixTypes';