@reyaxyz/common 0.97.0 → 0.98.1

package/src/transactions/abis/socket/VaultWithPayload.json

@@ -0,0 +1,40 @@
+{
+  "abi": [
+    {
+      "type": "function",
+      "name": "bridge",
+      "inputs": [
+        {
+          "name": "receiver_",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "amount_",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "msgGasLimit_",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "connector_",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "execPayload_",
+          "type": "bytes",
+          "internalType": "bytes"
+        },
+        {
+          "name": "options_",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ]
+    }
+  ]
+}

package/src/transactions/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/transactions/consts.ts

@@ -0,0 +1,3 @@
+export const BRIDGE_DEADLINE_IN_SECONDS = 15 * 60; // 15 minutes
+export const CORE_DEADLINE_IN_SECONDS = 60; // 1 minute
+export const RELAYER_ACCOUNT = '0xb43c317c9c9215d268881d7d6b59c2d3d0247da1'; // @todo update value

package/src/transactions/contractAddresses.ts

@@ -0,0 +1,41 @@
+import { Address, ReyaChainId } from '../types';
+
+export enum ContractType {
+  CORE_PROXY = 'core_proxy',
+  PASSIVE_POOL_PROXY = 'passive_pool_proxy',
+  PERIPHERY_PROXY = 'periphery_proxy',
+}
+
+const addresses: Record<ReyaChainId, Record<ContractType, Address>> = {
+  [ReyaChainId.reyaCronos]: {
+    [ContractType.CORE_PROXY]: '0x20da8f7aa44f858a3a3e3f03ba6ffad039d1eb28',
+    [ContractType.PASSIVE_POOL_PROXY]:
+      '0x9afc30bed29d636e566fd9d7dd89d51773724be6',
+    [ContractType.PERIPHERY_PROXY]:
+      '0xa45d0566144956b6012d461ad509dad2bacacaaf',
+  },
+  [ReyaChainId.reyaNetwork]: {
+    [ContractType.CORE_PROXY]: '0xa763b6a5e09378434406c003dae6487fbbdc1a80',
+    [ContractType.PASSIVE_POOL_PROXY]:
+      '0xb4b77d6180cc14472a9a7bdff01cc2459368d413',
+    [ContractType.PERIPHERY_PROXY]:
+      '0xcd2869d1eb1bc8991bc55de9e9b779e912faf736',
+  },
+};
+export const getAddress = (
+  chainId: number,
+  contractName: ContractType,
+): Address => {
+  const keyChainId = chainId.toString();
+
+  if (!Object.keys(addresses).includes(keyChainId)) {
+    throw new Error(`Unspecified addresses for chain id ${keyChainId}`);
+  }
+
+  const networkAddresses = addresses[chainId as ReyaChainId];
+  if (!Object.keys(networkAddresses).includes(contractName)) {
+    throw new Error(`Unspecified address for ${contractName} contract`);
+  }
+
+  return networkAddresses[contractName];
+};

package/src/transactions/executeTransaction.ts

@@ -0,0 +1,83 @@
+import { JsonRpcSigner, Signer } from 'ethers';
+import { ReyaChainId } from '../types';
+import { ContractType, getAddress } from './contractAddresses';
+import { getGasBuffer } from './txHelpers';
+
+export type Transaction = {
+  from: string;
+  to: string;
+  data: string;
+  value?: string;
+};
+
+export async function estimateGas(
+  signer: Signer | JsonRpcSigner,
+  data: string,
+  value: string,
+  chainId: number,
+  targetContract: ContractType | string,
+): Promise<
+  Transaction & {
+    gasLimit: bigint;
+    maxPriorityFeePerGas?: bigint;
+    maxFeePerGas?: bigint;
+  }
+> {
+  const accountAddress = await signer.getAddress();
+
+  const contractAddress = Object.values(ContractType).includes(
+    targetContract as ContractType,
+  )
+    ? getAddress(chainId, targetContract as ContractType)
+    : targetContract;
+  const tx = {
+    from: accountAddress, // @todo Update with relayer address
+    to: contractAddress,
+    data,
+    ...(value && value !== '0' ? { value: value } : {}),
+  };
+
+  let gasLimit: bigint = BigInt('5000000'); // hardcode to 5m gas limit if fails to get estimate
+
+  try {
+    const gasEstimate = await signer.estimateGas(tx);
+    gasLimit = getGasBuffer(gasEstimate);
+  } catch (error) {
+    // sentry error & thorw
+    console.warn(error);
+    throw new Error('Error executing transaction'); // @todo introduce error parsing
+  }
+
+  if (Object.values(ReyaChainId).includes(chainId as ReyaChainId)) {
+    const maxPriorityFeePerGas: bigint = BigInt('0');
+    const maxFeePerGas: bigint = BigInt('100000000');
+    return { ...tx, gasLimit, maxPriorityFeePerGas, maxFeePerGas };
+  }
+
+  return { ...tx, gasLimit };
+}
+
+export async function executeTransaction(
+  signer: Signer | JsonRpcSigner,
+  data: string,
+  value: string,
+  chainId: number,
+  targetContract: ContractType | string,
+) {
+  const txData = await estimateGas(
+    signer,
+    data,
+    value,
+    chainId,
+    targetContract,
+  );
+
+  try {
+    const txResponse = await signer.sendTransaction(txData);
+    const txReceipt = await txResponse.wait();
+    return txReceipt;
+  } catch (error) {
+    console.warn(error);
+    throw new Error('Transaction Execution Error');
+  }
+}

package/src/transactions/index.ts

@@ -0,0 +1,11 @@
+export * from './action';
+export { abi as CoreAbi } from './abis/CoreProxy.json';
+export { abi as PeripheryAbi } from './abis/Periphery.json';
+export { abi as Socket_VaultWithPayloadAbi } from './abis/socket/VaultWithPayload.json';
+export * from './contractAddresses';
+export * from './routerCommands';
+export * from './sign';
+export * from './trade';
+export * from './txHelpers';
+export * from './consts';
+export * from './executeTransaction';

package/src/transactions/routerCommands.ts

@@ -0,0 +1,62 @@
+import { AbiCoder } from 'ethers';
+import { SingleAction } from './action';
+
+/**
+ * CommandTypes
+ * @description Flags that modify a command's execution
+ * @enum {number}
+ */
+export enum CommandType {
+  DEPOSIT,
+  WITHDRAW,
+  DUTCH_LIQUIDATION,
+  MATCH_ORDER,
+  PROPAGATE_CACHE_FLOW,
+  TRANSFER_MARGIN_ACCOUNT,
+}
+
+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
+  [CommandType.DUTCH_LIQUIDATION]: ['tuple(uint128,address,uint128[],bytes)'],
+  [CommandType.TRANSFER_MARGIN_ACCOUNT]: ['tuple(uint128,address,uint256)'], // @todo update once needed
+};
+
+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/transactions/sign.ts

