@reyaxyz/sdk 0.1.0

package/src/index.ts

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

package/src/services/encode.ts

@@ -0,0 +1,72 @@
+////////////////////  ENCODE SINGLE  ////////////////////
+
+import { MethodParameters, MultiAction } from '../utils/action';
+import { CommandType, getCommand } from '../utils/routerCommands';
+import { AbiCoder, Interface } from 'ethers';
+import { abi } from '../abis/ExecutionModule.json';
+// const abi = [
+//   'function coreExecute(uint128 poolId, uint128 accountId, Command[] commands, EIP712Signature sig)',
+// ];
+export const encodeSingleDeposit = (
+  token: string,
+  amount: bigint,
+  marketId: number,
+  exchangeId: number,
+  multiAction: MultiAction,
+): void => {
+  multiAction.newAction(
+    getCommand(CommandType.DEPOSIT, [token, amount], marketId, exchangeId),
+  );
+};
+
+export const encodeSingleWithdraw = (
+  token: string,
+  amount: bigint,
+  marketId: number,
+  exchangeId: number,
+  multiAction: MultiAction,
+): void => {
+  multiAction.newAction(
+    getCommand(CommandType.WITHDRAW, [token, amount], marketId, exchangeId),
+  );
+};
+
+export const encodeSingleTrade = (
+  counterpartyAccountIds: number[],
+  orderBase: bigint,
+  orderPriceLimit: bigint,
+  marketId: number,
+  exchangeId: number,
+  multiAction: MultiAction,
+): void => {
+  // (int256 orderBase, UD60x18 orderPriceLimit) = abi.decode(matchOrderInputs.inputs, (int256, UD60x18));
+  const encodedBasePrice = AbiCoder.defaultAbiCoder().encode(
+    ['int256', 'uint256'], // @todo check if uint256 casts to UD60x18
+    [orderBase, orderPriceLimit],
+  );
+
+  multiAction.newAction(
+    getCommand(
+      CommandType.MATCH_ORDER,
+      [counterpartyAccountIds, encodedBasePrice],
+      marketId,
+      exchangeId,
+    ),
+  );
+};
+
+export const encodeRouterCall = (
+  multiAction: MultiAction,
+  accountId: number,
+  nativeCurrencyValue: bigint,
+): MethodParameters => {
+  const functionSignature = 'execute';
+  const parameters = [accountId, multiAction.commands];
+
+  const INTERFACE = new Interface(abi);
+  const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
+  return {
+    calldata: calldata,
+    value: BigInt(nativeCurrencyValue).toString(10),
+  };
+};

package/src/services/executeTransaction.ts

@@ -0,0 +1,54 @@
+import { Signer } from 'ethers';
+import { getGasBuffer } from '../utils/txHelpers';
+
+export type Transaction = {
+  from: string;
+  to: string;
+  data: string;
+  value?: string;
+};
+
+export async function estimateGas(
+  signer: Signer,
+  data: string,
+  value: string,
+  chainId: number,
+): Promise<Transaction & { gasLimit: bigint }> {
+  console.log(chainId); // @todo remove chainId if obsolete
+  const accountAddress = await signer.getAddress();
+  const contractAddress = `0xdb8cd625873ca9d7b6529ffafe5ecdd3746708b4`; // @todo Define after deployment
+  const tx = {
+    from: accountAddress,
+    to: contractAddress,
+    data,
+    ...(value && value !== '0' ? { value: value } : {}),
+  };
+
+  let gasLimit: bigint;
+
+  try {
+    const gasEstimate = await signer.estimateGas(tx);
+    gasLimit = getGasBuffer(gasEstimate);
+  } catch (error) {
+    console.warn(error);
+    throw new Error(error as string);
+  }
+  return { ...tx, gasLimit };
+}
+
+export async function executeTransaction(
+  signer: Signer,
+  data: string,
+  value: string,
+  chainId: number,
+) {
+  const txData = await estimateGas(signer, data, value, chainId);
+  try {
+    const txResponse = await signer.sendTransaction(txData);
+    const txReceipt = await txResponse.wait(); // @todo Check what was reasoning behind this since this function waits until transaction is minted
+    return txReceipt;
+  } catch (error) {
+    console.warn(error);
+    throw new Error('Transaction Execution Error');
+  }
+}

