refactor(core, proto)!: define bridge memos in proto (#1285)

## Summary
Defines the bridge unlock, ics20 withdrawal, and ics20 deposit memos as
protobuf.

## Background
The various memos were read inside sequencer to inform the behaviour of
the protocol, but were not defined in the canonical
`astria.protocol.v1alpha1` protobufs. This patch defines the memo types
in a new `astria.protocol.v1alpha1.memos` so that there is a single
source of truth for all protocol-relevant objects. The memos are still
only ever serialiazed as plaintext `JSON` and not as protobuf.

## Changes
* Define the following types:
  * `astria.protocol.v1alpha1.memos.BridgeUnlock`
  * `astria.protocol.v1alpha1.memos.Ics20WithdrawalFromRollup`
  * `astria.protocol.v1alpha1.memos.Ics20TransferDeposit`
* Remove the `astria_core::bridge` module
* Update `astria_bridge_contracts`, `astria_bridge_withdrawer`, and
`astria_sequencer` to operate in terms of these types
* Update all memo fields containing bytes to be of type `string` so that
the rollup-native formatting can be used (to make it easier to identify
e.g. transactions and avoid the use of base64 for non-Astria byte
slices)
* Various field names have been updated to clarify that their source is
the rollup (e.g. `rollup_transaction_hash`, `rollup_return_address`).

## Testing
The changes in this code rely on smoke tests still working. Because the
IBC tests require the latest (rust) astria-cli, the IBC tests were
reworked.

## Breaking Changelist
* This is a protocl breaking change: the shape of the memo JSON objects
has changed (object keys were renamed, the encoding of byte fields no
longer requires base64).

## Related Issues
Closes #1286

---------

Co-authored-by: Jordan Oroshiba <[email protected]>

Author: SuperFluffy

.github/workflows/docker-build.yml

@@ -191,6 +191,10 @@ jobs:
         uses: helm/kind-action@v1
         with:
           install_only: true
+      - name: Install astria cli (rust)
+        run: just install-cli
+      - name: Fetch and install celestia-appd
+        run: just get-celestia-appd v1.9.0 Linux x86_64
       - name: Log in to GHCR
         uses: docker/login-action@v2
         with:
@@ -204,27 +208,10 @@ jobs:
           just deploy cluster
           kubectl create secret generic regcred --from-file=.dockerconfigjson=$HOME/.docker/config.json --type=kubernetes.io/dockerconfigjson
           echo -e "\n\nDeploying with astria images tagged $TAG"
-          just deploy ibc-test-infra $TAG
-          just build-and-load-bridge-tester-image $TAG
-      - name: Run IBC Bridge Tester
-        timeout-minutes: 2
-        run: |
-          TAG=sha-$(git rev-parse --short HEAD)
-          printlogs() {
-            echo "IBC Transfer Test failed, printing logs..."
-            kubectl describe job bridge-tester-chart -n astria-dev-cluster
-            kubectl logs job/bridge-tester-chart --all-containers -n astria-dev-cluster
-            exit 1
-          }
-          just deploy bridge-tester $TAG
-          # timeout before the gh job times out so we can print logs
-          kubectl wait --for=condition=complete --timeout=90s job/bridge-tester-chart -n astria-dev-cluster || printlogs
-          JOB_STATUS=$(kubectl get job bridge-tester-chart -n astria-dev-cluster -o jsonpath='{.status.succeeded}')
-          if [ "$JOB_STATUS" != "1" ]; then
-            printlogs
-          else
-            echo "IBC Transfer Test passed"
-          fi
+          just ibc-test deploy $TAG
+      - name: Run IBC ICS20 Transfer test
+        timeout-minutes: 3
+        run: just ibc-test run ./celestia ./celestia-appd
 
   docker:
     if: ${{ always() && !cancelled() }}

Cargo.lock

@@ -1,3 +1,5 @@
+mod ibc-test
+
 ##############################################
 ## Deploying and Running using Helm and K8s ##
 ##############################################
@@ -225,6 +227,16 @@ init-rollup-bridge rollupName=defaultRollupName evmDestinationAddress=evm_destin
     --fee-asset=$FEE_ASSET --asset=$ASSET || exit 1
 
 
+init-ibc-bridge privateKey asset feeAsset rollupName=defaultRollupName:
+  astria-cli sequencer init-bridge-account \
+    --rollup-name {{ rollupName }} \
+    --private-key {{ privateKey }} \
+    --sequencer.chain-id {{ sequencer_chain_id }} \
+    --sequencer-url {{ sequencer_rpc_url }} \
+    --fee-asset {{ feeAsset }} \
+    --asset {{ asset }}
+
+
 eth_rpc_url := "http://executor.astria.localdev.me/"
 eth_ws_url := "ws://ws-executor.astria.localdev.me/"
 bridge_tx_bytes := "0xf8f280843c54e7f182898594a58639fb5458e65e4fa917ff951c390292c24a15880de0b6b3a7640000b884bab916d00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002d617374726961313777306164656736346b7930646178776432756779756e65656c6c6d6a676e786c333935303400000000000000000000000000000000000000820a96a086b85348c9816f6d34533669db3d3626cf55eecea6a380d4d072efb1839df443a04b8b60c8b91dd30add1ca4a96097238d73bab29b0a958322d9a51755d5a5f287"

charts/bridge-test/.helmignore

@@ -0,0 +1,111 @@
+defaultTag := ""
+
+delete:
+  -just delete celestia-local
+  -just delete sequencer
+  -just delete hermes-local
+  -just delete rollup
+
+@deploy tag=defaultTag:
+  echo "Deploying ingress controller..." && just deploy-ingress-controller > /dev/null
+  just wait-for-ingress-controller > /dev/null
+  echo "Deploying local celestia instance..." && just deploy celestia-local > /dev/null
+  helm dependency update ./sequencer > /dev/null
+  helm dependency update ./evm-stack > /dev/null
+  echo "Setting up single astria sequencer..." && helm install \
+    -n astria-validator-single single-sequencer-chart ./sequencer \
+    -f ../dev/values/validators/all.yml \
+    -f ../dev/values/validators/single.yml \
+    {{ if tag != '' { replace('--set images.sequencer.devTag=# --set sequencer-relayer.images.sequencerRelayer.devTag=#', '#', tag) } else { '' } }} \
+    --create-namespace > /dev/null
+  just wait-for-sequencer > /dev/null
+  echo "Starting EVM rollup..." && helm install -n astria-dev-cluster astria-chain-chart ./evm-stack \
+    -f ../dev/values/rollup/dev.yaml \
+    -f ../dev/values/rollup/ibc-bridge-test.yaml \
+    {{ if tag != '' { replace('--set evm-rollup.images.conductor.devTag=# --set composer.images.composer.devTag=# --set evm-bridge-withdrawer.images.evmBridgeWithdrawer.devTag=#', '#', tag) } else { '' } }} \
+    --set blockscout-stack.enabled=false \
+    --set postgresql.enabled=false \
+    --set evm-faucet.enabled=false > /dev/null
+  just wait-for-rollup > /dev/null
+  echo "Deploying Hermes"
+  just deploy hermes-local > /dev/null
+  kubectl wait -n astria-dev-cluster deployment hermes-local-chart --for=condition=Available=True --timeout=300s
+
+[no-cd]
+run celestiaHome pathToCelestiaAppd=default_celestia_appd :
+  #!/usr/bin/env bash
+
+  initial_balance=$(just evm-get-balance {{evm_destination_address}})
+
+  # Create a bridge account on the sequencer
+  just init-ibc-bridge {{ sequencer_tia_bridge_pkey }} transfer/channel-0/utia nria
+
+  # Load the private key of the Celestia dev account to issue transfers
+  just ibc-test _load-celestia-key "{{ celestiaHome}}" "{{ pathToCelestiaAppd }}"
+
+  # Execute the transfer from Celestia to the Rollup
+  just ibc-test _do-ibc-transfer "{{ celestiaHome}}" "{{ pathToCelestiaAppd }}"
+
+  # Multiplication factor is 10^-6 (utia to tia) * 10^18 (rollup factor) = 10^12
+  let expected_balance="$initial_balance + {{ transfer_amount }} * 10**12"
+
+  for i in {1..50}
+  do
+    current_balance=$(just evm-get-balance {{evm_destination_address}})
+    echo "check $i, balance: $current_balance, expected: $expected_balance"
+    if (( expected_balance == $current_balance )); then
+      expected_balance_found="1"
+      break
+    else
+      sleep 1
+    fi
+  done
+  if [[ -z $expected_balance_found ]]; then
+    echo "expected balance was not found; IBC transfer from Celestia to the Rollup failed"
+    exit 1
+  fi
+    
+
+bridge_address := "astria1d7zjjljc0dsmxa545xkpwxym86g8uvvwhtezcr"
+celestia_dev_account_address := "celestia1m0ksdjl2p5nzhqy3p47fksv52at3ln885xvl96"
+celestia_dev_account_key_name := "dev"
+celestia_dev_account_mnemonic := "enrich avocado local net will avoid dizzy truth column excuse ready lesson"
+celestia_chain_id := "celestia-local-0"
+celestia_node_url := "http://rpc.app.celestia.localdev.me:80"
+sequencer_tia_bridge_pkey := "6015fbe1c365d3c5ef92dc891db8c5bb26ad454bec2db4762b96e9f8b2430285"
+keyring_backend := "test"
+
+# This is the same address as used in deploy.just
+evm_destination_address := "0xaC21B97d35Bf75A7dAb16f35b111a50e78A72F30"
+
+# all in units of utia
+transfer_amount := "53000"
+transfer_fees := "26000"
+
+default_celestia_appd := "celestia-appd"
+[no-cd]
+_load-celestia-key celestiaHome pathToCelestiaAppd=default_celestia_appd:
+  #!/usr/bin/env bash
+  pwd
+  "{{pathToCelestiaAppd}}" keys add {{ celestia_dev_account_key_name }} \
+    --home "{{celestiaHome}}" \
+    --keyring-backend="{{ keyring_backend }}" \
+    --recover <<< "{{ celestia_dev_account_mnemonic }}"
+
+[no-cd]
+_do-ibc-transfer celestiaHome pathToCelestiaAppd=default_celestia_appd:
+  echo "Performing IBC transfer..."
+  "{{pathToCelestiaAppd}}" tx ibc-transfer transfer \
+    transfer \
+    channel-0 \
+    {{ bridge_address }} \
+    "{{ transfer_amount }}utia" \
+    --memo="{\"rollupDepositAddress\":\"{{ evm_destination_address }}\"}" \
+    --chain-id="{{ celestia_chain_id }}" \
+    --node="{{ celestia_node_url }}" \
+    --from="{{ celestia_dev_account_address }}" \
+    --fees="{{ transfer_fees }}utia" \
+    --yes \
+    --log_level=debug \
+    --home "{{celestiaHome}}" \
+    --keyring-backend="{{ keyring_backend }}"

charts/bridge-test/Chart.yaml

@@ -11,6 +11,8 @@ astria-core = { path = "../astria-core", features = ["serde"] }
 ethers = { workspace = true }
 futures = { workspace = true }
 ibc-types = { workspace = true }
+prost = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 tendermint = { workspace = true }
 thiserror = { workspace = true }

charts/bridge-test/files/scripts/test-ibc-transfer.sh

@@ -12,9 +12,12 @@ use astria_core::{
         Address,
         AddressError,
     },
-    protocol::transaction::v1alpha1::{
-        action::Ics20Withdrawal,
-        Action,
+    protocol::{
+        memos,
+        transaction::v1alpha1::{
+            action::Ics20Withdrawal,
+            Action,
+        },
     },
 };
 use astria_withdrawer::{
@@ -370,15 +373,15 @@ where
         &self,
         log: Log,
     ) -> Result<Action, GetWithdrawalActionsError> {
-        let block_number = log
+        let rollup_block_number = log
             .block_number
             .ok_or_else(|| GetWithdrawalActionsError::log_without_block_number(&log))?
             .as_u64();
 
-        let transaction_hash = log
+        let rollup_transaction_hash = log
             .transaction_hash
             .ok_or_else(|| GetWithdrawalActionsError::log_without_transaction_hash(&log))?
-            .into();
+            .to_string();
 
         let event = decode_log::<Ics20WithdrawalFilter>(log)
             .map_err(GetWithdrawalActionsError::decode_log)?;
@@ -393,15 +396,13 @@ where
                 .expect("must be set if this method is entered"),
         );
 
-        let memo = serde_json::to_string(&astria_core::bridge::Ics20WithdrawalFromRollupMemo {
+        let memo = memo_to_json(&memos::v1alpha1::Ics20WithdrawalFromRollup {
             memo: event.memo.clone(),
-            block_number,
+            rollup_block_number,
             rollup_return_address: event.sender.to_string(),
-            transaction_hash,
+            rollup_transaction_hash,
         })
-        .map_err(|source| {
-            GetWithdrawalActionsError::encode_memo("Ics20WithdrawalFromRollupMemo", source)
-        })?;
+        .map_err(GetWithdrawalActionsError::encode_memo)?;
 
         let amount = calculate_amount(&event, self.asset_withdrawal_divisor)
             .map_err(GetWithdrawalActionsError::calculate_withdrawal_amount)?;
@@ -427,24 +428,24 @@ where
         &self,
         log: Log,
     ) -> Result<Action, GetWithdrawalActionsError> {
-        let block_number = log
+        let rollup_block_number = log
             .block_number
             .ok_or_else(|| GetWithdrawalActionsError::log_without_block_number(&log))?
             .as_u64();
 
-        let transaction_hash = log
+        let rollup_transaction_hash = log
             .transaction_hash
             .ok_or_else(|| GetWithdrawalActionsError::log_without_transaction_hash(&log))?
-            .into();
+            .to_string();
 
         let event = decode_log::<SequencerWithdrawalFilter>(log)
             .map_err(GetWithdrawalActionsError::decode_log)?;
 
-        let memo = serde_json::to_string(&astria_core::bridge::UnlockMemo {
-            block_number,
-            transaction_hash,
+        let memo = memo_to_json(&memos::v1alpha1::BridgeUnlock {
+            rollup_block_number,
+            rollup_transaction_hash,
         })
-        .map_err(|err| GetWithdrawalActionsError::encode_memo("bridge::UnlockMemo", err))?;
+        .map_err(GetWithdrawalActionsError::encode_memo)?;
 
         let amount = calculate_amount(&event, self.asset_withdrawal_divisor)
             .map_err(GetWithdrawalActionsError::calculate_withdrawal_amount)?;
@@ -485,11 +486,8 @@ impl GetWithdrawalActionsError {
         ))
     }
 
-    fn encode_memo(which: &'static str, source: serde_json::Error) -> Self {
-        Self(GetWithdrawalActionsErrorKind::EncodeMemo {
-            which,
-            source,
-        })
+    fn encode_memo(source: EncodeMemoError) -> Self {
+        Self(GetWithdrawalActionsErrorKind::EncodeMemo(source))
     }
 
     fn get_logs(source: GetLogsError) -> Self {
@@ -513,11 +511,8 @@ enum GetWithdrawalActionsErrorKind {
     DecodeLog(DecodeLogError),
     #[error(transparent)]
     DestinationChainAsAddress(DestinationChainAsAddressError),
-    #[error("failed encoding memo `{which}`")]
-    EncodeMemo {
-        which: &'static str,
-        source: serde_json::Error,
-    },
+    #[error(transparent)]
+    EncodeMemo(EncodeMemoError),
     #[error(transparent)]
     GetLogs(GetLogsError),
     #[error("log did not contain a block number")]
@@ -628,6 +623,20 @@ struct DestinationChainAsAddressError {
     source: AddressError,
 }
 
+#[derive(Debug, thiserror::Error)]
+#[error("failed encoding memo `{proto_message}` as JSON")]
+struct EncodeMemoError {
+    proto_message: String,
+    source: serde_json::Error,
+}
+
+fn memo_to_json<T: prost::Name + serde::Serialize>(memo: &T) -> Result<String, EncodeMemoError> {
+    serde_json::to_string(memo).map_err(|source| EncodeMemoError {
+        proto_message: T::full_name(),
+        source,
+    })
+}
+
 fn parse_destination_chain_as_address(
     event: &SequencerWithdrawalFilter,
 ) -> Result<Address, DestinationChainAsAddressError> {

charts/bridge-test/templates/_helpers.tpl

@@ -4,10 +4,6 @@ use std::{
 };
 
 use astria_core::{
-    bridge::{
-        self,
-        Ics20WithdrawalFromRollupMemo,
-    },
     generated::sequencerblock::v1alpha1::{
         sequencer_service_client::{
             self,
@@ -19,6 +15,7 @@ use astria_core::{
     protocol::{
         asset::v1alpha1::AllowedFeeAssetsResponse,
         bridge::v1alpha1::BridgeAccountLastTxHashResponse,
+        memos,
         transaction::v1alpha1::Action,
     },
 };
@@ -442,14 +439,15 @@ fn rollup_height_from_signed_transaction(
 
     let last_batch_rollup_height = match withdrawal_action {
         Action::BridgeUnlock(action) => {
-            let memo: bridge::UnlockMemo = serde_json::from_str(&action.memo)
+            let memo: memos::v1alpha1::BridgeUnlock = serde_json::from_str(&action.memo)
                 .wrap_err("failed to parse memo from last transaction by the bridge account")?;
-            Some(memo.block_number)
+            Some(memo.rollup_block_number)
         }
         Action::Ics20Withdrawal(action) => {
-            let memo: Ics20WithdrawalFromRollupMemo = serde_json::from_str(&action.memo)
-                .wrap_err("failed to parse memo from last transaction by the bridge account")?;
-            Some(memo.block_number)
+            let memo: memos::v1alpha1::Ics20WithdrawalFromRollup =
+                serde_json::from_str(&action.memo)
+                    .wrap_err("failed to parse memo from last transaction by the bridge account")?;
+            Some(memo.rollup_block_number)
         }
         _ => None,
     }

charts/bridge-test/templates/configmap.yaml

@@ -6,7 +6,6 @@ compile_error!(
 #[rustfmt::skip]
 pub mod generated;
 
-pub mod bridge;
 pub mod crypto;
 pub mod execution;
 pub mod primitive;

charts/bridge-test/templates/job.yaml

@@ -0,0 +1 @@
+pub mod v1alpha1;

charts/bridge-test/values.yaml

@@ -0,0 +1,8 @@
+---
+source: crates/astria-core/src/protocol/memos/v1alpha1.rs
+expression: memo
+---
+{
+  "rollupBlockNumber": "42",
+  "rollupTransactionHash": "a-rollup-defined-hash"
+}

charts/deploy.just

@@ -0,0 +1,7 @@
+---
+source: crates/astria-core/src/protocol/memos/v1alpha1.rs
+expression: memo
+---
+{
+  "rollupDepositAddress": "an-address-on-the-rollup"
+}

charts/ibc-test.just

@@ -0,0 +1,10 @@
+---
+source: crates/astria-core/src/protocol/memos/v1alpha1.rs
+expression: memo
+---
+{
+  "rollupBlockNumber": "1",
+  "rollupTransactionHash": "a-rollup-defined-hash",
+  "rollupReturnAddress": "a-rollup-defined-address",
+  "memo": "hello"
+}

crates/astria-bridge-contracts/Cargo.toml

@@ -0,0 +1,41 @@
+pub use crate::generated::protocol::memos::v1alpha1::{
+    BridgeUnlock,
+    Ics20TransferDeposit,
+    Ics20WithdrawalFromRollup,
+};
+
+#[cfg(all(feature = "serde", test))]
+mod test {
+    use super::*;
+
+    #[test]
+    fn bridge_unlock_memo_snapshot() {
+        let memo = BridgeUnlock {
+            rollup_block_number: 42,
+            rollup_transaction_hash: "a-rollup-defined-hash".to_string(),
+        };
+
+        insta::assert_json_snapshot!(memo);
+    }
+
+    #[test]
+    fn ics20_withdrawal_from_rollup_memo_snapshot() {
+        let memo = Ics20WithdrawalFromRollup {
+            rollup_block_number: 1,
+            rollup_return_address: "a-rollup-defined-address".to_string(),
+            rollup_transaction_hash: "a-rollup-defined-hash".to_string(),
+            memo: "hello".to_string(),
+        };
+
+        insta::assert_json_snapshot!(memo);
+    }
+
+    #[test]
+    fn ics20_transfer_deposit_memo_snapshot() {
+        let memo = Ics20TransferDeposit {
+            rollup_deposit_address: "an-address-on-the-rollup".to_string(),
+        };
+
+        insta::assert_json_snapshot!(memo);
+    }
+}

crates/astria-bridge-contracts/src/lib.rs

@@ -7,6 +7,7 @@ pub mod abci;
 pub mod account;
 pub mod asset;
 pub mod bridge;
+pub mod memos;
 pub mod transaction;
 
 #[cfg(any(feature = "test-utils", test))]

crates/astria-bridge-withdrawer/src/bridge_withdrawer/startup.rs

@@ -1,8 +1,5 @@
 use base64_serde::base64_serde_type;
-use serde::{
-    Deserializer,
-    Serializer,
-};
+use serde::Serializer;
 
 base64_serde_type!(pub(crate) Base64Standard, base64::engine::general_purpose::STANDARD);
 pub(crate) fn base64_serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
@@ -12,12 +9,3 @@ where
 {
     Base64Standard::serialize(value, serializer)
 }
-
-pub(crate) fn base64_deserialize_array<'de, T, D>(deserializer: D) -> Result<T, D::Error>
-where
-    T: TryFrom<Vec<u8>>,
-    D: Deserializer<'de>,
-{
-    let bytes = Base64Standard::deserialize(deserializer)?;
-    T::try_from(bytes).map_err(|_| serde::de::Error::custom("invalid array length"))
-}

crates/astria-core/src/bridge.rs

@@ -18,17 +18,14 @@ use anyhow::{
     Result,
 };
 use astria_core::{
-    bridge::{
-        Ics20TransferDepositMemo,
-        Ics20WithdrawalFromRollupMemo,
-    },
     primitive::v1::{
         asset::{
             denom,
             Denom,
         },
         Address,
     },
+    protocol::memos,
     sequencerblock::v1alpha1::block::Deposit,
 };
 use cnidarium::{
@@ -412,7 +409,9 @@ async fn execute_ics20_transfer<S: StateWriteExt>(
     //
     // in this case, we lock the tokens back in the bridge account and
     // emit a `Deposit` event to send the tokens back to the rollup.
-    if is_refund && serde_json::from_str::<Ics20WithdrawalFromRollupMemo>(&packet_data.memo).is_ok()
+    if is_refund
+        && serde_json::from_str::<memos::v1alpha1::Ics20WithdrawalFromRollup>(&packet_data.memo)
+            .is_ok()
     {
         let bridge_account = packet_data.sender.parse().context(
             "sender not an Astria Address: for refunds of ics20 withdrawals that came from a \
@@ -581,20 +580,27 @@ async fn execute_ics20_transfer_bridge_lock<S: StateWriteExt>(
     }
 
     // assert memo is valid
-    let deposit_memo: Ics20TransferDepositMemo =
+    let deposit_memo: memos::v1alpha1::Ics20TransferDeposit =
         serde_json::from_str(&memo).context("failed to parse memo as Ics20TransferDepositMemo")?;
 
     ensure!(
-        !deposit_memo.rollup_address.is_empty(),
-        "packet memo field must be set for bridge account recipient",
+        !deposit_memo.rollup_deposit_address.is_empty(),
+        "rollup deposit address must be set to bridge funds from sequencer to rollup",
     );
 
     ensure!(
-        deposit_memo.rollup_address.len() <= MAX_ROLLUP_ADDRESS_BYTE_LENGTH,
+        deposit_memo.rollup_deposit_address.len() <= MAX_ROLLUP_ADDRESS_BYTE_LENGTH,
         "rollup address is too long: exceeds MAX_ROLLUP_ADDRESS_BYTE_LENGTH",
     );
 
-    execute_deposit(state, recipient, denom, amount, deposit_memo.rollup_address).await
+    execute_deposit(
+        state,
+        recipient,
+        denom,
+        amount,
+        deposit_memo.rollup_deposit_address,
+    )
+    .await
 }
 
 async fn execute_deposit<S: StateWriteExt>(
@@ -766,8 +772,8 @@ mod test {
             .put_bridge_account_ibc_asset(&bridge_address, &denom)
             .unwrap();
 
-        let memo = Ics20TransferDepositMemo {
-            rollup_address: "rollupaddress".to_string(),
+        let memo = memos::v1alpha1::Ics20TransferDeposit {
+            rollup_deposit_address: "rollupaddress".to_string(),
         };
 
         let packet = FungibleTokenPacketData {
@@ -1047,11 +1053,11 @@ mod test {
             sender: bridge_address.to_string(),
             amount: "100".to_string(),
             receiver: "other-chain-address".to_string(),
-            memo: serde_json::to_string(&Ics20WithdrawalFromRollupMemo {
+            memo: serde_json::to_string(&memos::v1alpha1::Ics20WithdrawalFromRollup {
                 memo: String::new(),
-                block_number: 1,
+                rollup_block_number: 1,
                 rollup_return_address: "rollup-defined".to_string(),
-                transaction_hash: [1u8; 32],
+                rollup_transaction_hash: hex::encode([1u8; 32]),
             })
             .unwrap(),
         };

crates/astria-core/src/generated/astria.protocol.memos.v1alpha1.rs

@@ -1,5 +1,4 @@
 import 'charts/deploy.just'
-import 'dev/bridgetester.just'
 
 default:
   @just --list
@@ -14,6 +13,22 @@ docker-build crate tag=default_docker_tag:
 install-cli:
   cargo install --path ./crates/astria-cli --locked
 
+# version is a celestia-app release. Example: v1.9.0
+# operatingSystem is Linux or Darwin
+# machineHardwareName is arm64 or x86_64
+celestia_default_appd_dst := "."
+get-celestia-appd version operatingSystem machineHardwareName dst=celestia_default_appd_dst:
+  #!/usr/bin/env bash
+  src="celestia-app_{{operatingSystem}}_{{machineHardwareName}}.tar.gz"
+  curl -LOsS -q --output-dir "{{dst}}" \
+    https://github.com/celestiaorg/celestia-app/releases/download/{{version}}/"$src"
+  curl -LOsS -q --output-dir "{{dst}}" \
+    https://github.com/celestiaorg/celestia-app/releases/download/{{version}}/checksums.txt
+  cd "{{dst}}"
+  sha256sum --ignore-missing -c checksums.txt
+  cd -
+  tar --directory "{{dst}}" -xvzf "{{dst}}"/"$src" celestia-appd
+
 # Compiles the generated rust code from protos which are used in crates.
 compile-protos:
   cargo run --manifest-path tools/protobuf-compiler/Cargo.toml

crates/astria-core/src/generated/astria.protocol.memos.v1alpha1.serde.rs

@@ -0,0 +1,56 @@
+// Memo types that are intended to only be serialized as plaintext JSON and encoded
+// as binary/protobuf. The intent is to follow the IBC convention of keeping memos as
+// JSON. The specific JSON formatting should follows the pbjson mapping.
+//
+// XXX: Different from protobuf any changes in the field names is protocol breaking,
+//      because these messages are serialized as plaintext JSON.
+
+syntax = "proto3";
+
+package astria.protocol.memos.v1alpha1;
+
+message BridgeUnlock {
+  // The block number on the rollup that triggered the transaction underlying
+  // this bridge unlock memo.
+  uint64 rollup_block_number = 1;
+  // The hash of the original rollup transaction that triggered a bridge unlock
+  // and that is underlying this bridge unlock memo.
+  //
+  // This field is of type `string` so that it can be formatted in the preferred
+  // format of the rollup when targeting plain text encoding.
+  string rollup_transaction_hash = 2;
+}
+
+// Memo for an ICS20 withdrawal from the rollup which is sent to
+// an external IBC-enabled chain.
+message Ics20WithdrawalFromRollup {
+  // The block number on the rollup that triggered the transaction underlying
+  // this ics20 withdrawal memo.
+  uint64 rollup_block_number = 1;
+  // The hash of the original rollup transaction that triggered this ics20
+  // withdrawal and that is underlying this bridge unlock memo.
+  //
+  // This field is of type `string` so that it can be formatted in the preferred
+  // format of the rollup when targeting plain text encoding.
+  string rollup_transaction_hash = 2;
+  // The return address on the rollup to which funds should returned in case of
+  // failure. This field exists so that the rollup can identify which account
+  // the returned funds originated from.
+  //
+  // This field is of type `string` so that it can be formatted in the preferred
+  // format of the rollup when targeting plain text encoding.
+  string rollup_return_address = 3;
+  // A field that can be populated by the rollup. It is assumed that this field
+  // will be consumed by the downstream chain.
+  string memo = 4;
+}
+
+// Memo for an ICS20 transfer to Astria which is sent to a
+// bridge account, which will then be deposited into the rollup.
+message Ics20TransferDeposit {
+  // The destination address for the deposit on the rollup.
+  //
+  // This field is of type `string` so that it can be formatted in the preferred
+  // format of the rollup when targeting plain text encoding.
+  string rollup_deposit_address = 1;
+}