# Solana Meteora DAMM v2 Transaction Parsing

Meteora's Dynamic AMM v2 (DAMM v2) introduces a new era of liquidity provision on Solana, featuring optimized transaction fees and enhanced flexibility for LPs and token launches. For those looking to understand the mechanics of these advanced pools, real-time transaction data is essential. This document will guide you through streaming and parsing Meteora DAMM v2 transactions, providing immediate insights into its unique fee structures, concentrated liquidity features, and anti-sniper mechanisms.

{% hint style="success" %}
The complete source code for this project is available on GitHub. 

* [<mark style="color:yellow;">TypeScript</mark>](http://github.com/Shyft-to/solana-defi/tree/main/Meteora/Typescript/stream_and_parse_meteora_damm_transactions)
* [<mark style="color:yellow;">Rust</mark>](https://github.com/Shyft-to/solana-defi/tree/main/Meteora/Rust/stream_and_parse_meteora_damm_transaction)

Please feel free to clone the repository and try it out. Additionally, you will find other relevant and useful code examples related to gRPC and streaming [<mark style="color:yellow;">here</mark>](https://github.com/Shyft-to/solana-defi).
{% endhint %}

## Step-by-Step Breakdown

This project consists of two key components:

1. Streaming Meteora DAMM Transactions via Yellowstone gRPC
2. Parsing those transactions using the program's IDL

### Streaming Transactions Using gRPC

The first step involves initializing the Solana Yellowstone Client. You can get Solana Yellowstone gRPC access from the Shyft Dashboard. Please check out our [gRPC Authentication Docs](https://docs.shyft.to/docs#authentication) for more details.&#x20;

#### Initializing the Client

Once you have the authentication details, you can initialize the client in the following manner,

{% tabs %}
{% tab title="TypeScript" %}

```typescript
import Client from "@triton-one/yellowstone-grpc";

const client = new Client(
  "YOUR-GRPC-ENDPOINT", //yellowstone grpc url
  "GRPC-ACCESS-TOKEN", //authentication token
  undefined
);
```

{% endtab %}

{% tab title="Rust" %}

```rust
use yellowstone_grpc_client::{GeyserGrpcClient, Interceptor}

async fn connect(&self) -> anyhow::Result<GeyserGrpcClient<impl Interceptor>> {
     GeyserGrpcClient::build_from_shared(self.endpoint.clone())? //grpc url
            .x_token(Some(self.x_token.clone()))? //grpc auth token
            .connect_timeout(Duration::from_secs(10))
            .timeout(Duration::from_secs(10))
            .tls_config(ClientTlsConfig::new().with_native_roots())?
            .max_decoding_message_size(1024 * 1024 * 1024)
            .connect()
            .await
            .map_err(Into::into)
}
```

{% endtab %}
{% endtabs %}

You can use any **Yellowstone** gRPC endpoint with this client. An access token is **optional**, as some gRPC services don't require authentication.

The Rust client supports several additional options, as demonstrated in the example above. Most of these options are also available for the TS client, where they are passed as the third argument to the `Client` constructor.

#### Specifying what data to stream from gRPC

To specify what on-chain data,  we send a `SubscribeRequest` over the existing **Solana Yellowstone gRPC** client. These Request allows you to filter for specific **accounts**, **transactions**, **slots**, or other **Solana on-chain events**, giving you full control over the data you receive.

You can find out more about [Subscribe Requests](https://docs.shyft.to/docs#what-are-subscribe-requests) here. The example below demonstrates how to initiate a gRPC stream by sending a `SubscribeRequest` using a standard gRPC client:

{% tabs %}
{% tab title="TypeScript" %}
{% code overflow="wrap" %}

```typescript
const req: SubscribeRequest = {
  accounts: {},
  slots: {},
  transactions: {
    meteoraDamm: {
      vote: false,
      failed: false,
      signature: undefined,
      accountInclude: ["cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"],
      //for our usecase we only need to listen to transaction belonging to one program, so we have added one address
      accountExclude: [],
      accountRequired: [],
    },
  },
  transactionsStatus: {},
  entry: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  ping: undefined,
  commitment: CommitmentLevel.CONFIRMED,
};
```

{% endcode %}
{% endtab %}

{% tab title="Rust" %}
{% code overflow="wrap" %}

```rust
transactions.insert(
   "client".to_owned(),
   SubscribeRequestFilterTransactions {
        vote: Some(false),
        failed: Some(false),
        account_include: vec!["cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"], 
        //for our usecase we only need to listen to transaction belonging to one program
        account_exclude: vec![],
        account_required: vec![],
        signature: None,
   }
 );
```

{% endcode %}
{% endtab %}
{% endtabs %}

Once established, the stream will begin sending data directly to your application. You have the flexibility to [**modify your subscription**](https://docs.shyft.to/solana-yellowstone-grpc/docs/getting-started/modify-grpc-subscribe-request) **on the fly**, allowing you to change the data specifications you receive without stopping your stream. For more details on [**reconnecting and re-starting the stream from a specific slot**](https://docs.shyft.to/solana-yellowstone-grpc/docs/getting-started/replaying-slots-with-grpc)**, or** [**closing your gRPC connection**](https://docs.shyft.to/solana-yellowstone-grpc/docs/getting-started/gracefully-closing-a-grpc-connection), you can find additional information in our [documentation](https://docs.shyft.to/solana-yellowstone-grpc/docs).

### Parsing the received transaction

Once a raw Solana transaction is received via the Yellowstone gRPC stream, it must be parsed to extract meaningful, human-readable data. For JavaScript/TypeScript applications, [**Shyft's IDL-based transaction parser**](https://www.npmjs.com/package/@shyft-to/solana-transaction-parser), are commonly used, as they efficiently decode transactions into structured data based on the program's IDL.&#x20;

On Rust however, we use a interface generated by [solores](https://crates.io/crates/solores) to parse the transaction instruction.&#x20;

{% tabs %}
{% tab title="TypeScript" %}

```typescript
import { SolanaParser } from "@shyft-to/solana-transaction-parser";
import meteoraDammIdl from "./idls/meteora_damm.json";

const METEORA_DAMM_PROGRAM_ID = new PublicKey(
  "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
);
const METEORA_DAMM_IX_PARSER = new SolanaParser([]);
METEORA_DAMM_IX_PARSER.addParserFromIdl(
  METEORA_DAMM_PROGRAM_ID.toBase58(),
  meteoraDammIdl as Idl
);

function decodeRaydiumLaunchpad(tx: VersionedTransactionResponse) {
  if (tx.meta?.err) return;
  try{
    const paredIxs = METEORA_DAMM_IX_PARSER.parseTransactionData(
      tx.transaction.message,
      tx.meta.loadedAddresses,
    ); //parsing transaction

    const parsedInnerIxs = METEORA_DAMM_IX_PARSER.parseTransactionWithInnerInstructions(tx);
    //parsing inner instructions
     
     //..code shortened
    return result;
  }catch(err){
    console.log(err);
  }
}

```

{% endtab %}

{% tab title="Rust" %}

```rust
message: VersionedMessage::V0(
    Message {
        //....shortend for visibility
        instructions: raw_message
            .instructions
            .iter()
            .map(|ix| CompiledInstruction {
                program_id_index: ix.program_id_index as u8,
                accounts: ix.accounts.clone(),
                data: ix.data.clone(),
            })
            .collect(),
        address_table_lookups:
            raw_message
                .address_table_lookups
                .iter()
                .map(|l| MessageAddressTableLookup {
                    account_key: Pubkey::new_from_array(l.account_key.clone().try_into().expect("Failed to convert Vec<u8> to [u8; 32]")),
                    writable_indexes: l.writable_indexes.clone(),
                    readonly_indexes: l.readonly_indexes.clone(),
                })
                .collect(),
    }
),
},
meta: TransactionStatusMeta {
status: Result::Ok(()),
fee: meta.fee,
pre_balances: meta.pre_balances.clone(),
post_balances: meta.post_balances.clone(),
inner_instructions: Some(
    meta.inner_instructions.iter().map(|f| {
        InnerInstructions {
            index: f.index as u8,
            instructions: f.instructions.iter().map(|v| {
                InnerInstruction {
                    instruction: CompiledInstruction {
                        program_id_index: v.program_id_index as u8,
                        accounts: v.accounts.clone(),
                        data: v.data.clone(),
                    },
                    stack_height: Some(v.stack_height.unwrap()),
                }
            }).collect(),
        }
    }).collect()
),
```

{% endtab %}
{% endtabs %}

### Important Links

* [**Solana gRPC Documentation**](https://docs.shyft.to/solana-yellowstone-grpc/docs) – In-depth technical docs for implementing real-time streaming with **Yellowstone gRPC** and **Geyser plugin** on Solana.
* [**Blogs on Solana gRPC Streaming**](https://blogs.shyft.to/) – Guides, use cases, and performance benchmarks for building **low-latency Solana applications** using **gRPC-based infrastructure**.
* [**Solana DeFi Code Snippets & Examples**](https://github.com/Shyft-to/solana-defi/) – Ready-to-use code snippets and integrations for common **DeFi protocols**, **transaction parsers**, and **real-time Solana data streaming** use cases.