package/src/services/lp/encode.ts

@@ -0,0 +1,36 @@
+import { MethodParameters } from '../../utils/action';
+import { Interface } from 'ethers';
+
+// @todo Update ABI
+const provideLiquidityAbi = [
+  'function addLiquidity(uint128 poolId, address owner, uint256 amount, uint256 minShares) returns (uint256)',
+];
+
+// @todo Update ABI
+const removeLiquidityabi = [
+  'function removeLiquidity(uint128 poolId, uint256 sharesAmount, uint256 minOut) returns (uint256)',
+];
+export const encodeProvideLiquidityCall = (
+  poolId: number,
+  accountOwner: string,
+  amount: number,
+  minShares: number,
+): MethodParameters => {
+  const functionSignature = 'addLiquidity';
+  const parameters = [poolId, accountOwner, amount, minShares];
+  const INTERFACE = new Interface(provideLiquidityAbi);
+  const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
+  return { calldata: calldata, value: BigInt(0).toString(10) };
+};
+
+export const encodeRemoveLiquidityCall = (
+  poolId: number,
+  sharesAmount: number,
+  minOut: number,
+): MethodParameters => {
+  const functionSignature = 'removeLiquidity';
+  const parameters = [poolId, sharesAmount, minOut];
+  const INTERFACE = new Interface(removeLiquidityabi);
+  const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
+  return { calldata: calldata, value: BigInt(0).toString(10) };
+};

package/src/services/lp/lp.ts

@@ -0,0 +1,47 @@
+import { executeTransaction } from '../executeTransaction';
+import {
+  encodeProvideLiquidityCall,
+  encodeRemoveLiquidityCall,
+} from './encode';
+import { ProvideLiquidityArgs, RemoveLiquidityArgs } from './types';
+
+export const provideLiquidity = async (
+  params: ProvideLiquidityArgs,
+): Promise<unknown> => {
+  // @todo update type once we agree on the structure
+  const { calldata: data, value } = encodeProvideLiquidityCall(
+    params.poolId,
+    params.owner,
+    params.amount,
+    params.minShares,
+  );
+
+  const result = await executeTransaction(
+    params.signer,
+    data,
+    value,
+    params.chainId,
+  );
+
+  return result;
+};
+
+export const removeLiquidity = async (
+  params: RemoveLiquidityArgs,
+): Promise<unknown> => {
+  // @todo update type once we agree on the structure
+  const { calldata: data, value } = encodeRemoveLiquidityCall(
+    params.poolId,
+    params.sharesAmount,
+    params.minOut,
+  );
+
+  const result = await executeTransaction(
+    params.signer,
+    data,
+    value,
+    params.chainId,
+  );
+
+  return result;
+};

package/src/services/lp/types.ts

@@ -0,0 +1,18 @@
+import { Signer } from 'ethers';
+
+export type ProvideLiquidityArgs = {
+  signer: Signer;
+  chainId: number;
+  poolId: number;
+  owner: string;
+  amount: number;
+  minShares: number;
+};
+
+export type RemoveLiquidityArgs = {
+  signer: Signer;
+  chainId: number;
+  poolId: number;
+  sharesAmount: number;
+  minOut: number;
+};

package/src/services/margin-accounts/account.ts

@@ -0,0 +1,21 @@
+import { executeTransaction } from '../executeTransaction';
+import { encodeCreateAccountCall } from './encode';
+import { CreateAccountArgs } from './types';
+
+export const createAccount = async (
+  params: CreateAccountArgs,
+): Promise<unknown> => {
+  // @todo update type once we agree on the structure
+  const { calldata: data, value } = encodeCreateAccountCall(
+    params.ownerAddress,
+  );
+
+  const result = await executeTransaction(
+    params.signer,
+    data,
+    value,
+    params.chainId,
+  );
+
+  return result;
+};

package/src/services/margin-accounts/deposit.ts

