@reyaxyz/sdk 0.145.2 → 0.146.0

package/src/services/lp/unstakeStakedReya.ts

@@ -0,0 +1,66 @@
+import { UnstakeStakedReyaParams, UnstakeStakedReyaResult } from './types';
+import { getReyaNetwork } from '../../utils/network';
+import {
+  scale,
+  getTokenInfoByName,
+  ContractType,
+  getAddress,
+  signCoreCommands,
+  getCurrentTimestampInSeconds,
+  CORE_DEADLINE_IN_SECONDS,
+  MultiAction,
+} from '@reyaxyz/common';
+import { encodeSingleWithdraw } from '../encode';
+import { encodeUnstakeStakedReya } from './encode';
+import { signAndBroadcastTransaction } from '../signAndBroadcastTransaction';
+import { ethers } from 'ethers';
+
+export const unstakeStakedReya = async (
+  params: UnstakeStakedReyaParams,
+): Promise<UnstakeStakedReyaResult> => {
+  const chainId = getReyaNetwork();
+
+  const sreyaTokenInfo = getTokenInfoByName('SREYA', chainId);
+  const reyaTokenInfo = getTokenInfoByName('REYA', chainId);
+  const shareAmount = scale(sreyaTokenInfo.decimals)(params.shareAmount);
+  const minAssetAmount = params.minAssetAmount
+    ? scale(reyaTokenInfo.decimals)(params.minAssetAmount)
+    : BigInt(0);
+
+  const multiAction = new MultiAction();
+  encodeSingleWithdraw(sreyaTokenInfo.address, shareAmount, multiAction);
+
+  const { signature: withdrawSig } = await signCoreCommands(
+    params.signer,
+    chainId,
+    getAddress(chainId, ContractType.PERIPHERY_PROXY),
+    params.marginAccountId,
+    multiAction.commands,
+    params.owner.coreSigNonce + 1,
+    getCurrentTimestampInSeconds() + CORE_DEADLINE_IN_SECONDS,
+    ethers.AbiCoder.defaultAbiCoder().encode(
+      ['string', 'uint256'],
+      ['unstakeStakedReya', minAssetAmount],
+    ),
+  );
+
+  const { calldata: data } = encodeUnstakeStakedReya(
+    params.marginAccountId,
+    shareAmount,
+    minAssetAmount,
+    withdrawSig,
+  );
+
+  const result = await signAndBroadcastTransaction(
+    data,
+    chainId,
+    ContractType.PERIPHERY_PROXY,
+    {},
+  );
+
+  return {
+    transactionHash: result?.txHash || null,
+    coreSigNonce:
+      result?.coreSigNonce != null ? Number(result.coreSigNonce) : null,
+  };
+};

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

@@ -14,8 +14,6 @@ import {
   BridgeAndDepositExistingMAParams,
   BridgeAndDepositExistingMAResult,
 } from './types';
