@reyaxyz/sdk 0.146.8 → 0.147.1

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

@@ -1,14 +1,8 @@
-import {
-  MethodParameters,
-  MultiAction,
-  OFTSendParam,
-  OFTMessagingFee,
-} from '@reyaxyz/common';
+import { MethodParameters, MultiAction } from '@reyaxyz/common';
 import { Interface } from 'ethers';
 import { encodeSingleTransferMargin } from '../encode';
 import {
   CoreAbi as abi,
-  OFTAbi as OFTAbi,
   PeripheryAbi,
   Socket_VaultWithPayloadAbi,
   CORE_DEADLINE_IN_SECONDS,
@@ -21,12 +15,6 @@ import { getCurrentTimestampInSeconds } from '@reyaxyz/common';
 import { Signer } from 'ethers';
 import { ethers } from 'ethers';
 
-enum LzComposerOperationType {
-  NONE = 0,
-  DEPOSIT_SPOT_ACCOUNT = 1,
-  DEPOSIT_ACCOUNT = 2,
-}
-
 export const encodeCreateAccountCall = (
   accountOwner: string,
 ): MethodParameters => {
@@ -142,141 +130,3 @@ export const encodeBridgeAndDepositExistingMA = (
   const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
   return { calldata: calldata, value: socketFees.toString(10) };
 };
-
-export const encodeWithdrawMALZ = (
-  accountId: number,
-  corePeripheryTokenAddress: string,
-  corePeripheryTokenAmount: bigint,
-  sig: EIP712Signature,
-  dstEid: number,
-  receiver: string,
-): MethodParameters => {
-  const functionSignature = 'withdrawMALZ';
-  const parameters = [
-    {
-      accountId,
-      token: corePeripheryTokenAddress,
-      tokenAmount: corePeripheryTokenAmount,
-      sig,
-      dstEid,
-      receiver,
-    },
-  ];
-  const INTERFACE = new Interface(PeripheryAbi);
-  const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
-  return { calldata: calldata, value: BigInt(0).toString(10) };
-};
-
-// Gas for lzReceive on destination: token credit + endpoint.sendCompose() queuing
-const LZ_RECEIVE_GAS = 1_000_000;
-// Gas estimate for lzCompose execution on destination chain
-// Covers: abi.decode + createOrGetSpotAccount/depositExistingMA in OftModule.lzCompose
-const LZ_COMPOSE_GAS = 1_000_000;
-
-/**
- * Encode LZ v3 extraOptions with both lzReceive and lzCompose options.
- * Required for msgType=2 (SEND_AND_CALL) since enforced options only cover msgType=1.
- */
-export const encodeLzSendAndComposeExtraOptions = (
-  receiveGas: number,
-  composeGas: number,
-): string => {
-  // Options v3 layout:
-  //   TYPE_3 header:           uint16(3)
-  //   --- lzReceive option ---
-  //   WORKER_ID:               uint8(1)
-  //   length:                  uint16(17) = OPTION_TYPE(1) + GAS(16)
-  //   OPTION_TYPE_LZRECEIVE:   uint8(1)
-  //   gas:                     uint128
-  //   --- lzCompose option ---
-  //   WORKER_ID:               uint8(1)
-  //   length:                  uint16(19) = OPTION_TYPE(1) + INDEX(2) + GAS(16)
-  //   OPTION_TYPE_LZCOMPOSE:   uint8(3)
-  //   index:                   uint16(0)
-  //   gas:                     uint128
-  return ethers.solidityPacked(
-    [
-      'uint16',
-      'uint8',
-      'uint16',
-      'uint8',
-      'uint128',
-      'uint8',
-      'uint16',
-      'uint8',
-      'uint16',
-      'uint128',
-    ],
-    [3, 1, 17, 1, receiveGas, 1, 19, 3, 0, composeGas],
-  );
-};
-
-export const buildOFTBridgeAndDepositExistingMASendParam = (
-  dstEid: number,
-  receiverAddress: string,
-  accountId: number,
-  peripheryTokenAddress: string,
-  amountLD: bigint,
-  minAmountLD: bigint,
-): { sendParam: OFTSendParam; composeMsg: string } => {
-  const opType = LzComposerOperationType.DEPOSIT_ACCOUNT;
-  const opData = ethers.AbiCoder.defaultAbiCoder().encode(
-    ['uint128', 'address'],
-    [accountId, peripheryTokenAddress],
-  );
-
-  const composeMsg = ethers.AbiCoder.defaultAbiCoder().encode(
-    ['uint8', 'bytes'],
-    [opType, opData],
-  );
-
-  const receiverBytes32 = ethers.zeroPadValue(receiverAddress, 32);
-  const extraOptions = encodeLzSendAndComposeExtraOptions(
-    LZ_RECEIVE_GAS,
-    LZ_COMPOSE_GAS,
-  );
-
-  const sendParam: OFTSendParam = {
-    dstEid,
-    to: receiverBytes32,
-    amountLD,
-    minAmountLD,
-    extraOptions,
-    composeMsg,
-    oftCmd: '0x',
-  };
-
-  return { sendParam, composeMsg };
-};
-
-export const encodeOFTBridgeAndDepositExistingMA = (
-  dstEid: number,
-  receiverAddress: string,
-  accountId: number,
-  peripheryTokenAddress: string,
-  amountLD: bigint,
-  minAmountLD: bigint,
-  messagingFee: OFTMessagingFee,
-  callerAddress: string,
-): MethodParameters => {
-  const { sendParam } = buildOFTBridgeAndDepositExistingMASendParam(
-    dstEid,
-    receiverAddress,
-    accountId,
-    peripheryTokenAddress,
-    amountLD,
-    minAmountLD,
-  );
-
-  const INTERFACE = new Interface(OFTAbi);
-  const calldata = INTERFACE.encodeFunctionData('send', [
-    sendParam,
-    messagingFee,
-    callerAddress,
-  ]);
-
-  return {
-    calldata,
-    value: messagingFee.nativeFee.toString(10),
-  };
-};

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

@@ -1,7 +1,5 @@
 export * from './types';
 export * from './account';
 export * from './bridgeAndDepositExistingMA';
-export * from './oftBridgeAndDepositExistingMA';
-export * from './oftWithdrawMAAndBridge';
 export * from './transferMarginBetweenAccounts';
 export * from './withdrawMAAndBridge';

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

@@ -8,6 +8,9 @@ import {
 } from './types';
 import { getReyaNetwork } from '../../utils/network';
 
+/**
+ * @deprecated Use {@link transferMarginBetweenAccountsV2} instead.
+ */
 export const transferMarginBetweenAccounts = async (
   params: TransferMarginBetweenAccountsParams,
 ): Promise<TransferMarginBetweenAccountsResult> => {

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

@@ -60,19 +60,3 @@ export type BridgeAndDepositExistingMAParams = {
 export type BridgeAndDepositExistingMAResult = {
   transactionHash: string | null;
 };
-
-export type OFTWithdrawMAAndBridgeParams = WithdrawMAAndBridgeParams;
-
-export type OFTWithdrawMAAndBridgeResult = WithdrawMAAndBridgeParamsResult;
-
-export type OFTBridgeAndDepositExistingMAParams = {
-  signer: Signer | JsonRpcSigner;
-  marginAccountId: number;
-  tokenAddress: TokenEntity['address'];
-  amount: number;
-  moneyInOutChainId?: MoneyInOutChainId;
-};
-
-export type OFTBridgeAndDepositExistingMAResult = {
-  transactionHash: string | null;
-};

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

@@ -19,6 +19,9 @@ import { ethers } from 'ethers';
 import { getTransactionModuleClient } from '../../config';
 import { getReyaNetwork } from '../../utils/network';
 
+/**
+ * @deprecated Use {@link withdrawMAAndSocketBridgeV2} instead.
+ */
 export const withdrawMAAndBridge = async ({
   signer,
   moneyInOutChainId,

package/src/services/margin-accounts-v2/createAccount.ts

@@ -0,0 +1,35 @@
+import { Interface } from 'ethers';
+import { getReyaNetwork } from '../../utils/network';
+import { signAndBroadcastTransaction } from '../signAndBroadcastTransaction';
+import { CreateAccountParamsV2, CreateAccountResultV2 } from './types';
+import { ContractType, CoreAbi } from '@reyaxyz/common';
+
+const getCalldata = (accountOwner: string): string => {
+  const functionSignature = 'createAccount';
+  const parameters = [accountOwner];
+  const INTERFACE = new Interface(CoreAbi);
+  const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
+  return calldata;
+};
+
+export const createAccountV2 = async (
+  params: CreateAccountParamsV2,
+): Promise<CreateAccountResultV2> => {
+  const calldata = getCalldata(params.ownerAddress);
+  const chainId = getReyaNetwork();
+
+  const result = await signAndBroadcastTransaction(
+    calldata,
+    chainId,
+    ContractType.CORE_PROXY,
+    {
+      accountName: params.name,
+      action: 'createAccount',
+      sender: params.ownerAddress,
+    },
+  );
+  return {
+    transactionHash: result?.txHash || null,
+    accountId: Number(result?.accountId),
+  };
+};

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

@@ -0,0 +1,4 @@
+export { socketBridgeAndDepositMAV2 } from './socket/socketBridgeAndDepositMA';
+export { estimateFeeSocketBridgeAndDepositMAV2 } from './socket/estimateFeeSocketBridgeAndDepositMA';
+export { lzBridgeAndDepositMAV2 } from './lz/lzBridgeAndDepositMA';
+export { esimateFeeLzBridgeAndDepositMAV2 } from './lz/estimateFeeLzBridgeAndDepositMA';

package/src/services/margin-accounts-v2/deposit/lz/estimateFeeLzBridgeAndDepositMA.ts

@@ -0,0 +1,30 @@
+import {
+  buildOFTSendParamsToDepositInMA,
+  OFTAbi,
+  OFTMessagingFee,
+} from '@reyaxyz/common';
+import { Contract } from 'ethers';
+import { EstimateFeeLzBridgeAndDepositMAParamsV2 } from '../../types';
+import { getPeripheryAddress } from '../../../../utils/network';
+import { checkChainId } from '../../../../utils/checkChainId';
+
+export const esimateFeeLzBridgeAndDepositMAV2 = async (
+  params: EstimateFeeLzBridgeAndDepositMAParamsV2,
+): Promise<OFTMessagingFee> => {
+  await checkChainId(params.signer, params.chainId);
+  const sendParams = buildOFTSendParamsToDepositInMA({
+    amount: BigInt(0),
+    collateralAddressInReyaPeriphery: params.collateralAddressInReyaPeriphery,
+    dstEid: params.dstEid,
+    extraOptions: params.extraOptions,
+    receiverAddress: getPeripheryAddress(),
+    marginAccountId: 0,
+  });
+
+  const oft = new Contract(params.collateralAddress, OFTAbi, params.signer);
+  const [nativeFee, lzTokenFee] = await oft.quoteSend(sendParams, false);
+  return {
+    nativeFee: nativeFee.toString(),
+    lzTokenFee: lzTokenFee.toString(),
+  };
+};

package/src/services/margin-accounts-v2/deposit/lz/lzBridgeAndDepositMA.ts

@@ -0,0 +1,57 @@
+import {
+  buildOFTSendParamsToDepositInMA,
+  executeTransaction,
+  OFTAbi,
+  scaleV2,
+} from '@reyaxyz/common';
+import { Interface } from 'ethers';
+import {
+  LzBridgeAndDepositMAParamsV2,
+  LzBridgeAndDepositMAResultV2,
+} from '../../types';
+import { getPeripheryAddress } from '../../../../utils/network';
+import { checkChainId } from '../../../../utils/checkChainId';
+
+const getCalldata = async (
+  params: LzBridgeAndDepositMAParamsV2,
+): Promise<string> => {
+  const amount = scaleV2(params.collateralDecimals)(params.amount);
+  const refundAddress = await params.signer.getAddress();
+
+  const sendParams = buildOFTSendParamsToDepositInMA({
+    amount,
+    collateralAddressInReyaPeriphery: params.collateralAddressInReyaPeriphery,
+    dstEid: params.dstEid,
+    extraOptions: params.extraOptions,
+    receiverAddress: getPeripheryAddress(),
+    marginAccountId: params.marginAccountId,
+  });
+
+  const INTERFACE = new Interface(OFTAbi);
+  const calldata = INTERFACE.encodeFunctionData('send', [
+    sendParams,
+    params.bridgeFee,
+    refundAddress,
+  ]);
+
+  return calldata;
+};
+
+export const lzBridgeAndDepositMAV2 = async (
+  params: LzBridgeAndDepositMAParamsV2,
+): Promise<LzBridgeAndDepositMAResultV2> => {
+  await checkChainId(params.signer, params.chainId);
+  const calldata = await getCalldata(params);
+
+  const result = await executeTransaction(
+    params.signer,
+    calldata,
+    params.bridgeFee.nativeFee,
+    params.chainId,
+    params.collateralAddress,
+  );
+
+  return {
+    transactionHash: result?.hash || null,
+  };
+};

package/src/services/margin-accounts-v2/deposit/socket/estimateFeeSocketBridgeAndDepositMA.ts

@@ -0,0 +1,24 @@
+import { SOCKET_EMPTY_PAYLOAD_SIZE } from '@reyaxyz/common';
+import { Contract } from 'ethers';
+import { EstimateFeeSocketBridgeAndDepositMAParamsV2 } from '../../types';
+import { checkChainId } from '../../../../utils/checkChainId';
+
+const abi = [
+  'function getMinFees(address, uint256, uint256) external view returns (uint256)',
+];
+
+export const estimateFeeSocketBridgeAndDepositMAV2 = async (
+  params: EstimateFeeSocketBridgeAndDepositMAParamsV2,
+): Promise<string> => {
+  await checkChainId(params.signer, params.chainId);
+
+  const vaultContract = new Contract(params.vaultAddress, abi, params.signer);
+
+  const fees = await vaultContract.getMinFees(
+    params.connectorAddress,
+    params.msgGasLimit,
+    SOCKET_EMPTY_PAYLOAD_SIZE,
+  );
+
+  return fees.toString();
+};

package/src/services/margin-accounts-v2/deposit/socket/socketBridgeAndDepositMA.ts

@@ -0,0 +1,59 @@
+import { Interface } from 'ethers';
+import {
+  PeripheryAbi,
+  Socket_VaultWithPayloadAbi as VaultAbi,
+  executeTransaction,
+  scaleV2,
+} from '@reyaxyz/common';
+import {
+  SocketBridgeAndDepositMAParamsV2,
+  SocketBridgeAndDepositMAResultV2,
+} from '../../types';
+import { getPeripheryAddress } from '../../../../utils/network';
+import { checkChainId } from '../../../../utils/checkChainId';
+
+const getCalldata = (params: SocketBridgeAndDepositMAParamsV2): string => {
+  const amount = scaleV2(params.collateralDecimals)(params.amount);
+
+  const PERIPHERY_INTERFACE = new Interface(PeripheryAbi);
+  const inputs = {
+    accountId: params.accountId,
+    token: params.collateralAddressInReyaPeriphery,
+  };
+  const peripheryCalldata = PERIPHERY_INTERFACE.encodeFunctionData(
+    'depositExistingMA((uint128,address))',
+    [inputs],
+  );
+
+  const VAULT_INTERFACE = new Interface(VaultAbi);
+  const parameters = [
+    getPeripheryAddress(),
+    amount,
+    params.msgGasLimit,
+    params.connectorAddress,
+    peripheryCalldata,
+    '0x',
+  ];
+  const calldata = VAULT_INTERFACE.encodeFunctionData('bridge', parameters);
+
+  return calldata;
+};
+
+export const socketBridgeAndDepositMAV2 = async (
+  params: SocketBridgeAndDepositMAParamsV2,
+): Promise<SocketBridgeAndDepositMAResultV2> => {
+  await checkChainId(params.signer, params.chainId);
+  const calldata = getCalldata(params);
+
+  const result = await executeTransaction(
+    params.signer,
+    calldata,
+    params.bridgeFee,
+    params.chainId,
+    params.vaultAddress,
+  );
+
+  return {
+    transactionHash: result?.hash || null,
+  };
+};

package/src/services/margin-accounts-v2/erc20/approve.erc20.ts

@@ -0,0 +1,38 @@
+import { Interface } from 'ethers';
+import { executeTransaction, scaleV2 } from '@reyaxyz/common';
+import { checkChainId } from '../../../utils/checkChainId';
+import { Erc20ApproveParamsV2, Erc20ApproveResultV2 } from '../types';
+
+const ERC20_INTERFACE = new Interface([
+  'function approve(address spender, uint256 amount) external returns (bool)',
+]);
+
+const getCalldata = (params: Erc20ApproveParamsV2): string => {
+  const amount = scaleV2(params.collateralDecimals)(params.amount);
+
+  const calldata = ERC20_INTERFACE.encodeFunctionData('approve', [
+    params.spenderAddress,
+    amount,
+  ]);
+
+  return calldata;
+};
+
+export const erc20ApproveV2 = async (
+  params: Erc20ApproveParamsV2,
+): Promise<Erc20ApproveResultV2> => {
+  await checkChainId(params.signer, params.chainId);
+  const calldata = getCalldata(params);
+
+  const result = await executeTransaction(
+    params.signer,
+    calldata,
+    '0',
+    params.chainId,
+    params.collateralAddress,
+  );
+
+  return {
+    transactionHash: result?.hash || null,
+  };
+};

package/src/services/margin-accounts-v2/erc20/getAllowance.erc20.ts

@@ -0,0 +1,22 @@
+import { descale } from '@reyaxyz/common';
+import { Contract } from 'ethers';
+import { Erc20GetAllowanceParamsV2, Erc20GetAllowanceResultV2 } from '../types';
+import { checkChainId } from '../../../utils/checkChainId';
+
+const abi = [
+  'function allowance(address, address) external view returns (uint256)',
+];
+
+export const erc20GetAllowanceV2 = async (
+  params: Erc20GetAllowanceParamsV2,
+): Promise<Erc20GetAllowanceResultV2> => {
+  await checkChainId(params.signer, params.chainId);
+  const erc20 = new Contract(params.collateralAddress, abi, params.signer);
+  const currentAllowance = await erc20.allowance(
+    params.walletAddress,
+    params.spenderAddress,
+  );
+  return {
+    allowance: descale(params.collateralDecimals)(currentAllowance),
+  };
+};

package/src/services/margin-accounts-v2/erc20/getBalance.erc20.ts

@@ -0,0 +1,17 @@
+import { descale } from '@reyaxyz/common';
+import { Contract } from 'ethers';
+import { Erc20GetBalanceParamsV2, Erc20GetBalanceResultV2 } from '../types';
+import { checkChainId } from '../../../utils/checkChainId';
+
+const abi = ['function balanceOf(address) external view returns (uint256)'];
+
+export const erc20GetBalanceV2 = async (
+  params: Erc20GetBalanceParamsV2,
+): Promise<Erc20GetBalanceResultV2> => {
+  await checkChainId(params.signer, params.chainId);
+  const erc20 = new Contract(params.collateralAddress, abi, params.signer);
+  const currentBalance = await erc20.balanceOf(params.walletAddress);
+  return {
+    balance: descale(params.collateralDecimals)(currentBalance),
+  };
+};

package/src/services/margin-accounts-v2/erc20/index.ts

@@ -0,0 +1,3 @@
+export { erc20ApproveV2 } from './approve.erc20';
+export { erc20GetAllowanceV2 } from './getAllowance.erc20';
+export { erc20GetBalanceV2 } from './getBalance.erc20';

package/src/services/margin-accounts-v2/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './createAccount';
+export * from './deposit';
+export * from './transferMarginBetweenAccounts';
+export * from './withdraw';
+export * from './erc20';

package/src/services/margin-accounts-v2/transferMarginBetweenAccounts.ts

@@ -0,0 +1,75 @@
+import {
+  scaleV2,
+  getCommand,
+  CommandType,
+  signCoreCommands,
+  CORE_DEADLINE_IN_SECONDS,
+  getCurrentTimestampInSeconds,
+  PeripheryAbi,
+  ContractType,
+} from '@reyaxyz/common';
+import { signAndBroadcastTransaction } from '../signAndBroadcastTransaction';
+import { TransferMAParamsV2, TransferMAResultV2 } from './types';
+import { getPeripheryAddress, getReyaNetwork } from '../../utils/network';
+import { ethers, Interface } from 'ethers';
+
+const getCalldata = async (params: TransferMAParamsV2): Promise<string> => {
+  const amount = scaleV2(params.collateralDecimals)(params.amount);
+  const chainId = getReyaNetwork();
+
+  const { command } = getCommand(
+    CommandType.TRANSFER_MARGIN_ACCOUNT,
+    [[params.toMarginAccountId, params.collateralAddress, amount]],
+    0,
+    0,
+  );
+
+  const peripheryAddress = getPeripheryAddress();
+
+  const { signature: eip712Signature } = await signCoreCommands(
+    params.signer,
+    chainId,
+    peripheryAddress,
+    params.fromMarginAccountId,
+    [command],
+    params.coreSigNonce + 1,
+    getCurrentTimestampInSeconds() + CORE_DEADLINE_IN_SECONDS,
+    ethers.AbiCoder.defaultAbiCoder().encode([], []),
+  );
+
+  const functionSignature = 'transferFromMAToMA';
+  const parameters = [
+    {
+      accountId: params.fromMarginAccountId,
+      transfer: {
+        destAccountId: params.toMarginAccountId,
+        collateral: params.collateralAddress,
+        collateralAmount: amount,
+      },
+      sig: eip712Signature,
+    },
+  ];
+
+  const INTERFACE = new Interface(PeripheryAbi);
+  const calldata = INTERFACE.encodeFunctionData(functionSignature, parameters);
+  return calldata;
+};
+
+export const transferMarginBetweenAccountsV2 = async (
+  params: TransferMAParamsV2,
+): Promise<TransferMAResultV2> => {
+  const chainId = getReyaNetwork();
+
+  const calldata = await getCalldata(params);
+  const result = await signAndBroadcastTransaction(
+    calldata,
+    chainId,
+    ContractType.PERIPHERY_PROXY,
+    {},
+  );
+
+  return {
+    transactionHash: result?.txHash || null,
+    coreSigNonce: Number(result?.coreSigNonce) || null,
+  };
+};