@@ -0,0 +1,23 @@
+import { DepositArgs } from './types';
+import { encodeDeposit } from './encode';
+import { executeTransaction } from '../executeTransaction';
+
+export const deposit = async (params: DepositArgs): Promise<unknown> => {
+  // @todo update type once we agree on the structure
+  const { calldata: data, value } = encodeDeposit(
+    params.accountId,
+    params.token,
+    params.amount,
+    params.marketId,
+    params.exchangeId,
+  );
+
+  const result = await executeTransaction(
+    params.signer,
+    data,
+    value,
+    params.chainId,
+  );
+
+  return result;
+};

package/src/services/margin-accounts/encode.ts

@@ -0,0 +1,56 @@
+import { MethodParameters, MultiAction } from '../../utils/action';
+import { Interface } from 'ethers';
+import {
+  encodeRouterCall,
+  encodeSingleDeposit,
+  encodeSingleWithdraw,
+} from '../encode';
+
+import { abi } from '../../abis/AccountModule.json';
+export const encodeCreateAccountCall = (
+  accountOwner: string,
+): MethodParameters => {
+  const functionSignature = 'createAccount';
+  const parameters = [accountOwner];
+  const INTERFACE = new Interface(abi);
+  const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
+  return { calldata: calldata, value: BigInt(0).toString(10) };
+};
+
+export const encodeDeposit = (
+  accountId: number,
+  token: string,
+  amount: bigint,
+  marketId: number,
+  exchangeId: number,
+): MethodParameters => {
+  const multiAction = new MultiAction();
+
+  encodeSingleDeposit(token, amount, marketId, exchangeId, multiAction);
+
+  const value = BigInt(0);
+  const call = encodeRouterCall(multiAction, accountId, value);
+
+  return {
+    ...call,
+  };
+};
+
+export const encodeWithdraw = (
+  accountId: number,
+  token: string,
+  amount: bigint,
+  marketId: number,
+  exchangeId: number,
+): MethodParameters => {
+  const multiAction = new MultiAction();
+
+  encodeSingleWithdraw(token, amount, marketId, exchangeId, multiAction);
+
+  const value = BigInt(0);
+  const call = encodeRouterCall(multiAction, accountId, value);
+
+  return {
+    ...call,
+  };
+};

package/src/services/margin-accounts/types.ts

@@ -0,0 +1,27 @@
+import { Signer } from 'ethers';
+
+export type CreateAccountArgs = {
+  signer: Signer;
+  chainId: number;
+  ownerAddress: string;
+};
+
+export type DepositArgs = {
+  signer: Signer;
+  chainId: number;
+  accountId: number;
+  token: string;
+  amount: bigint;
+  marketId: number;
+  exchangeId: number;
+};
+
+export type WithdrawArgs = {
+  signer: Signer;
+  chainId: number;
+  accountId: number;
+  token: string;
+  amount: bigint;
+  marketId: number;
+  exchangeId: number;
+};

package/src/services/margin-accounts/withdraw.ts

@@ -0,0 +1,23 @@
+import { WithdrawArgs } from './types';
+import { encodeWithdraw } from './encode';
+import { executeTransaction } from '../executeTransaction';
+
+export const withdraw = async (params: WithdrawArgs): Promise<unknown> => {
+  // @todo update type once we agree on the structure
+  const { calldata: data, value } = encodeWithdraw(
+    params.accountId,
+    params.token,
+    params.amount,
+    params.marketId,
+    params.exchangeId,
+  );
+
+  const result = await executeTransaction(
+    params.signer,
+    data,
+    value,
+    params.chainId,
+  );
+
+  return result;
+};

package/src/services/orders/encode.ts

@@ -0,0 +1,29 @@
+import { MethodParameters, MultiAction } from '../../utils/action';
+import { encodeRouterCall, encodeSingleTrade } from '../encode';
+
+export const encodeMatchOrder = (
+  accountId: number,
+  orderBase: bigint,
+  orderPriceLimit: bigint,
+  counterpartyAccountIds: number[],
+  marketId: number,
+  exchangeId: number,
+): MethodParameters => {
+  const multiAction = new MultiAction();
+
+  encodeSingleTrade(
+    counterpartyAccountIds,
+    orderBase,
+    orderPriceLimit,
+    marketId,
+    exchangeId,
+    multiAction,
+  );
+
+  const value = BigInt(0);
+  const call = encodeRouterCall(multiAction, accountId, value);
+
+  return {
+    ...call,
+  };
+};