-import { encodeSingleDeposit } from '../encode';
-import { MultiAction } from '@reyaxyz/common';
 import { getTransactionModuleClient } from '../../config';
 
 export const bridgeAndDepositExistingMA = async (
@@ -38,13 +36,6 @@ export const bridgeAndDepositExistingMA = async (
     ? getTokenInfoByName('RUSD', reyaChainId)
     : reyaPeripheryTokenInfo;
 
-  const multiAction = new MultiAction();
-  encodeSingleDeposit(
-    reyaCoreTokenInfo.address,
-    scale(reyaPeripheryTokenInfo.decimals)(params.amount),
-    multiAction,
-  );
-
   const peripheryAddress = getAddress(
     reyaChainId,
     ContractType.PERIPHERY_PROXY,
@@ -63,7 +54,6 @@ export const bridgeAndDepositExistingMA = async (
     params.socketDepositFees,
     params.marginAccountId,
     reyaPeripheryTokenInfo.address,
-    scale(reyaPeripheryTokenInfo.decimals)(params.amount),
     scale(moneyInOutTokenInfo.decimals)(params.amount),
   );
 

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

@@ -1,8 +1,14 @@
-import { MethodParameters, MultiAction } from '@reyaxyz/common';
+import {
+  MethodParameters,
+  MultiAction,
+  OFTSendParam,
+  OFTMessagingFee,
+} 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,
@@ -15,6 +21,12 @@ 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 => {
@@ -105,7 +117,6 @@ export const encodeBridgeAndDepositExistingMA = (
   socketFees: bigint,
   accountId: number,
   peripheryTokenAddress: string,
-  peripheryTokenAmount: bigint,
   moneyInOutTokenAmount: bigint,
 ): MethodParameters => {
   const PERIPHERY_INTERFACE = new Interface(PeripheryAbi);
@@ -131,3 +142,141 @@ 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,5 +1,7 @@
 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/oftBridgeAndDepositExistingMA.ts

@@ -0,0 +1,112 @@
+import {
+  scale,
+  MoneyInOutChainId,
+  getTokenInfoByAddress,
+  getTokenInfoByName,
+  getReyaNetworkFromMoneyInOutChainId,
+  ContractType,
+  getAddress,
+  executeTransaction,
+  getLzEndpointId,
+  OFTMessagingFee,
+  OFTAbi as OFTAbi,
+} from '@reyaxyz/common';
+import { ethers } from 'ethers';
+import {
+  encodeOFTBridgeAndDepositExistingMA,
+  buildOFTBridgeAndDepositExistingMASendParam,
+} from './encode';
+import {
+  OFTBridgeAndDepositExistingMAParams,
+  OFTBridgeAndDepositExistingMAResult,
+} from './types';
+
+export const oftBridgeAndDepositExistingMA = async (
+  params: OFTBridgeAndDepositExistingMAParams,
+): Promise<OFTBridgeAndDepositExistingMAResult> => {
+  const moneyInOutChainId: MoneyInOutChainId =
+    params.moneyInOutChainId ??
+    Number((await params.signer.provider?.getNetwork())?.chainId);
+  const reyaChainId = getReyaNetworkFromMoneyInOutChainId(moneyInOutChainId);
+
+  const moneyInOutTokenInfo = getTokenInfoByAddress(
+    params.tokenAddress,
+    moneyInOutChainId,
+  );
+
+  if (!moneyInOutTokenInfo.isOFT) {
+    throw new Error(
+      `Token ${moneyInOutTokenInfo.name} at ${params.tokenAddress} is not an OFT token on chain ${moneyInOutChainId}`,
+    );
+  }
+
+  const reyaPeripheryTokenInfo = getTokenInfoByName(
+    moneyInOutTokenInfo.name,
+    reyaChainId,
+  );
+
+  const peripheryAddress = getAddress(
+    reyaChainId,
+    ContractType.PERIPHERY_PROXY,
+  );
+
+  const dstEid = getLzEndpointId(reyaChainId);
+  const amountLD = scale(moneyInOutTokenInfo.decimals)(params.amount);
+  const minAmountLD = amountLD;
+
+  const { sendParam } = buildOFTBridgeAndDepositExistingMASendParam(
+    dstEid,
+    peripheryAddress,
+    params.marginAccountId,
+    reyaPeripheryTokenInfo.address,
+    amountLD,
+    minAmountLD,
+  );
+
+  const provider = params.signer.provider;
+  if (!provider) {
+    throw new Error('Signer must have a provider to quote OFT messaging fees');
+  }
+
+  const oftContract = new ethers.Contract(
+    moneyInOutTokenInfo.address,
+    OFTAbi,
+    provider,
+  );
+
+  const msgFee = await oftContract.quoteSend.staticCall(sendParam, false);
+  const messagingFee: OFTMessagingFee = {
+    nativeFee: msgFee.nativeFee,
+    lzTokenFee: msgFee.lzTokenFee,
+  };
+
+  const callerAddress = await params.signer.getAddress();
+  const { calldata: data, value } = encodeOFTBridgeAndDepositExistingMA(
+    dstEid,
+    peripheryAddress,
+    params.marginAccountId,
+    reyaPeripheryTokenInfo.address,
+    amountLD,
+    minAmountLD,
+    messagingFee,
+    callerAddress,
+  );
+
+  const result = await executeTransaction(
+    params.signer,
+    data,
+    value,
+    moneyInOutChainId,
+    moneyInOutTokenInfo.address,
+  );
+
+  if (!result?.hash) {
+    return {
+      transactionHash: null,
+    };
+  }
+
+  return {
+    transactionHash: result?.hash,
+  };
+};

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

@@ -0,0 +1,93 @@
+import {
+  getCurrentTimestampInSeconds,
+  scale,
+  getTokenInfoByAddress,
+  getLzEndpointId,
+} from '@reyaxyz/common';
+import { ContractType, getAddress } from '@reyaxyz/common';
+import { signAndBroadcastTransaction } from '../signAndBroadcastTransaction';
+import { signCoreCommands } from '@reyaxyz/common';
+import { encodeWithdrawMALZ } from './encode';
+import {
+  OFTWithdrawMAAndBridgeParams,
+  OFTWithdrawMAAndBridgeResult,
+} from './types';
+import { BRIDGE_DEADLINE_IN_SECONDS } from '@reyaxyz/common';
+import { encodeSingleWithdraw } from '../encode';
+import { MultiAction } from '@reyaxyz/common';
+import { ethers } from 'ethers';
+import { getReyaNetwork } from '../../utils/network';
+
+export const oftWithdrawMAAndBridge = async ({
+  signer,
+  moneyInOutChainId,
+  marginAccountId,
+  owner,
+  amount: unscaledAmount,
+  tokenAddress,
+  receiverAddress = owner.address,
+}: OFTWithdrawMAAndBridgeParams): Promise<OFTWithdrawMAAndBridgeResult> => {
+  const reyaChainId = getReyaNetwork();
+
+  const corePeripheryTokenInfo = getTokenInfoByAddress(tokenAddress);
+
+  if (!corePeripheryTokenInfo.isOFT) {
+    throw new Error(
+      `Token ${corePeripheryTokenInfo.name} at ${tokenAddress} is not an OFT token`,
+    );
+  }
+
+  const multiAction = new MultiAction();
+  encodeSingleWithdraw(
+    corePeripheryTokenInfo.address,
+    scale(corePeripheryTokenInfo.decimals)(unscaledAmount),
+    multiAction,
+  );
+
+  const dstEid = getLzEndpointId(moneyInOutChainId);
+
+  const { signature: eip712Signature } = await signCoreCommands(
+    signer,
+    reyaChainId,
+    getAddress(reyaChainId, ContractType.PERIPHERY_PROXY),
+    marginAccountId,
+    multiAction.commands,
+    owner.coreSigNonce + 1,
+    getCurrentTimestampInSeconds() + BRIDGE_DEADLINE_IN_SECONDS,
+    ethers.AbiCoder.defaultAbiCoder().encode(
+      ['string', 'address', 'uint32'],
+      ['withdrawMALZ', receiverAddress, dstEid],
+    ),
+  );
+
+  const { calldata: data } = encodeWithdrawMALZ(
+    marginAccountId,
+    corePeripheryTokenInfo.address,
+    scale(corePeripheryTokenInfo.decimals)(unscaledAmount),
+    eip712Signature,
+    dstEid,
+    receiverAddress,
+  );
+
+  const result = await signAndBroadcastTransaction(
+    data,
+    reyaChainId,
+    ContractType.PERIPHERY_PROXY,
+    {
+      destinationType: 'account',
+    },
+  );
+
+  if (!result?.txHash) {
+    return {
+      transactionHash: null,
+      coreSigNonce: null,
+    };
+  }
+
+  return {
+    transactionHash: result?.txHash || null,
+    coreSigNonce:
+      result?.coreSigNonce != null ? Number(result.coreSigNonce) : null,
+  };
+};

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

@@ -60,3 +60,19 @@ 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;
+};