@@ -0,0 +1,135 @@
+import { JsonRpcSigner, Signature, Signer, TypedDataField } from 'ethers';
+import { ContractType, getAddress } from './contractAddresses';
+import { Command } from './action';
+import { ethers } from 'ethers';
+import { Address, ReyaChainId } from '../types';
+
+export type EIP712Signature = {
+  v: number;
+  r: string;
+  s: string;
+  deadline: number;
+};
+
+function convertEthersSignatureToEIP712Signature(
+  signature: Signature,
+  deadline: number,
+): EIP712Signature {
+  return {
+    v: signature.v,
+    r: signature.r,
+    s: signature.s,
+    deadline: deadline,
+  };
+}
+
+export async function signCoreCommands(
+  signer: Signer | JsonRpcSigner,
+  reyaChainId: ReyaChainId,
+  caller: Address,
+  accountId: number,
+  commands: Command[],
+  nonce: number,
+  deadline: number,
+  extraSignatureData: string,
+): Promise<EIP712Signature> {
+  const signature = await signReyaTypedData(
+    signer,
+    getAddress(reyaChainId, ContractType.CORE_PROXY),
+    {
+      ExecuteBySig: [
+        { name: 'verifyingChainId', type: 'uint256' },
+        { name: 'caller', type: 'address' },
+        { name: 'accountId', type: 'uint128' },
+        { name: 'commands', type: 'Command[]' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+        { name: 'extraSignatureData', type: 'bytes' },
+      ],
+      Command: [
+        { name: 'commandType', type: 'uint8' },
+        { name: 'inputs', type: 'bytes' },
+        { name: 'marketId', type: 'uint128' },
+        { name: 'exchangeId', type: 'uint128' },
+      ],
+    },
+    {
+      verifyingChainId: reyaChainId,
+      caller: caller,
+      accountId: accountId,
+      commands: commands,
+      nonce: nonce,
+      deadline: deadline,
+      extraSignatureData: extraSignatureData,
+    },
+  );
+
+  return convertEthersSignatureToEIP712Signature(signature, deadline);
+}
+
+export async function signPoolRemoveLiquidity(
+  signer: Signer | JsonRpcSigner,
+  reyaChainId: ReyaChainId,
+  caller: Address,
+  owner: Address,
+  poolId: number,
+  sharesAmount: bigint,
+  minOut: bigint,
+  nonce: number,
+  deadline: number,
+  socketMsgGasLimit: bigint,
+  chainId: number,
+  receiver: string,
+): Promise<EIP712Signature> {
+  const signature = await signReyaTypedData(
+    signer,
+    getAddress(reyaChainId, ContractType.PASSIVE_POOL_PROXY),
+    {
+      RemoveLiquidityBySig: [
+        { name: 'verifyingChainId', type: 'uint256' },
+        { name: 'caller', type: 'address' },
+        { name: 'owner', type: 'address' },
+        { name: 'poolId', type: 'uint128' },
+        { name: 'sharesAmount', type: 'uint256' },
+        { name: 'minOut', type: 'uint256' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+        { name: 'extraSignatureData', type: 'bytes' },
+      ],
+    },
+    {
+      verifyingChainId: reyaChainId,
+      caller: caller,
+      owner: owner,
+      poolId: poolId,
+      sharesAmount: sharesAmount,
+      minOut: minOut,
+      nonce: nonce,
+      deadline: deadline,
+      extraSignatureData: ethers.AbiCoder.defaultAbiCoder().encode(
+        ['address', 'uint256', 'uint256'],
+        [receiver, chainId, socketMsgGasLimit],
+      ),
+    },
+  );
+
+  return convertEthersSignatureToEIP712Signature(signature, deadline);
+}
+
+async function signReyaTypedData(
+  signer: Signer | JsonRpcSigner,
+  verifyingContract: string,
+  types: Record<string, Array<TypedDataField>>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  value: Record<string, any>,
+): Promise<Signature> {
+  const domain = {
+    name: 'Reya',
+    version: '1',
+    verifyingContract: verifyingContract,
+  };
+
+  const signatureString = await signer.signTypedData(domain, types, value);
+
+  return Signature.from(signatureString);
+}

package/src/transactions/trade.ts

@@ -0,0 +1,25 @@
+import BigNumber from 'bignumber.js';
+
+// todo: need the ability to supply custom slippage or use a more conservative default for the slippage tolerance
+export function calculatePriceLimitForTrade(
+  orderPrice: number,
+  amount: number,
+): bigint {
+  // Ensure orderPrice is BigInt
+  const orderPriceBigInt = BigNumber(orderPrice);
+
+  // Calculate 50% of the order price
+  const offset = orderPriceBigInt.div(2);
+
+  // Determine if the amount is positive or negative and adjust the price accordingly
+  if (amount > 0) {
+    // Trade is long, so add
+    return BigInt(
+      BigNumber(orderPriceBigInt).plus(offset).times(1e18).toFixed(0),
+    );
+  } else {
+    return BigInt(
+      BigNumber(orderPriceBigInt).minus(offset).times(1e18).toFixed(0),
+    );
+  }
+}

package/src/transactions/txHelpers.ts

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