package/src/services/orders/order.ts

@@ -0,0 +1,24 @@
+import { MatchOrderArgs } from './types';
+import { encodeMatchOrder } from './encode';
+import { executeTransaction } from '../executeTransaction';
+
+export const matchOrder = async (params: MatchOrderArgs): Promise<unknown> => {
+  // @todo update type once we agree on the structure
+  const { calldata: data, value } = encodeMatchOrder(
+    params.accountId,
+    params.orderBase,
+    params.orderPriceLimit,
+    params.counterpartyAccountIds,
+    params.marketId,
+    params.exchangeId,
+  );
+
+  const result = await executeTransaction(
+    params.signer,
+    data,
+    value,
+    params.chainId,
+  );
+
+  return result;
+};

package/src/services/orders/types.ts

@@ -0,0 +1,12 @@
+import { Signer } from 'ethers';
+
+export type MatchOrderArgs = {
+  signer: Signer;
+  chainId: number;
+  accountId: number;
+  orderBase: bigint;
+  orderPriceLimit: bigint;
+  counterpartyAccountIds: number[];
+  marketId: number;
+  exchangeId: number;
+};

package/src/utils/action.ts

@@ -0,0 +1,41 @@
+// ENCODED ACTIONS
+
+import { CommandType } from './routerCommands';
+
+export type MethodParameters = {
+  /**
+   * The hex encoded calldata to perform the given operation
+   */
+  calldata: string;
+  /**
+   * The amount of ether (wei) to send in hex.
+   */
+  value: string;
+};
+
+export type Command = {
+  commandType: CommandType;
+  inputs: string;
+  marketId: number;
+  exchangeId: number;
+};
+
+export type SingleAction = {
+  command: Command;
+};
+
+export class MultiAction {
+  public commands: Command[];
+
+  constructor() {
+    this.commands = [];
+  }
+
+  public get length(): number {
+    return this.commands.length;
+  }
+
+  public newAction(singleAction: SingleAction): void {
+    this.commands.push(singleAction.command);
+  }
+}

package/src/utils/routerCommands.ts

@@ -0,0 +1,58 @@
+import { AbiCoder } from 'ethers';
+import { SingleAction } from './action';
+
+/**
+ * CommandTypes
+ * @description Flags that modify a command's execution
+ * @enum {number}
+ */
+export enum CommandType {
+  DEPOSIT,
+  WITHDRAW,
+  MATCH_ORDER,
+  PROPAGATE_CACHE_FLOW,
+}
+
+const ABI_DEFINITION: { [key in CommandType]: string[] } = {
+  [CommandType.DEPOSIT]: ['address', 'uint256'],
+  [CommandType.WITHDRAW]: ['address', 'uint256'],
+  [CommandType.MATCH_ORDER]: ['uint128[]', 'bytes'],
+  [CommandType.PROPAGATE_CACHE_FLOW]: [], // @todo Check if correct
+};
+
+export type RouterCommand = {
+  type: CommandType;
+  encodedInput: string;
+  marketId: number;
+  exchangeId: number;
+};
+
+export function createCommand(
+  type: CommandType,
+  parameters: unknown[],
+  marketId: number,
+  exchangeId: number,
+): RouterCommand {
+  const encodedInput = AbiCoder.defaultAbiCoder().encode(
+    ABI_DEFINITION[type],
+    parameters,
+  );
+  return { type, encodedInput, marketId, exchangeId };
+}
+
+export function getCommand(
+  type: CommandType,
+  parameters: unknown[],
+  marketId: number,
+  exchangeId: number,
+): SingleAction {
+  const command = createCommand(type, parameters, marketId, exchangeId);
+  return {
+    command: {
+      commandType: command.type,
+      inputs: command.encodedInput,
+      marketId: command.marketId,
+      exchangeId: command.exchangeId,
+    },
+  };
+}

package/src/utils/txHelpers.ts

@@ -0,0 +1,3 @@
+export function getGasBuffer(value: bigint): bigint {
+  return (value * BigInt(120)) / BigInt(100);
+}