feat: osmosis swap messages

Author: mateuszjasiuk

apps/namadillo/src/workers/MaspTxMessages.ts

@@ -1,6 +1,7 @@
 import {
   Account,
   IbcTransferMsgValue,
+  OsmosisSwapMsgValue,
   ShieldedTransferMsgValue,
   ShieldingTransferMsgValue,
   TxResponseMsgValue,
@@ -76,6 +77,19 @@ export type IbcTransferDone = WebWorkerMessage<
   EncodedTxData<IbcTransferMsgValue>
 >;
 
+type OsmosisSwapPayload = {
+  account: Account;
+  gasConfig: GasConfig;
+  props: OsmosisSwapMsgValue[];
+  chain: ChainSettings;
+  memo?: string;
+};
+export type OsmosisSwap = WebWorkerMessage<"osmosis-swap", OsmosisSwapPayload>;
+export type OsmosisSwapDone = WebWorkerMessage<
+  "osmosis-swap-done",
+  EncodedTxData<OsmosisSwapMsgValue>
+>;
+
 type GenerateIbcShieldingMemoPayload = {
   target: string;
   token: string;

apps/namadillo/src/workers/MaspTxWorker.ts

@@ -2,6 +2,7 @@ import { initMulticore } from "@namada/sdk/inline-init";
 import { getSdk, Sdk } from "@namada/sdk/web";
 import {
   IbcTransferMsgValue,
+  OsmosisSwapMsgValue,
   ShieldedTransferMsgValue,
   ShieldingTransferMsgValue,
   TxResponseMsgValue,
@@ -18,6 +19,8 @@ import {
   IbcTransferDone,
   Init,
   InitDone,
+  OsmosisSwap,
+  OsmosisSwapDone,
   Shield,
   ShieldDone,
   ShieldedTransfer,
@@ -89,6 +92,17 @@ export class Worker {
     };
   }
 
+  async osmosisSwap(m: OsmosisSwap): Promise<OsmosisSwapDone> {
+    if (!this.sdk) {
+      throw new Error("SDK is not initialized");
+    }
+
+    return {
+      type: "osmosis-swap-done",
+      payload: await osmosisSwap(this.sdk, m.payload),
+    };
+  }
+
   async broadcast(m: Broadcast): Promise<BroadcastDone> {
     if (!this.sdk) {
       throw new Error("SDK is not initialized");
@@ -189,6 +203,27 @@ async function ibcTransfer(
   return encodedTxData;
 }
 
+async function osmosisSwap(
+  sdk: Sdk,
+  payload: OsmosisSwap["payload"]
+): Promise<EncodedTxData<OsmosisSwapMsgValue>> {
+  const { account, gasConfig, chain, props } = payload;
+
+  await sdk.masp.loadMaspParams("", chain.chainId);
+  const encodedTxData = await buildTx<OsmosisSwapMsgValue>(
+    sdk,
+    account,
+    gasConfig,
+    chain,
+    props,
+    sdk.tx.buildOsmosisSwap,
+    undefined,
+    false
+  );
+
+  return encodedTxData;
+}
+
 async function generateIbcShieldingMemo(
   sdk: Sdk,
   payload: GenerateIbcShieldingMemo["payload"]
@@ -240,6 +275,8 @@ export const registerTransferHandlers = (): void => {
   registerBNTransferHandler<UnshieldDone>("unshield-done");
   registerBNTransferHandler<IbcTransfer>("ibc-transfer");
   registerBNTransferHandler<IbcTransferDone>("ibc-transfer-done");
+  registerBNTransferHandler<OsmosisSwap>("osmosis-swap");
+  registerBNTransferHandler<OsmosisSwapDone>("osmosis-swap-done");
   registerBNTransferHandler<Unshield>("unshield");
   registerBNTransferHandler<GenerateIbcShieldingMemo>(
     "generate-ibc-shielding-memo"

packages/sdk/src/tx/tx.ts

@@ -15,6 +15,8 @@ import {
   IbcTransferMsgValue,
   IbcTransferProps,
   Message,
+  OsmosisSwapMsgValue,
+  OsmosisSwapProps,
   RedelegateMsgValue,
   RedelegateProps,
   RevealPkMsgValue,
@@ -280,6 +282,31 @@ export class Tx {
     return deserialize(Buffer.from(serializedTx), TxMsgValue);
   }
 
+  /**
+   * Build Osmosis Swap Tx
+   * `osmosisSwapProps.transfer.amountInBaseDenom` is the amount in the **base** denom
+   * e.g. the value of 1 NAM should be BigNumber(1_000_000), not BigNumber(1).
+   * @async
+   * @param wrapperTxProps - properties of the transaction
+   * @param osmosisSwapProps - properties of the osmosis swap tx
+   * @returns promise that resolves to an TxMsgValue
+   */
+  async buildOsmosisSwap(
+    wrapperTxProps: WrapperTxProps,
+    osmosisSwapProps: OsmosisSwapProps
+  ): Promise<TxMsgValue> {
+    const ibcTransferMsg = new Message<OsmosisSwapProps>();
+    const encodedWrapperArgs = this.encodeTxArgs(wrapperTxProps);
+    const encodedIbcTransfer = ibcTransferMsg.encode(
+      new OsmosisSwapMsgValue(osmosisSwapProps)
+    );
+    const serializedTx = await this.sdk.build_osmosis_swap(
+      encodedIbcTransfer,
+      encodedWrapperArgs
+    );
+    return deserialize(Buffer.from(serializedTx), TxMsgValue);
+  }
+
   /**
    * Build Ethereum Bridge Transfer Tx
    * @async

packages/shared/lib/src/sdk/args.rs

@@ -19,6 +19,7 @@ use namada_sdk::masp_primitives::zip32;
 use namada_sdk::signing::SigningTxData;
 use namada_sdk::time::DateTimeUtc;
 use namada_sdk::tx::data::GasLimit;
+use namada_sdk::tx::either::Either;
 use namada_sdk::tx::{Section, Tx};
 use namada_sdk::{
     address::Address,
@@ -308,6 +309,104 @@ pub fn redelegate_tx_args(
     Ok(args)
 }
 
+#[derive(BorshSerialize, BorshDeserialize, Debug)]
+#[borsh(crate = "namada_sdk::borsh")]
+pub enum Slippage {
+    /// Specifies the minimum amount to be received
+    MinOutputAmount(String),
+    /// A time-weighted average price
+    Twap {
+        /// The maximum percentage difference allowed between the estimated and
+        /// actual trade price. This must be a decimal number in the range
+        /// `[0, 100]`.
+        slippage_percentage: String,
+        /// The time period (in seconds) over which the average price is
+        /// calculated
+        window_seconds: u64,
+    },
+}
+
+impl From<Slippage> for args::Slippage {
+    fn from(slippage: Slippage) -> Self {
+        match slippage {
+            Slippage::MinOutputAmount(min_output_amount) => {
+                let min_output_amount =
+                    Amount::from_str(&min_output_amount, 0u8).expect("Amount to be valid.");
+                args::Slippage::MinOutputAmount(min_output_amount)
+            }
+            Slippage::Twap {
+                slippage_percentage,
+                window_seconds,
+            } => args::Slippage::Twap {
+                slippage_percentage,
+                window_seconds,
+            },
+        }
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Debug)]
+#[borsh(crate = "namada_sdk::borsh")]
+pub struct OsmosisSwapMsg {
+    pub transfer: Vec<u8>,
+    /// The token we wish to receive (on Namada)
+    pub output_denom: String,
+    /// Address of the recipient on Namada
+    pub recipient: String,
+    /// Address to receive funds exceeding the minimum amount,
+    /// in case of IBC shieldings
+    pub overflow: String,
+    ///  Constraints on the  osmosis swap
+    pub slippage: Slippage,
+    /// Recovery address (on Osmosis) in case of failure
+    pub local_recovery_addr: String,
+    /// The route to take through Osmosis pools
+    /// A REST rpc endpoint to Osmosis
+    pub osmosis_rest_rpc: String,
+}
+
+pub fn osmosis_swap_tx_args(
+    osmosis_swap_msg: &[u8],
+    tx_msg: &[u8],
+) -> Result<(args::TxOsmosisSwap, Option<StoredBuildParams>), JsError> {
+    let osmosis_swap_msg = OsmosisSwapMsg::try_from_slice(osmosis_swap_msg)?;
+
+    let OsmosisSwapMsg {
+        transfer,
+        output_denom,
+        recipient,
+        overflow,
+        slippage,
+        local_recovery_addr,
+        osmosis_rest_rpc,
+    } = osmosis_swap_msg;
+
+    let (ibc_transfer_args, bparams) = ibc_transfer_tx_args(&transfer, tx_msg)?;
+
+    let recipient = match Address::from_str(&recipient) {
+        Ok(address) => Ok(Either::Left(address)),
+        Err(_) => match PaymentAddress::from_str(&recipient) {
+            Ok(pa) => Ok(Either::Right(pa)),
+            Err(_) => Err(JsError::new("Invalid recipient address")),
+        },
+    }?;
+
+    let overflow = Address::from_str(&overflow)?;
+
+    let tx_osmosis_swap_args = args::TxOsmosisSwap {
+        transfer: ibc_transfer_args,
+        output_denom,
+        recipient,
+        overflow: Some(overflow),
+        slippage: slippage.into(),
+        local_recovery_addr,
+        route: None,
+        osmosis_rest_rpc,
+    };
+
+    Ok((tx_osmosis_swap_args, bparams))
+}
+
 #[derive(BorshSerialize, BorshDeserialize, Debug)]
 #[borsh(crate = "namada_sdk::borsh")]
 pub struct VoteProposalMsg {

packages/shared/lib/src/sdk/mod.rs

@@ -734,6 +734,49 @@ impl Sdk {
         self.serialize_tx_result(tx, wrapper_tx_msg, signing_data, None)
     }
 
+    pub async fn build_osmosis_swap(
+        &self,
+        osmosis_swap_msg: &[u8],
+        wrapper_tx_msg: &[u8],
+    ) -> Result<JsValue, JsError> {
+        let (args, bparams) = args::osmosis_swap_tx_args(osmosis_swap_msg, wrapper_tx_msg)?;
+        let tx = args.into_ibc_transfer(&self.namada).await?;
+        let bparams = if let Some(bparams) = bparams {
+            BuildParams::StoredBuildParams(bparams)
+        } else {
+            generate_rng_build_params()
+        };
+
+        let _ = &self.namada.shielded_mut().await.load().await?;
+
+        let xfvks = match tx.source {
+            TransferSource::Address(_) => vec![],
+            TransferSource::ExtendedKey(pek) => vec![pek.to_viewing_key()],
+        };
+
+        let ((tx, signing_data, _), masp_signing_data) = match bparams {
+            BuildParams::RngBuildParams(mut bparams) => {
+                let tx = build_ibc_transfer(&self.namada, &tx, &mut bparams).await?;
+                let masp_signing_data = MaspSigningData::new(
+                    bparams
+                        .to_stored()
+                        .ok_or_err_msg("Cannot convert bparams to stored")?,
+                    xfvks,
+                );
+
+                (tx, masp_signing_data)
+            }
+            BuildParams::StoredBuildParams(mut bparams) => {
+                let tx = build_ibc_transfer(&self.namada, &tx, &mut bparams).await?;
+                let masp_signing_data = MaspSigningData::new(bparams, xfvks);
+
+                (tx, masp_signing_data)
+            }
+        };
+
+        self.serialize_tx_result(tx, wrapper_tx_msg, signing_data, Some(masp_signing_data))
+    }
+
     pub async fn build_reveal_pk(&self, wrapper_tx_msg: &[u8]) -> Result<JsValue, JsError> {
         let args = args::tx_args_from_slice(wrapper_tx_msg)?;
         let public_key = args.signing_keys[0].clone();

packages/types/src/tx/schema/index.ts

@@ -4,6 +4,7 @@ export * from "./bparams";
 export * from "./claimRewards";
 export * from "./ethBridgeTransfer";
 export * from "./ibcTransfer";
+export * from "./osmosisSwap";
 export * from "./redelegate";
 export * from "./revealPk";
 export * from "./signature";
@@ -22,6 +23,7 @@ import { BondMsgValue } from "./bond";
 import { ClaimRewardsMsgValue } from "./claimRewards";
 import { EthBridgeTransferMsgValue } from "./ethBridgeTransfer";
 import { IbcTransferMsgValue } from "./ibcTransfer";
+import { OsmosisSwapMsgValue } from "./osmosisSwap";
 import { RedelegateMsgValue } from "./redelegate";
 import { RevealPkMsgValue } from "./revealPk";
 import { SignatureMsgValue } from "./signature";
@@ -50,6 +52,7 @@ export type Schema =
   | BatchTxResultMsgValue
   | EthBridgeTransferMsgValue
   | IbcTransferMsgValue
+  | OsmosisSwapMsgValue
   | SignatureMsgValue
   | BondMsgValue
   | UnbondMsgValue

packages/types/src/tx/schema/osmosisSwap.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { field, variant } from "@dao-xyz/borsh";
+import { OsmosisSwapProps } from "../types";
+import { IbcTransferMsgValue } from "./ibcTransfer";
+
+abstract class SlippageMsgValue {}
+
+@variant(0)
+class MinOutputAmount extends SlippageMsgValue {
+  // 0 to follow rust convention, the amount is in the **base** denom
+  @field({ type: "string" })
+  public 0!: string;
+
+  constructor(data: MinOutputAmount) {
+    super();
+    Object.assign(this, data);
+  }
+}
+
+@variant(1)
+class Twap extends SlippageMsgValue {
+  @field({ type: "string" })
+  public slippagePercentage!: string;
+
+  @field({ type: "u64" })
+  public windowSeconds!: bigint;
+
+  constructor(data: SlippageMsgValue) {
+    super();
+    Object.assign(this, data);
+  }
+}
+
+export class OsmosisSwapMsgValue {
+  @field({ type: IbcTransferMsgValue })
+  transfer!: IbcTransferMsgValue;
+
+  @field({ type: "string" })
+  outputDenom!: string;
+
+  @field({ type: "string" })
+  overflow!: string;
+
+  @field({ type: SlippageMsgValue })
+  slippage!: SlippageMsgValue;
+
+  @field({ type: "string" })
+  localRecoveryAddr!: string;
+
+  @field({ type: "string" })
+  osmosisRestRpc!: string;
+
+  constructor(data: OsmosisSwapProps) {
+    const slippage =
+      data instanceof MinOutputAmount ?
+        new MinOutputAmount(data)
+      : new Twap(data);
+
+    Object.assign(this, {
+      ...data,
+      transfer: new IbcTransferMsgValue(data.transfer),
+      slippage,
+    });
+  }
+}