From b97a8395677fb98bd2267028494495e655f949a5 Mon Sep 17 00:00:00 2001
From: erkostandyan <erik.kostandyan2003@gmail.com>
Date: Wed, 4 Mar 2026 23:57:29 +0400
Subject: [PATCH 1/5] solana initial commit.

---
 .claude/rules/key-files.md                    |  15 +
 CLAUDE.md                                     |  97 +-
 csharp/TrainSolver.slnx                       |   1 +
 csharp/src/AdminPanel/wwwroot/index.html      |   2 +-
 csharp/src/AppHost/AppHost.cs                 |   7 +
 csharp/src/AppHost/AppHost.csproj             |   1 +
 .../Activities/ISolanaBlockchainActivities.cs |  64 ++
 .../Activities/ISolanaWorkflowActivities.cs   |  20 +
 .../Activities/SolanaBlockchainActivities.cs  | 857 ++++++++++++++++
 .../Activities/SolanaWorkflowActivities.cs    |  80 ++
 .../Activities/WorkflowActivities.cs          | 111 +++
 .../TrainSolverBuilderExtensions.cs           |  38 +
 .../Helpers/SolanaAnchorHelper.cs             | 247 +++++
 .../Workflow.Solana/Helpers/SolanaHelper.cs   | 111 +++
 .../Models/SolanaHTLCModels.cs                | 160 +++
 .../Workflow.Solana/Models/SolanaModels.cs    | 226 +++++
 csharp/src/Workflow.Solana/Program.cs         |  21 +
 .../Properties/launchSettings.json            |  11 +
 .../SolanaListenerCapabilities.cs             | 124 +++
 .../Workflow.Solana/Workflow.Solana.csproj    |  28 +
 .../Workflows/SolanaAddressGenerator.cs       |  27 +
 .../Workflows/SolanaEventListenerBase.cs      | 239 +++++
 .../Workflows/SolanaNetworkRuntime.cs         | 726 ++++++++++++++
 .../Workflows/SolanaRPCEventListener.cs       | 229 +++++
 .../Workflows/SolanaTransactionProcessor.cs   | 935 ++++++++++++++++++
 csharp/src/Workflow.Solana/appsettings.json   |  12 +
 .../src/treasury/solana/solana.service.ts     |  10 +-
 27 files changed, 4393 insertions(+), 6 deletions(-)
 create mode 100644 csharp/src/Workflow.Solana/Activities/ISolanaBlockchainActivities.cs
 create mode 100644 csharp/src/Workflow.Solana/Activities/ISolanaWorkflowActivities.cs
 create mode 100644 csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs
 create mode 100644 csharp/src/Workflow.Solana/Activities/SolanaWorkflowActivities.cs
 create mode 100644 csharp/src/Workflow.Solana/Activities/WorkflowActivities.cs
 create mode 100644 csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs
 create mode 100644 csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs
 create mode 100644 csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs
 create mode 100644 csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs
 create mode 100644 csharp/src/Workflow.Solana/Models/SolanaModels.cs
 create mode 100644 csharp/src/Workflow.Solana/Program.cs
 create mode 100644 csharp/src/Workflow.Solana/Properties/launchSettings.json
 create mode 100644 csharp/src/Workflow.Solana/SolanaListenerCapabilities.cs
 create mode 100644 csharp/src/Workflow.Solana/Workflow.Solana.csproj
 create mode 100644 csharp/src/Workflow.Solana/Workflows/SolanaAddressGenerator.cs
 create mode 100644 csharp/src/Workflow.Solana/Workflows/SolanaEventListenerBase.cs
 create mode 100644 csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs
 create mode 100644 csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs
 create mode 100644 csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
 create mode 100644 csharp/src/Workflow.Solana/appsettings.json

diff --git a/.claude/rules/key-files.md b/.claude/rules/key-files.md
index d096aa06..8560d7cd 100644
--- a/.claude/rules/key-files.md
+++ b/.claude/rules/key-files.md
@@ -31,6 +31,21 @@
 | IAddressGenerator | `src/Workflow.Abstractions/Workflows/IAddressGenerator.cs` |
 | AddressGenerator (EVM) | `src/Workflow.EVM/Workflows/AddressGenerator.cs` |
 | AddressGenerator (Starknet) | `js/src/Blockchain/Blockchain.Starknet/Workflows/StarknetAddressGenerator.ts` |
+| AddressGenerator (Solana) | `src/Workflow.Solana/Workflows/SolanaAddressGenerator.cs` |
+| Solana network runtime | `src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs` |
+| Solana transaction processor | `src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs` |
+| Solana blockchain activities interface | `src/Workflow.Solana/Activities/ISolanaBlockchainActivities.cs` |
+| Solana blockchain activities impl | `src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs` |
+| Solana workflow activities interface | `src/Workflow.Solana/Activities/ISolanaWorkflowActivities.cs` |
+| Solana workflow activities impl | `src/Workflow.Solana/Activities/SolanaWorkflowActivities.cs` |
+| Solana RPC event listener | `src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs` |
+| Solana event listener base | `src/Workflow.Solana/Workflows/SolanaEventListenerBase.cs` |
+| Solana listener capabilities | `src/Workflow.Solana/SolanaListenerCapabilities.cs` |
+| Solana anchor helper | `src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs` |
+| Solana HTLC models | `src/Workflow.Solana/Models/SolanaHTLCModels.cs` |
+| Solana models | `src/Workflow.Solana/Models/SolanaModels.cs` |
+| Solana helper | `src/Workflow.Solana/Helpers/SolanaHelper.cs` |
+| Solana DI extensions | `src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs` |
 | WalletGenerator | `src/Workflow.Swap/Workflows/WalletGenerator.cs` |
 | INetworkRuntime | `src/Workflow.Abstractions/Workflows/INetworkRuntime.cs` |
 | NetworkRuntime | `src/Workflow.EVM/Workflows/NetworkRuntime.cs` |
diff --git a/CLAUDE.md b/CLAUDE.md
index d180050c..11953677 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -9,7 +9,7 @@ csharp/                     # .NET 9 backend (Aspire, Temporal, APIs, workflows)
 ├── src/                    # Source projects
 ├── tests/                  # xUnit tests
 └── tools/                  # DataSeeder, ProtoGenerator
-js/                         # TypeScript workers (Aztec, Starknet network support)
+js/                         # TypeScript workers (Aztec, Starknet, Solana network support)
 treasury/                   # Vault-backed key management service (JS)
 protos/blockchain.proto     # Language-agnostic network worker contract schema
 ```
@@ -87,7 +87,7 @@ dotnet test tests/Workflow.Tests/Workflow.Tests.csproj
 
 ## JS Project (`js/`)
 
-TypeScript Temporal workers for non-EVM networks (Aztec, Starknet).
+TypeScript Temporal workers for non-EVM networks (Aztec, Starknet, Solana).
 
 ```bash
 # Install (from js/)
@@ -113,6 +113,99 @@ Bare minimum integration — transfers only, no HTLC contract support yet.
 - **Same Dockerfile as Aztec**: Differentiated by `TrainSolver__NetworkType` env var
 - **AppHost**: `workflow-runner-starknet` container with `TrainSolver__NetworkSlug=starknet-sepolia`
 
+### Solana (`js/src/Blockchain/Blockchain.Solana/`) — SUPERSEDED by C# Workflow.Solana
+
+**Note:** The JS Solana worker has been replaced by the C# `Workflow.Solana` project (see below). The JS code remains in the repo for reference but is no longer used. AppHost now runs a C# project instead of a JS container.
+
+### Workflow.Solana (`csharp/src/Workflow.Solana/`)
+
+C# Solana integration using SolNet SDK with `recentBlockhash` + ComputeBudget priority fees. HTLC event listener polls Anchor program transactions (no Anchor events — instruction-based detection).
+
+- **NetworkType**: `solana`, task queue: `solana`
+- **SDK**: SolNet v6.1.0 (`Solnet.Rpc`, `Solnet.Programs`, `Solnet.Wallet`)
+- **DI registration**: `.WithSolanaWorkflows()` in `TrainSolverBuilderExtensions`
+- **AppHost**: `workflow-runner-solana` C# project with `TrainSolver__NetworkType=solana`
+
+**Transaction Pipeline (recentBlockhash + priority fees):**
+Uses `getLatestBlockhash` for transaction lifetime instead of durable nonce accounts. Each transaction includes ComputeBudget instructions for priority fee bidding. Expired transactions are retried with escalated fees.
+- Pipeline: Queued → GetLatestBlockhash → GetPriorityFee → Build(blockhash, ComputeBudget) → Sign → Pending → Publish → InFlight → Confirmed/Expired
+- Priority fee: 75th percentile of `getRecentPrioritizationFees` (floor: 1000 microLamports)
+- Expiry detection: `currentBlockHeight > lastValidBlockHeight` OR `elapsed > stuckTimeoutSeconds`
+- Retry on expiry: up to 3 retries with 1.5x fee escalation (1x → 1.5x → 2.25x → fail)
+- Redis used only for TP state persistence (`solana:tp-state:{slug}:{wallet}`, 7-day TTL)
+
+**ComputeBudget helpers** (`SolanaHelper`):
+- `SetComputeUnitLimit(uint units)` — discriminant `0x02` + 4-byte LE u32
+- `SetComputeUnitPrice(ulong microLamports)` — discriminant `0x03` + 8-byte LE u64
+- Both return `TransactionInstruction` with `ComputeBudget111111111111111111111111111111` program ID
+
+**Transaction Processor** (`SolanaTransactionProcessor`):
+- 3-queue pipeline: Queued → Pending (blockhash + signed) → InFlight (published, polling)
+- Supports all HTLC signals: SubmitLock, SubmitRedeem, SubmitRefund, SubmitUserRefund, SubmitTransfer
+- HTLC tx building: TP reads HTLC PDA account on-chain (for redeem/refund account metas), builds Anchor instructions via `SolanaAnchorHelper`, signs via treasury
+- `SolanaQueuedRequest` carries typed request (`LockRequest`, `RedeemRequest`, `RefundRequest`, `TransferRequest`) — routed by `Type` in `BuildUnsignedTransactionForQueuedAsync`
+- **No gas bumping** — Solana has no mempool replacement. Uses priority fee escalation on retry instead.
+- **No cancellation tx** — no self-transfer pattern
+- **No orphaned monitoring** — expired transactions are retried or failed
+- `maxInFlightTransactions = 10` (configurable via DB)
+- Continue-as-new at 50 iterations
+- State persisted to Redis (`solana:tp-state:{slug}:{wallet}`, 7-day TTL)
+
+**Network Runtime** (`SolanaNetworkRuntime`):
+- Bootstrap: fetch network + wallets, start TransactionProcessors + event listeners
+- Listener support: bootstraps `rpc-log-event-listener` from `EventListenerConfigs`, composes subscriptions via `SolanaListenerCapabilities`
+- No GasStation (Solana uses priority fees, not EVM gas estimation)
+- Health check every ~1 min: re-fetch wallets, reconcile TPs/listeners, update subscriptions if filter addresses change
+- Update handlers: GetBalance, GetBatchBalances, ValidateAddress, ValidateNode, and all 6 HTLC Build* methods (BuildSolverLock, BuildUserLock, BuildSolverRedeem, BuildUserRedeem, BuildSolverRefund, BuildUserRefund) via local activities
+- Build* methods read HTLC PDA account on-chain for redeem/refund (to get sender/src_receiver for account metas)
+- Continue-as-new at 200 operations
+
+**Event Listener** (`SolanaRPCEventListener`):
+- Polls `getSignaturesForAddress(HTLCProgramId)` for HTLC program transactions
+- Parses Anchor instruction discriminators (`sha256("global:<fn>")[..8]`) to identify function calls
+- Reads HTLC PDA account data (Borsh-decoded) for hashlock, amounts, addresses
+- Event mapping: `lock()`→SolverTokenLocked, `add_lock()/add_lock_sig()`→UserTokenLocked, `redeem()/refund()`→compare HTLC.sender vs solver wallets
+- Skips `commit()` (no hashlock yet) and `lock_reward()` (supplementary)
+- Checkpoint: slot + signature stored in Redis (`solana:checkpoint:{slug}:{type}`)
+- Continue-as-new at 50 iterations
+- Self-contained `SolanaEventListenerBase` (no dependency on Workflow.EVM)
+
+**HTLC Contract** (`7ZT5gs8CG7BAv34bLYSke31DJeg5RRUa4G7p9GNcbPE`):
+- Anchor program `native_htlc` on Solana devnet
+- 7 functions: commit, lock, lock_reward, add_lock, add_lock_sig, redeem, refund
+- No Anchor events (`emit!()`) — detection via instruction parsing + PDA account reads
+- PDA seeded by 32-byte `Id` field
+- **lock() account metas**: sender(signer,mut), htlc(init,mut,PDA[Id]), system_program, rent. Id = hashlock for solver locks.
+- **redeem() account metas**: user_signing(signer,mut), sender(unchecked,mut), src_receiver(unchecked,mut), htlc(mut,PDA[Id]), system_program, rent
+- **refund() account metas**: user_signing(signer,mut), htlc(mut,PDA[Id]), sender(unchecked,mut), system_program, rent
+- **Borsh encoding**: `SolanaAnchorHelper` provides `WriteBorshU64`, `WriteBorshString`, `WriteBorshPubkey`, `WriteBorshBytes32` for instruction data serialization
+- **Instruction builders**: `BuildLockInstructionData`, `BuildRedeemInstructionData`, `BuildRefundInstructionData` in `SolanaAnchorHelper`
+
+**Address Generator** (`SolanaAddressGenerator`):
+- Single step: call treasury `/api/treasury/solana/generate` → return address
+- No funding/deployment needed (Solana addresses are just keypairs)
+
+**Activities** (`SolanaBlockchainActivities`):
+- `GetBalanceAsync`: Native SOL via `rpcClient.GetBalanceAsync`, SPL via `GetTokenAccountsByOwnerAsync`
+- `GetLatestBlockhashAsync`: Returns `SolanaBlockhashInfo { Blockhash, LastValidBlockHeight }`
+- `GetRecentPriorityFeeAsync`: Raw HTTP JSON-RPC `getRecentPrioritizationFees`, returns 75th percentile (floor: 1000 µL)
+- `BuildHTLCLockTransactionAsync`: Builds Anchor `lock()` instruction — PDA from hashlock, Borsh-encoded args (Id, hashlock, timelock, amount, dst_chain, dst_address, dst_asset, src_asset, src_receiver)
+- `BuildHTLCRedeemTransactionAsync`: Builds Anchor `redeem()` instruction — account metas require sender + src_receiver from PDA account data
+- `BuildHTLCRefundTransactionAsync`: Builds Anchor `refund()` instruction — account metas require sender from PDA account data
+- `GetHTLCAccountDataAsync`: Reads HTLC PDA via `getAccountInfo` → Borsh-decodes → returns `SolanaHTLCAccount` (sender, src_receiver, hashlock, etc.)
+- `GetBlockHeightAsync`: Current block height for expiry checks
+- `BuildTransferTransactionAsync`: Uses `SetRecentBlockHash` + `SetComputeUnitLimit` + `SetComputeUnitPrice` instructions before `SystemProgram.Transfer`. Builds unsigned tx with zero-byte signature placeholders.
+- `SignTransactionAsync`: POST `/api/treasury/solana/sign` with `{ address, unsignedTxn }` → returns `{ signedTxn }`
+- `PublishTransactionAsync`: `rpcClient.SendTransactionAsync` with error classification (Published, DuplicateTransaction, InsufficientFunds, BlockhashNotFound, Failed)
+- `GetHTLCEventsAsync`: Polls `getSignaturesForAddress` → `getTransaction` → parse Anchor discriminators → read HTLC PDA accounts → returns categorized events
+
+**Unsigned Transaction Wire Format:**
+`[compact-u16 sig_count][64-zero-bytes per sig][message bytes]` — compatible with treasury's `Transaction.from(buffer)` in `@solana/web3.js` v1.
+
+**Native token address**: `11111111111111111111111111111111` (System Program). Also accepts EVM-style null address `0x0000000000000000000000000000000000000000`.
+
+**SPL token transfers**: Not yet implemented (only native SOL). Will need ATA (Associated Token Account) creation when added.
+
 ## Treasury (`treasury/`)
 
 Vault-backed key management and signing service.
diff --git a/csharp/TrainSolver.slnx b/csharp/TrainSolver.slnx
index 124778ef..174f1d5c 100644
--- a/csharp/TrainSolver.slnx
+++ b/csharp/TrainSolver.slnx
@@ -33,6 +33,7 @@
     <Project Path="src/Workflow.Common/Workflow.Common.csproj" />
     <Project Path="src/Workflow.EVM/Workflow.EVM.csproj" />
     <Project Path="src/Workflow.EVM.Common/Workflow.EVM.Common.csproj" />
+    <Project Path="src/Workflow.Solana/Workflow.Solana.csproj" />
     <Project Path="src/Workflow.Swap/Workflow.Swap.csproj" />
     <Project Path="src/Workflow.Tron/Workflow.Tron.csproj" />
   </Folder>
diff --git a/csharp/src/AdminPanel/wwwroot/index.html b/csharp/src/AdminPanel/wwwroot/index.html
index fa28554d..419dd8fe 100644
--- a/csharp/src/AdminPanel/wwwroot/index.html
+++ b/csharp/src/AdminPanel/wwwroot/index.html
@@ -28,7 +28,7 @@
         <a href="." class="reload">Reload</a>
         <span class="dismiss">🗙</span>
     </div>
-    <script src="_framework/blazor.webassembly#[.{fingerprint}].js"></script>
+    <script src="_framework/blazor.webassembly.js"></script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/ethers/6.9.0/ethers.umd.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.7/dist/chart.umd.min.js"></script>
     <script>
diff --git a/csharp/src/AppHost/AppHost.cs b/csharp/src/AppHost/AppHost.cs
index 7084b07a..a776422e 100644
--- a/csharp/src/AppHost/AppHost.cs
+++ b/csharp/src/AppHost/AppHost.cs
@@ -190,6 +190,13 @@ and assign Generated Token's Policies "train-write-policy.hcl"
     .WaitFor(temporal)
     .WaitFor(treasuryApi);
 
+builder.AddProject<Projects.Workflow_Solana>("workflow-runner-solana")
+    .AddTrainSolverDefaults(solverDb, redis, temporal, alloy)
+    .WithReplicas(1)
+    .WaitFor(treasuryApi)
+    .WithEnvironment("TrainSolver__NetworkType", "solana")
+    .WithEnvironment("QuoteSigning__HmacSecretKey", quoteSigningKey);
+
 builder.AddProject<Projects.StationAPI>("station-api")
     .WithExternalHttpEndpoints();
 
diff --git a/csharp/src/AppHost/AppHost.csproj b/csharp/src/AppHost/AppHost.csproj
index 7c47f7a9..876a58ed 100644
--- a/csharp/src/AppHost/AppHost.csproj
+++ b/csharp/src/AppHost/AppHost.csproj
@@ -26,6 +26,7 @@
     <ProjectReference Include="..\API\API.csproj" />
     <ProjectReference Include="..\StationAPI\StationAPI.csproj" />
     <ProjectReference Include="..\Workflow.EVM\Workflow.EVM.csproj" />
+    <ProjectReference Include="..\Workflow.Solana\Workflow.Solana.csproj" />
     <ProjectReference Include="..\Workflow.Swap\Workflow.Swap.csproj" />
     <ProjectReference Include="..\Workflow.Tron\Workflow.Tron.csproj" />
   </ItemGroup>
diff --git a/csharp/src/Workflow.Solana/Activities/ISolanaBlockchainActivities.cs b/csharp/src/Workflow.Solana/Activities/ISolanaBlockchainActivities.cs
new file mode 100644
index 00000000..2535dde7
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Activities/ISolanaBlockchainActivities.cs
@@ -0,0 +1,64 @@
+using System.Numerics;
+using Temporalio.Activities;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Solana.Models;
+
+namespace Train.Solver.Workflow.Solana.Activities;
+
+public interface ISolanaBlockchainActivities
+{
+    [Activity]
+    Task<string> GenerateAddressAsync(GenerateAddressRequest request);
+
+    [Activity]
+    Task<BigInteger> GetBalanceAsync(SolanaBalanceRequest request);
+
+    [Activity]
+    Task<Dictionary<string, BigInteger>> GetBatchBalancesAsync(string nodeUrl, string address, List<string> tokenContracts);
+
+    [Activity]
+    Task<ulong> GetSlotAsync(string nodeUrl);
+
+    [Activity]
+    Task<bool> ValidateAddressAsync(string address);
+
+    [Activity]
+    Task<List<SolanaSignatureStatus>> GetSignatureStatusesAsync(SolanaGetSignatureStatusRequest request);
+
+    // Blockhash and priority fees
+    [Activity]
+    Task<SolanaBlockhashInfo> GetLatestBlockhashAsync(string nodeUrl);
+
+    [Activity]
+    Task<ulong> GetRecentPriorityFeeAsync(SolanaGetPriorityFeeRequest request);
+
+    [Activity]
+    Task<ulong> GetBlockHeightAsync(string nodeUrl);
+
+    // Transaction building + publishing
+    [Activity]
+    Task<string> BuildTransferTransactionAsync(SolanaBuildTransferRequest request);
+
+    [Activity]
+    Task<string> SignTransactionAsync(SolanaSignRequest request);
+
+    [Activity]
+    Task<SolanaPublishResult> PublishTransactionAsync(SolanaPublishRequest request);
+
+    // HTLC transaction building
+    [Activity]
+    Task<string> BuildHTLCLockTransactionAsync(SolanaBuildHTLCLockRequest request);
+
+    [Activity]
+    Task<string> BuildHTLCRedeemTransactionAsync(SolanaBuildHTLCRedeemRequest request);
+
+    [Activity]
+    Task<string> BuildHTLCRefundTransactionAsync(SolanaBuildHTLCRefundRequest request);
+
+    [Activity]
+    Task<SolanaHTLCAccount?> GetHTLCAccountDataAsync(SolanaGetHTLCAccountRequest request);
+
+    // HTLC event detection
+    [Activity]
+    Task<SolanaHTLCEventResult> GetHTLCEventsAsync(SolanaGetHTLCEventsRequest request);
+}
diff --git a/csharp/src/Workflow.Solana/Activities/ISolanaWorkflowActivities.cs b/csharp/src/Workflow.Solana/Activities/ISolanaWorkflowActivities.cs
new file mode 100644
index 00000000..b9afdf18
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Activities/ISolanaWorkflowActivities.cs
@@ -0,0 +1,20 @@
+using Temporalio.Activities;
+using Train.Solver.Workflow.Solana.Models;
+
+namespace Train.Solver.Workflow.Solana.Activities;
+
+public interface ISolanaWorkflowActivities
+{
+    [Activity]
+    Task<SolanaTransactionProcessorSnapshot?> LoadTransactionStateAsync(string networkSlug, string walletAddress);
+
+    [Activity]
+    Task SaveTransactionStateAsync(string networkSlug, string walletAddress, SolanaTransactionProcessorSnapshot snapshot);
+
+    // Listener checkpoint
+    [Activity]
+    Task<SolanaListenerCheckpoint?> GetListenerCheckpointAsync(string networkSlug, string listenerType);
+
+    [Activity]
+    Task SaveListenerCheckpointAsync(string networkSlug, string listenerType, SolanaListenerCheckpoint checkpoint);
+}
diff --git a/csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs b/csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs
new file mode 100644
index 00000000..cfb3f6d7
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs
@@ -0,0 +1,857 @@
+using System.Net.Http.Json;
+using System.Numerics;
+using System.Text.Json;
+using Microsoft.Extensions.Logging;
+using Solnet.Programs;
+using Solnet.Rpc;
+using Solnet.Rpc.Builders;
+using Solnet.Wallet;
+using Solnet.Wallet.Utilities;
+using Temporalio.Activities;
+using Temporalio.Exceptions;
+using Train.Solver.Infrastrucutre.Secret.Treasury.Client;
+using Train.Solver.Infrastrucutre.Secret.Treasury.Models;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Solana.Helpers;
+using Train.Solver.Workflow.Solana.Models;
+
+namespace Train.Solver.Workflow.Solana.Activities;
+
+public class SolanaBlockchainActivities(
+    ILogger<SolanaBlockchainActivities> logger) : ISolanaBlockchainActivities
+{
+    private const string NetworkType = "solana";
+    private const ulong DefaultPriorityFeeFloor = 1000; // microLamports
+
+    [Activity]
+    public virtual async Task<string> GenerateAddressAsync(GenerateAddressRequest request)
+    {
+        var client = TreasuryClientFactory.Create(request.SignerAgentUrl);
+        var response = await client.GenerateAddressAsync(NetworkType);
+
+        if (!response.IsSuccessStatusCode || response.Content == null)
+            throw new ApplicationFailureException(
+                $"Treasury generate address failed: {response.Error?.Content}", nonRetryable: true);
+
+        return response.Content.Address;
+    }
+
+    [Activity]
+    public virtual async Task<BigInteger> GetBalanceAsync(SolanaBalanceRequest request)
+    {
+        var rpcClient = ClientFactory.GetClient(request.NodeUrl);
+
+        if (SolanaHelper.IsNativeToken(request.TokenContract))
+        {
+            var result = await rpcClient.GetBalanceAsync(request.Address);
+            if (!result.WasRequestSuccessfullyHandled)
+                throw new Exception($"GetBalance failed: {result.Reason}");
+
+            return new BigInteger(result.Result.Value);
+        }
+
+        // SPL token balance
+        var tokenAccounts = await rpcClient.GetTokenAccountsByOwnerAsync(
+            request.Address, request.TokenContract);
+
+        if (!tokenAccounts.WasRequestSuccessfullyHandled)
+            throw new Exception($"GetTokenAccountsByOwner failed: {tokenAccounts.Reason}");
+
+        if (tokenAccounts.Result?.Value == null || tokenAccounts.Result.Value.Count == 0)
+            return BigInteger.Zero;
+
+        // Sum all token accounts for this mint
+        var totalBalance = BigInteger.Zero;
+        foreach (var account in tokenAccounts.Result.Value)
+        {
+            if (account.Account?.Data?.Parsed?.Info?.TokenAmount?.Amount != null)
+            {
+                if (BigInteger.TryParse(account.Account.Data.Parsed.Info.TokenAmount.Amount, out var amount))
+                    totalBalance += amount;
+            }
+        }
+
+        return totalBalance;
+    }
+
+    [Activity]
+    public virtual async Task<Dictionary<string, BigInteger>> GetBatchBalancesAsync(
+        string nodeUrl, string address, List<string> tokenContracts)
+    {
+        var result = new Dictionary<string, BigInteger>();
+
+        foreach (var tokenContract in tokenContracts)
+        {
+            try
+            {
+                var balance = await GetBalanceAsync(new SolanaBalanceRequest
+                {
+                    NodeUrl = nodeUrl,
+                    Address = address,
+                    TokenContract = tokenContract
+                });
+                result[tokenContract] = balance;
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to get balance for {Token} on {Address}", tokenContract, address);
+                result[tokenContract] = BigInteger.Zero;
+            }
+        }
+
+        return result;
+    }
+
+    [Activity]
+    public virtual async Task<ulong> GetSlotAsync(string nodeUrl)
+    {
+        var rpcClient = ClientFactory.GetClient(nodeUrl);
+        var result = await rpcClient.GetSlotAsync();
+
+        if (!result.WasRequestSuccessfullyHandled)
+            throw new Exception($"GetSlot failed: {result.Reason}");
+
+        return result.Result;
+    }
+
+    [Activity]
+    public virtual Task<bool> ValidateAddressAsync(string address)
+    {
+        return Task.FromResult(SolanaHelper.IsValidSolanaAddress(address));
+    }
+
+    [Activity]
+    public virtual async Task<List<SolanaSignatureStatus>> GetSignatureStatusesAsync(
+        SolanaGetSignatureStatusRequest request)
+    {
+        var rpcClient = ClientFactory.GetClient(request.NodeUrl);
+        var result = await rpcClient.GetSignatureStatusesAsync(request.TxSignatures, searchTransactionHistory: true);
+
+        if (!result.WasRequestSuccessfullyHandled)
+            throw new Exception($"GetSignatureStatuses failed: {result.Reason}");
+
+        var statuses = new List<SolanaSignatureStatus>();
+        for (var i = 0; i < request.TxSignatures.Count; i++)
+        {
+            var statusInfo = result.Result?.Value?[i];
+            statuses.Add(new SolanaSignatureStatus
+            {
+                TxSignature = request.TxSignatures[i],
+                Confirmed = statusInfo?.ConfirmationStatus == "confirmed" ||
+                            statusInfo?.ConfirmationStatus == "finalized",
+                Failed = statusInfo?.Error != null,
+                ErrorMessage = statusInfo?.Error?.Type.ToString(),
+                Slot = statusInfo?.Slot
+            });
+        }
+
+        return statuses;
+    }
+
+    #region Blockhash & Priority Fees
+
+    [Activity]
+    public virtual async Task<SolanaBlockhashInfo> GetLatestBlockhashAsync(string nodeUrl)
+    {
+        var rpcClient = ClientFactory.GetClient(nodeUrl);
+        var result = await rpcClient.GetLatestBlockHashAsync();
+
+        if (!result.WasRequestSuccessfullyHandled)
+            throw new Exception($"GetLatestBlockHash failed: {result.Reason}");
+
+        return new SolanaBlockhashInfo
+        {
+            Blockhash = result.Result.Value.Blockhash,
+            LastValidBlockHeight = result.Result.Value.LastValidBlockHeight
+        };
+    }
+
+    [Activity]
+    public virtual async Task<ulong> GetRecentPriorityFeeAsync(SolanaGetPriorityFeeRequest request)
+    {
+        // getRecentPrioritizationFees is not in SolNet SDK — use raw HTTP JSON-RPC
+        using var httpClient = new HttpClient();
+        var rpcPayload = new
+        {
+            jsonrpc = "2.0",
+            id = 1,
+            method = "getRecentPrioritizationFees",
+            @params = request.AccountKeys.Count > 0
+                ? new object[] { request.AccountKeys }
+                : Array.Empty<object>()
+        };
+
+        var response = await httpClient.PostAsJsonAsync(request.NodeUrl, rpcPayload);
+        response.EnsureSuccessStatusCode();
+
+        var json = await response.Content.ReadFromJsonAsync<JsonElement>();
+
+        if (json.TryGetProperty("error", out var error))
+        {
+            logger.LogWarning("getRecentPrioritizationFees error: {Error}", error.ToString());
+            return DefaultPriorityFeeFloor;
+        }
+
+        if (!json.TryGetProperty("result", out var resultArray) || resultArray.ValueKind != JsonValueKind.Array)
+            return DefaultPriorityFeeFloor;
+
+        // Collect non-zero fees and return 75th percentile
+        var fees = new List<ulong>();
+        foreach (var entry in resultArray.EnumerateArray())
+        {
+            if (entry.TryGetProperty("prioritizationFee", out var feeElement))
+            {
+                var fee = feeElement.GetUInt64();
+                if (fee > 0)
+                    fees.Add(fee);
+            }
+        }
+
+        if (fees.Count == 0)
+            return DefaultPriorityFeeFloor;
+
+        fees.Sort();
+        var p75Index = (int)Math.Ceiling(fees.Count * 0.75) - 1;
+        var p75Fee = fees[Math.Max(0, p75Index)];
+
+        return Math.Max(p75Fee, DefaultPriorityFeeFloor);
+    }
+
+    [Activity]
+    public virtual async Task<ulong> GetBlockHeightAsync(string nodeUrl)
+    {
+        var rpcClient = ClientFactory.GetClient(nodeUrl);
+        var result = await rpcClient.GetBlockHeightAsync();
+
+        if (!result.WasRequestSuccessfullyHandled)
+            throw new Exception($"GetBlockHeight failed: {result.Reason}");
+
+        return result.Result;
+    }
+
+    #endregion
+
+    #region Transaction Building + Publishing
+
+    [Activity]
+    public virtual Task<string> BuildTransferTransactionAsync(SolanaBuildTransferRequest request)
+    {
+        var fromPubkey = new PublicKey(request.FromAddress);
+        var toPubkey = new PublicKey(request.ToAddress);
+
+        var builder = new TransactionBuilder()
+            .SetFeePayer(fromPubkey)
+            .SetRecentBlockHash(request.RecentBlockhash);
+
+        // Add ComputeBudget instructions before the transfer
+        builder.AddInstruction(SolanaHelper.SetComputeUnitLimit(request.ComputeUnitLimit));
+
+        if (request.PriorityFeeMicroLamports > 0)
+            builder.AddInstruction(SolanaHelper.SetComputeUnitPrice(request.PriorityFeeMicroLamports));
+
+        if (SolanaHelper.IsNativeToken(request.TokenContract))
+        {
+            // Native SOL transfer
+            builder.AddInstruction(SystemProgram.Transfer(
+                fromPubkey, toPubkey, (ulong)request.Amount));
+        }
+        else
+        {
+            // SPL token transfer — not yet implemented
+            throw new NotSupportedException("SPL token transfers are not yet supported on Solana. Only native SOL transfers are available.");
+        }
+
+        // Build unsigned transaction
+        var messageBytes = builder.CompileMessage();
+        var unsignedTx = BuildUnsignedTransaction(messageBytes, 1); // 1 signer: fee payer
+
+        return Task.FromResult(Convert.ToBase64String(unsignedTx));
+    }
+
+    [Activity]
+    public virtual async Task<string> SignTransactionAsync(SolanaSignRequest request)
+    {
+        var client = TreasuryClientFactory.Create(request.SignerAgentUrl);
+        var response = await client.SignTransactionAsync(NetworkType, new SignTransactionRequestModel
+        {
+            Address = request.WalletAddress,
+            UnsignedTxn = request.UnsignedTxBase64
+        });
+
+        if (!response.IsSuccessStatusCode || response.Content == null)
+            throw new ApplicationFailureException(
+                $"Treasury sign failed: {response.Error?.Content}", nonRetryable: true);
+
+        return response.Content.SignedTxn;
+    }
+
+    [Activity]
+    public virtual async Task<SolanaPublishResult> PublishTransactionAsync(SolanaPublishRequest request)
+    {
+        var rpcClient = ClientFactory.GetClient(request.NodeUrl);
+
+        try
+        {
+            var result = await rpcClient.SendTransactionAsync(
+                request.SignedTxBase64,
+                skipPreflight: false);
+
+            if (result.WasRequestSuccessfullyHandled)
+            {
+                return new SolanaPublishResult
+                {
+                    Outcome = SolanaPublishOutcome.Published,
+                    TxSignature = result.Result
+                };
+            }
+
+            var outcome = SolanaHelper.ClassifyError(result.Reason);
+            return new SolanaPublishResult
+            {
+                Outcome = outcome,
+                ErrorMessage = result.Reason
+            };
+        }
+        catch (Exception ex)
+        {
+            var outcome = SolanaHelper.ClassifyError(ex.Message);
+            return new SolanaPublishResult
+            {
+                Outcome = outcome,
+                ErrorMessage = ex.Message
+            };
+        }
+    }
+
+    #endregion
+
+    #region HTLC Transaction Building
+
+    [Activity]
+    public virtual Task<string> BuildHTLCLockTransactionAsync(SolanaBuildHTLCLockRequest request)
+    {
+        var senderPubkey = new PublicKey(request.SenderAddress);
+        var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
+        var systemProgramPubkey = new PublicKey(SolanaHelper.SystemProgramId);
+
+        // Derive PDA from Id (= hashlock for lock())
+        PublicKey.TryFindProgramAddress(
+            [request.Hashlock],
+            programPubkey,
+            out var htlcPda,
+            out _);
+
+        // Build instruction data
+        var instructionData = SolanaAnchorHelper.BuildLockInstructionData(
+            request.Hashlock,
+            request.Timelock,
+            request.Amount,
+            request.DstChain,
+            request.DstAddress,
+            request.DstAsset,
+            request.SrcAsset,
+            request.SrcReceiver);
+
+        // Account metas: sender(signer,mut), htlc(init,mut,PDA), system_program, rent
+        var rentPubkey = new PublicKey("SysvarRent111111111111111111111111111111111");
+        var keys = new List<Solnet.Rpc.Models.AccountMeta>
+        {
+            Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, true),
+            Solnet.Rpc.Models.AccountMeta.Writable(htlcPda, false),
+            Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
+            Solnet.Rpc.Models.AccountMeta.ReadOnly(rentPubkey, false)
+        };
+        var htlcInstruction = Solnet.Rpc.Builders.TransactionInstructionFactory.Create(programPubkey, keys, instructionData);
+
+        var builder = new TransactionBuilder()
+            .SetFeePayer(senderPubkey)
+            .SetRecentBlockHash(request.RecentBlockhash);
+
+        builder.AddInstruction(SolanaHelper.SetComputeUnitLimit(request.ComputeUnitLimit));
+        if (request.PriorityFeeMicroLamports > 0)
+            builder.AddInstruction(SolanaHelper.SetComputeUnitPrice(request.PriorityFeeMicroLamports));
+        builder.AddInstruction(htlcInstruction);
+
+        var messageBytes = builder.CompileMessage();
+        var unsignedTx = BuildUnsignedTransaction(messageBytes, 1);
+        return Task.FromResult(Convert.ToBase64String(unsignedTx));
+    }
+
+    [Activity]
+    public virtual Task<string> BuildHTLCRedeemTransactionAsync(SolanaBuildHTLCRedeemRequest request)
+    {
+        var signerPubkey = new PublicKey(request.SignerAddress);
+        var senderPubkey = new PublicKey(request.SenderAddress);
+        var srcReceiverPubkey = new PublicKey(request.SrcReceiverAddress);
+        var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
+        var systemProgramPubkey = new PublicKey(SolanaHelper.SystemProgramId);
+
+        // Derive PDA from Id
+        PublicKey.TryFindProgramAddress(
+            [request.Id],
+            programPubkey,
+            out var htlcPda,
+            out _);
+
+        var instructionData = SolanaAnchorHelper.BuildRedeemInstructionData(request.Id, request.Secret);
+
+        // Account metas: user_signing(signer,mut), sender(unchecked,mut), src_receiver(unchecked,mut), htlc(mut,PDA), system_program, rent
+        var rentPubkey = new PublicKey("SysvarRent111111111111111111111111111111111");
+        var keys = new List<Solnet.Rpc.Models.AccountMeta>
+        {
+            Solnet.Rpc.Models.AccountMeta.Writable(signerPubkey, true),
+            Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, false),
+            Solnet.Rpc.Models.AccountMeta.Writable(srcReceiverPubkey, false),
+            Solnet.Rpc.Models.AccountMeta.Writable(htlcPda, false),
+            Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
+            Solnet.Rpc.Models.AccountMeta.ReadOnly(rentPubkey, false)
+        };
+        var htlcInstruction = Solnet.Rpc.Builders.TransactionInstructionFactory.Create(programPubkey, keys, instructionData);
+
+        var builder = new TransactionBuilder()
+            .SetFeePayer(signerPubkey)
+            .SetRecentBlockHash(request.RecentBlockhash);
+
+        builder.AddInstruction(SolanaHelper.SetComputeUnitLimit(request.ComputeUnitLimit));
+        if (request.PriorityFeeMicroLamports > 0)
+            builder.AddInstruction(SolanaHelper.SetComputeUnitPrice(request.PriorityFeeMicroLamports));
+        builder.AddInstruction(htlcInstruction);
+
+        var messageBytes = builder.CompileMessage();
+        var unsignedTx = BuildUnsignedTransaction(messageBytes, 1);
+        return Task.FromResult(Convert.ToBase64String(unsignedTx));
+    }
+
+    [Activity]
+    public virtual Task<string> BuildHTLCRefundTransactionAsync(SolanaBuildHTLCRefundRequest request)
+    {
+        var signerPubkey = new PublicKey(request.SignerAddress);
+        var senderPubkey = new PublicKey(request.SenderAddress);
+        var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
+        var systemProgramPubkey = new PublicKey(SolanaHelper.SystemProgramId);
+
+        // Derive PDA from Id
+        PublicKey.TryFindProgramAddress(
+            [request.Id],
+            programPubkey,
+            out var htlcPda,
+            out _);
+
+        var instructionData = SolanaAnchorHelper.BuildRefundInstructionData(request.Id);
+
+        // Account metas: user_signing(signer,mut), htlc(mut,PDA), sender(unchecked,mut), system_program, rent
+        var rentPubkey = new PublicKey("SysvarRent111111111111111111111111111111111");
+        var keys = new List<Solnet.Rpc.Models.AccountMeta>
+        {
+            Solnet.Rpc.Models.AccountMeta.Writable(signerPubkey, true),
+            Solnet.Rpc.Models.AccountMeta.Writable(htlcPda, false),
+            Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, false),
+            Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
+            Solnet.Rpc.Models.AccountMeta.ReadOnly(rentPubkey, false)
+        };
+        var htlcInstruction = Solnet.Rpc.Builders.TransactionInstructionFactory.Create(programPubkey, keys, instructionData);
+
+        var builder = new TransactionBuilder()
+            .SetFeePayer(signerPubkey)
+            .SetRecentBlockHash(request.RecentBlockhash);
+
+        builder.AddInstruction(SolanaHelper.SetComputeUnitLimit(request.ComputeUnitLimit));
+        if (request.PriorityFeeMicroLamports > 0)
+            builder.AddInstruction(SolanaHelper.SetComputeUnitPrice(request.PriorityFeeMicroLamports));
+        builder.AddInstruction(htlcInstruction);
+
+        var messageBytes = builder.CompileMessage();
+        var unsignedTx = BuildUnsignedTransaction(messageBytes, 1);
+        return Task.FromResult(Convert.ToBase64String(unsignedTx));
+    }
+
+    [Activity]
+    public virtual async Task<SolanaHTLCAccount?> GetHTLCAccountDataAsync(SolanaGetHTLCAccountRequest request)
+    {
+        var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
+
+        PublicKey.TryFindProgramAddress(
+            [request.Id],
+            programPubkey,
+            out var htlcPda,
+            out _);
+
+        if (htlcPda == null)
+            return null;
+
+        using var httpClient = new HttpClient();
+        var accountData = await GetAccountData(httpClient, request.NodeUrl, htlcPda.Key);
+        if (accountData == null || accountData.Length < 8)
+            return null;
+
+        if (!SolanaAnchorHelper.MatchesDiscriminator(accountData, SolanaAnchorHelper.HTLCAccountDiscriminator))
+            return null;
+
+        return SolanaAnchorHelper.ParseHTLCAccount(accountData);
+    }
+
+    #endregion
+
+    #region HTLC Event Detection
+
+    [Activity]
+    public virtual async Task<SolanaHTLCEventResult> GetHTLCEventsAsync(SolanaGetHTLCEventsRequest request)
+    {
+        using var httpClient = new HttpClient();
+        var result = new SolanaHTLCEventResult();
+
+        // 1. Get recent signatures for the HTLC program
+        var signatures = await GetSignaturesForAddress(httpClient, request.NodeUrl,
+            request.ProgramId, request.LastSignature);
+
+        if (signatures.Count == 0)
+            return result;
+
+        // 2. Reverse to process oldest-first
+        signatures.Reverse();
+
+        string? lastSig = null;
+        ulong lastSlot = 0;
+
+        // 3. For each signature, fetch and parse the transaction
+        foreach (var sigInfo in signatures)
+        {
+            var sig = sigInfo.GetProperty("signature").GetString()!;
+            var slot = sigInfo.GetProperty("slot").GetUInt64();
+
+            // Skip failed transactions
+            if (sigInfo.TryGetProperty("err", out var err) && err.ValueKind != JsonValueKind.Null)
+                continue;
+
+            lastSig = sig;
+            lastSlot = slot;
+
+            try
+            {
+                await ProcessTransaction(httpClient, request, sig, slot, result);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to process Solana tx {Signature}", sig);
+            }
+        }
+
+        result = result with
+        {
+            LastProcessedSignature = lastSig ?? request.LastSignature,
+            LastProcessedSlot = lastSlot
+        };
+
+        return result;
+    }
+
+    private async Task ProcessTransaction(
+        HttpClient httpClient,
+        SolanaGetHTLCEventsRequest request,
+        string signature,
+        ulong slot,
+        SolanaHTLCEventResult result)
+    {
+        var txResult = await GetTransaction(httpClient, request.NodeUrl, signature);
+        if (txResult is not { } tx) return;
+
+        // Find the instruction targeting the HTLC program
+        if (!tx.TryGetProperty("transaction", out var transaction)) return;
+        if (!transaction.TryGetProperty("message", out var message)) return;
+        if (!message.TryGetProperty("accountKeys", out var accountKeys)) return;
+
+        var programIndex = FindProgramIndex(accountKeys, request.ProgramId);
+        if (programIndex < 0) return;
+
+        // Check inner instructions and top-level instructions
+        if (!transaction.TryGetProperty("message", out _)) return;
+
+        var instructions = message.TryGetProperty("instructions", out var instrs)
+            ? instrs : default;
+
+        foreach (var instr in instructions.EnumerateArray())
+        {
+            if (!instr.TryGetProperty("programIdIndex", out var pidIdx) ||
+                pidIdx.GetInt32() != programIndex)
+                continue;
+
+            if (!instr.TryGetProperty("data", out var dataElement)) continue;
+
+            var dataBase58 = dataElement.GetString();
+            if (string.IsNullOrEmpty(dataBase58)) continue;
+
+            byte[] instructionData;
+            try
+            {
+                instructionData = Encoders.Base58.DecodeData(dataBase58);
+            }
+            catch
+            {
+                continue;
+            }
+
+            var functionName = SolanaAnchorHelper.IdentifyFunction(instructionData);
+            if (functionName == null) continue;
+
+            // Read the HTLC PDA account from the transaction's account list
+            var htlcAccount = await TryGetHTLCAccountFromTx(
+                httpClient, request.NodeUrl, instr, accountKeys, request.ProgramId);
+
+            if (htlcAccount == null)
+            {
+                logger.LogDebug("Could not read HTLC account for {Function} in tx {Sig}", functionName, signature);
+                continue;
+            }
+
+            var isSolverWallet = request.SolverWalletAddresses
+                .Any(w => string.Equals(w, htlcAccount.Sender, StringComparison.OrdinalIgnoreCase));
+
+            switch (functionName)
+            {
+                case "lock":
+                    // lock() is always called by solver
+                    result.LockedEvents.Add(new SolanaHTLCLockedEvent
+                    {
+                        TxSignature = signature,
+                        Slot = slot,
+                        Hashlock = htlcAccount.Hashlock,
+                        Sender = htlcAccount.Sender,
+                        SrcReceiver = htlcAccount.SrcReceiver,
+                        Amount = htlcAccount.Amount,
+                        Reward = htlcAccount.Reward,
+                        Timelock = htlcAccount.Timelock,
+                        RewardTimelock = htlcAccount.RewardTimelock,
+                        DstAddress = htlcAccount.DstAddress,
+                        DstChain = htlcAccount.DstChain,
+                        DstAsset = htlcAccount.DstAsset,
+                        SrcAsset = htlcAccount.SrcAsset,
+                        IsUserLock = false
+                    });
+                    break;
+
+                case "add_lock":
+                case "add_lock_sig":
+                    // add_lock/add_lock_sig adds hashlock to user's commit — this is user lock
+                    result.LockedEvents.Add(new SolanaHTLCLockedEvent
+                    {
+                        TxSignature = signature,
+                        Slot = slot,
+                        Hashlock = htlcAccount.Hashlock,
+                        Sender = htlcAccount.Sender,
+                        SrcReceiver = htlcAccount.SrcReceiver,
+                        Amount = htlcAccount.Amount,
+                        Reward = htlcAccount.Reward,
+                        Timelock = htlcAccount.Timelock,
+                        RewardTimelock = htlcAccount.RewardTimelock,
+                        DstAddress = htlcAccount.DstAddress,
+                        DstChain = htlcAccount.DstChain,
+                        DstAsset = htlcAccount.DstAsset,
+                        SrcAsset = htlcAccount.SrcAsset,
+                        IsUserLock = true
+                    });
+                    break;
+
+                case "redeem":
+                    result.RedeemedEvents.Add(new SolanaHTLCRedeemedEvent
+                    {
+                        TxSignature = signature,
+                        Slot = slot,
+                        Hashlock = htlcAccount.Hashlock,
+                        Secret = htlcAccount.Secret,
+                        RedeemAddress = GetTransactionSigner(transaction),
+                        IsSolverLock = isSolverWallet
+                    });
+                    break;
+
+                case "refund":
+                    result.RefundedEvents.Add(new SolanaHTLCRefundedEvent
+                    {
+                        TxSignature = signature,
+                        Slot = slot,
+                        Hashlock = htlcAccount.Hashlock,
+                        IsSolverLock = isSolverWallet
+                    });
+                    break;
+
+                // commit and lock_reward are skipped (no hashlock / supplementary)
+            }
+        }
+    }
+
+    private async Task<List<JsonElement>> GetSignaturesForAddress(
+        HttpClient httpClient, string nodeUrl, string address, string? untilSignature)
+    {
+        var rpcParams = new Dictionary<string, object> { ["limit"] = 100 };
+        if (!string.IsNullOrEmpty(untilSignature))
+            rpcParams["until"] = untilSignature;
+
+        var rpcPayload = new
+        {
+            jsonrpc = "2.0",
+            id = 1,
+            method = "getSignaturesForAddress",
+            @params = new object[] { address, rpcParams }
+        };
+
+        var response = await httpClient.PostAsJsonAsync(nodeUrl, rpcPayload);
+        response.EnsureSuccessStatusCode();
+
+        var json = await response.Content.ReadFromJsonAsync<JsonElement>();
+
+        if (json.TryGetProperty("error", out var error))
+        {
+            logger.LogWarning("getSignaturesForAddress error: {Error}", error.ToString());
+            return [];
+        }
+
+        if (!json.TryGetProperty("result", out var resultArray) ||
+            resultArray.ValueKind != JsonValueKind.Array)
+            return [];
+
+        return resultArray.EnumerateArray().ToList();
+    }
+
+    private static async Task<JsonElement?> GetTransaction(
+        HttpClient httpClient, string nodeUrl, string signature)
+    {
+        var rpcPayload = new
+        {
+            jsonrpc = "2.0",
+            id = 1,
+            method = "getTransaction",
+            @params = new object[]
+            {
+                signature,
+                new { encoding = "json", maxSupportedTransactionVersion = 0 }
+            }
+        };
+
+        var response = await httpClient.PostAsJsonAsync(nodeUrl, rpcPayload);
+        response.EnsureSuccessStatusCode();
+
+        var json = await response.Content.ReadFromJsonAsync<JsonElement>();
+
+        if (json.TryGetProperty("error", out _))
+            return null;
+
+        if (!json.TryGetProperty("result", out var result) || result.ValueKind == JsonValueKind.Null)
+            return null;
+
+        return result;
+    }
+
+    private async Task<SolanaHTLCAccount?> TryGetHTLCAccountFromTx(
+        HttpClient httpClient, string nodeUrl,
+        JsonElement instruction, JsonElement accountKeys, string programId)
+    {
+        // The HTLC PDA is typically the first account in the instruction's accounts list
+        if (!instruction.TryGetProperty("accounts", out var accounts) ||
+            accounts.GetArrayLength() == 0)
+            return null;
+
+        // Try the first few accounts — the PDA is usually account[0] or account[1]
+        foreach (var accountIndex in accounts.EnumerateArray().Take(3))
+        {
+            var idx = accountIndex.GetInt32();
+            if (idx >= accountKeys.GetArrayLength()) continue;
+
+            var accountAddress = accountKeys[idx].GetString();
+            if (string.IsNullOrEmpty(accountAddress)) continue;
+
+            var accountData = await GetAccountData(httpClient, nodeUrl, accountAddress);
+            if (accountData == null || accountData.Length < 8) continue;
+
+            // Verify Anchor account discriminator
+            if (!SolanaAnchorHelper.MatchesDiscriminator(accountData, SolanaAnchorHelper.HTLCAccountDiscriminator))
+                continue;
+
+            var parsed = SolanaAnchorHelper.ParseHTLCAccount(accountData);
+            if (parsed != null)
+                return parsed;
+        }
+
+        return null;
+    }
+
+    private async Task<byte[]?> GetAccountData(HttpClient httpClient, string nodeUrl, string address)
+    {
+        var rpcPayload = new
+        {
+            jsonrpc = "2.0",
+            id = 1,
+            method = "getAccountInfo",
+            @params = new object[]
+            {
+                address,
+                new { encoding = "base64" }
+            }
+        };
+
+        var response = await httpClient.PostAsJsonAsync(nodeUrl, rpcPayload);
+        response.EnsureSuccessStatusCode();
+
+        var json = await response.Content.ReadFromJsonAsync<JsonElement>();
+
+        if (json.TryGetProperty("error", out _))
+            return null;
+
+        if (!json.TryGetProperty("result", out var result) || result.ValueKind == JsonValueKind.Null)
+            return null;
+
+        if (!result.TryGetProperty("value", out var value) || value.ValueKind == JsonValueKind.Null)
+            return null;
+
+        if (!value.TryGetProperty("data", out var data) || data.ValueKind != JsonValueKind.Array)
+            return null;
+
+        var base64Data = data[0].GetString();
+        if (string.IsNullOrEmpty(base64Data))
+            return null;
+
+        return Convert.FromBase64String(base64Data);
+    }
+
+    private static int FindProgramIndex(JsonElement accountKeys, string programId)
+    {
+        var index = 0;
+        foreach (var key in accountKeys.EnumerateArray())
+        {
+            if (string.Equals(key.GetString(), programId, StringComparison.Ordinal))
+                return index;
+            index++;
+        }
+        return -1;
+    }
+
+    private static string GetTransactionSigner(JsonElement transaction)
+    {
+        if (transaction.TryGetProperty("message", out var message) &&
+            message.TryGetProperty("accountKeys", out var keys) &&
+            keys.GetArrayLength() > 0)
+        {
+            return keys[0].GetString() ?? string.Empty;
+        }
+        return string.Empty;
+    }
+
+    #endregion
+
+    #region Helpers
+
+    /// <summary>
+    /// Builds an unsigned transaction with zero-byte signature placeholders.
+    /// Wire format: [compact-u16 sig count] [64 zero bytes per sig] [message bytes]
+    /// </summary>
+    private static byte[] BuildUnsignedTransaction(byte[] messageBytes, int signatureCount)
+    {
+        // Compact-u16 encoding for small numbers (< 128) is just the byte itself
+        var sigCountByte = (byte)signatureCount;
+        var result = new byte[1 + (signatureCount * 64) + messageBytes.Length];
+        result[0] = sigCountByte;
+        // Signature slots are already zeroed (default byte array)
+        Array.Copy(messageBytes, 0, result, 1 + (signatureCount * 64), messageBytes.Length);
+        return result;
+    }
+
+    #endregion
+}
diff --git a/csharp/src/Workflow.Solana/Activities/SolanaWorkflowActivities.cs b/csharp/src/Workflow.Solana/Activities/SolanaWorkflowActivities.cs
new file mode 100644
index 00000000..e2049ec1
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Activities/SolanaWorkflowActivities.cs
@@ -0,0 +1,80 @@
+using System.Text.Json;
+using Microsoft.Extensions.Logging;
+using StackExchange.Redis;
+using Temporalio.Activities;
+using Train.Solver.Workflow.Solana.Models;
+
+namespace Train.Solver.Workflow.Solana.Activities;
+
+public class SolanaWorkflowActivities(
+    IDatabase cache,
+    ILogger<SolanaWorkflowActivities> logger) : ISolanaWorkflowActivities
+{
+    private static readonly TimeSpan StateTtl = TimeSpan.FromDays(7);
+
+    [Activity]
+    public virtual async Task<SolanaTransactionProcessorSnapshot?> LoadTransactionStateAsync(
+        string networkSlug, string walletAddress)
+    {
+        var key = BuildStateKey(networkSlug, walletAddress);
+        var value = await cache.StringGetAsync(key);
+
+        if (value.IsNullOrEmpty)
+            return null;
+
+        try
+        {
+            return JsonSerializer.Deserialize<SolanaTransactionProcessorSnapshot>(value!);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to deserialize Solana TP state from Redis for {Key}", key);
+            return null;
+        }
+    }
+
+    [Activity]
+    public virtual async Task SaveTransactionStateAsync(
+        string networkSlug, string walletAddress, SolanaTransactionProcessorSnapshot snapshot)
+    {
+        var key = BuildStateKey(networkSlug, walletAddress);
+        var json = JsonSerializer.Serialize(snapshot);
+        await cache.StringSetAsync(key, json, StateTtl);
+    }
+
+    [Activity]
+    public virtual async Task<SolanaListenerCheckpoint?> GetListenerCheckpointAsync(
+        string networkSlug, string listenerType)
+    {
+        var key = BuildCheckpointKey(networkSlug, listenerType);
+        var value = await cache.StringGetAsync(key);
+
+        if (value.IsNullOrEmpty)
+            return null;
+
+        try
+        {
+            return JsonSerializer.Deserialize<SolanaListenerCheckpoint>(value!);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to deserialize Solana listener checkpoint from Redis for {Key}", key);
+            return null;
+        }
+    }
+
+    [Activity]
+    public virtual async Task SaveListenerCheckpointAsync(
+        string networkSlug, string listenerType, SolanaListenerCheckpoint checkpoint)
+    {
+        var key = BuildCheckpointKey(networkSlug, listenerType);
+        var json = JsonSerializer.Serialize(checkpoint);
+        await cache.StringSetAsync(key, json);
+    }
+
+    private static string BuildStateKey(string networkSlug, string walletAddress) =>
+        $"solana:tp-state:{networkSlug}:{walletAddress}";
+
+    private static string BuildCheckpointKey(string networkSlug, string listenerType) =>
+        $"solana:checkpoint:{networkSlug}:{listenerType}";
+}
diff --git a/csharp/src/Workflow.Solana/Activities/WorkflowActivities.cs b/csharp/src/Workflow.Solana/Activities/WorkflowActivities.cs
new file mode 100644
index 00000000..ebe1834d
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Activities/WorkflowActivities.cs
@@ -0,0 +1,111 @@
+using System.Numerics;
+using Temporalio.Activities;
+using Temporalio.Client;
+using Temporalio.Exceptions;
+using Train.Solver.Workflow.Abstractions.Activities;
+using Train.Solver.Workflow.Abstractions.Models;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Common.Helpers;
+
+namespace Train.Solver.Workflow.Solana.Activities;
+
+public class WorkflowActivities(ITemporalClient temporalClient) : IWorkflowActivities
+{
+    [Activity]
+    public virtual async Task<bool> StartWorkflowAsync(StartWorkflowRequest request)
+    {
+        try
+        {
+            await temporalClient.StartWorkflowAsync(
+                request.WorkflowType,
+                request.Args ?? [],
+                new WorkflowOptions(request.WorkflowId, request.TaskQueue));
+            return true;
+        }
+        catch (WorkflowAlreadyStartedException)
+        {
+            return false;
+        }
+    }
+
+    [Activity]
+    public virtual async Task CancelWorkflowAsync(string workflowId)
+    {
+        try
+        {
+            var handle = temporalClient.GetWorkflowHandle(workflowId);
+            await handle.CancelAsync();
+        }
+        catch (RpcException)
+        {
+            // Workflow may not exist or already cancelled
+        }
+    }
+
+    [Activity]
+    public virtual async Task<BigInteger> GetBalanceViaRuntimeAsync(RuntimeBalanceRequest request)
+    {
+        var runtimeId = TemporalHelper.BuildNetworkRuntimeId(request.NetworkSlug);
+        var handle = temporalClient.GetWorkflowHandle<INetworkRuntime>(runtimeId);
+
+        var response = await handle.ExecuteUpdateAsync(
+            wf => wf.GetBalanceAsync(new GetBalanceRequest
+            {
+                Address = request.Address,
+                TokenContract = request.TokenContract
+            }));
+
+        return response.Balance;
+    }
+
+    [Activity]
+    public virtual async Task<ValidateAddressResponse> ValidateAddressViaRuntimeAsync(RuntimeValidateAddressRequest request)
+    {
+        var runtimeId = TemporalHelper.BuildNetworkRuntimeId(request.NetworkSlug);
+        var handle = temporalClient.GetWorkflowHandle<INetworkRuntime>(runtimeId);
+
+        return await handle.ExecuteUpdateAsync(
+            wf => wf.ValidateAddressAsync(request.Address));
+    }
+
+    [Activity]
+    public virtual async Task<ValidateNodeResponse> ValidateNodeViaRuntimeAsync(RuntimeValidateNodeRequest request)
+    {
+        var runtimeId = TemporalHelper.BuildNetworkRuntimeId(request.NetworkSlug);
+        var handle = temporalClient.GetWorkflowHandle<INetworkRuntime>(runtimeId);
+
+        return await handle.ExecuteUpdateAsync(
+            wf => wf.ValidateNodeAsync(new ValidateNodeRequest
+            {
+                NodeUrl = request.NodeUrl
+            }));
+    }
+
+    [Activity]
+    public virtual async Task<GetBatchBalancesResponse> GetBatchBalancesViaRuntimeAsync(RuntimeBatchBalancesRequest request)
+    {
+        var runtimeId = TemporalHelper.BuildNetworkRuntimeId(request.NetworkSlug);
+        var handle = temporalClient.GetWorkflowHandle<INetworkRuntime>(runtimeId);
+
+        return await handle.ExecuteUpdateAsync(
+            wf => wf.GetBatchBalancesAsync(new GetBatchBalancesRequest
+            {
+                Address = request.Address,
+                TokenContracts = request.TokenContracts
+            }));
+    }
+
+    [Activity]
+    public virtual async Task<TransactionResponse> GetTransactionViaRuntimeAsync(RuntimeGetTransactionRequest request)
+    {
+        var runtimeId = TemporalHelper.BuildNetworkRuntimeId(request.NetworkSlug);
+        var handle = temporalClient.GetWorkflowHandle<INetworkRuntime>(runtimeId);
+
+        return await handle.ExecuteUpdateAsync(
+            wf => wf.GetTransactionAsync(new GetTransactionRequest
+            {
+                NetworkSlug = request.NetworkSlug,
+                TransactionHash = request.TransactionHash
+            }));
+    }
+}
diff --git a/csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs b/csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs
new file mode 100644
index 00000000..2c6ef3c1
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs
@@ -0,0 +1,38 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using StackExchange.Redis;
+using Temporalio.Extensions.Hosting;
+using Temporalio.Worker;
+using Train.Solver.Infrastructure.DependencyInjection;
+using Train.Solver.Workflow.Solana.Activities;
+using Train.Solver.Workflow.Solana.Workflows;
+
+namespace Train.Solver.Workflow.Solana.Extensions;
+
+public static class TrainSolverBuilderExtensions
+{
+    public static TrainSolverBuilder WithSolanaWorkflows(this TrainSolverBuilder builder)
+    {
+        builder.Services
+            .AddHostedTemporalWorker(builder.Options.NetworkType)
+            .ConfigureOptions(opts =>
+            {
+                opts.WorkflowStackTrace = WorkflowStackTrace.Normal;
+            })
+            .AddWorkflow<SolanaNetworkRuntime>()
+            .AddWorkflow<SolanaAddressGenerator>()
+            .AddWorkflow<SolanaTransactionProcessor>()
+            .AddWorkflow<SolanaRPCEventListener>()
+            .AddTransientActivities<SolanaBlockchainActivities>()
+            .AddTransientActivities<SolanaWorkflowActivities>()
+            .AddTransientActivities<WorkflowActivities>();
+
+        // Redis dependencies (IConnectionMultiplexer + IDatabase) — used for TP state persistence
+        builder.Services.TryAddSingleton<IConnectionMultiplexer>(
+            _ => ConnectionMultiplexer.Connect(builder.Options.RedisConnectionString));
+        builder.Services.TryAddTransient<IDatabase>(
+            sp => sp.GetRequiredService<IConnectionMultiplexer>().GetDatabase(builder.Options.RedisDatabaseIndex));
+
+        return builder;
+    }
+}
diff --git a/csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs b/csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs
new file mode 100644
index 00000000..8fe04f2e
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs
@@ -0,0 +1,247 @@
+using System.Security.Cryptography;
+using System.Text;
+using Solnet.Wallet;
+using Train.Solver.Workflow.Solana.Models;
+
+namespace Train.Solver.Workflow.Solana.Helpers;
+
+/// <summary>
+/// Anchor instruction discriminator computation and HTLC account parsing.
+/// Discriminator = sha256("global:{function_name}")[..8]
+/// </summary>
+public static class SolanaAnchorHelper
+{
+    // Anchor account discriminator for HTLC struct: sha256("account:HTLC")[..8]
+    public static readonly byte[] HTLCAccountDiscriminator = ComputeAccountDiscriminator("HTLC");
+
+    // Precomputed instruction discriminators
+    public static readonly byte[] CommitDiscriminator = ComputeDiscriminator("commit");
+    public static readonly byte[] LockDiscriminator = ComputeDiscriminator("lock");
+    public static readonly byte[] LockRewardDiscriminator = ComputeDiscriminator("lock_reward");
+    public static readonly byte[] AddLockDiscriminator = ComputeDiscriminator("add_lock");
+    public static readonly byte[] AddLockSigDiscriminator = ComputeDiscriminator("add_lock_sig");
+    public static readonly byte[] RedeemDiscriminator = ComputeDiscriminator("redeem");
+    public static readonly byte[] RefundDiscriminator = ComputeDiscriminator("refund");
+
+    public static byte[] ComputeDiscriminator(string functionName)
+    {
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes($"global:{functionName}"));
+        return hash[..8];
+    }
+
+    public static byte[] ComputeAccountDiscriminator(string accountName)
+    {
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes($"account:{accountName}"));
+        return hash[..8];
+    }
+
+    public static bool MatchesDiscriminator(byte[] instructionData, byte[] discriminator)
+    {
+        if (instructionData.Length < 8) return false;
+        return instructionData.AsSpan(0, 8).SequenceEqual(discriminator);
+    }
+
+    /// <summary>
+    /// Identifies which HTLC function was called from instruction data.
+    /// Returns null for unknown instructions.
+    /// </summary>
+    public static string? IdentifyFunction(byte[] instructionData)
+    {
+        if (instructionData.Length < 8) return null;
+
+        if (MatchesDiscriminator(instructionData, CommitDiscriminator)) return "commit";
+        if (MatchesDiscriminator(instructionData, LockDiscriminator)) return "lock";
+        if (MatchesDiscriminator(instructionData, LockRewardDiscriminator)) return "lock_reward";
+        if (MatchesDiscriminator(instructionData, AddLockDiscriminator)) return "add_lock";
+        if (MatchesDiscriminator(instructionData, AddLockSigDiscriminator)) return "add_lock_sig";
+        if (MatchesDiscriminator(instructionData, RedeemDiscriminator)) return "redeem";
+        if (MatchesDiscriminator(instructionData, RefundDiscriminator)) return "refund";
+
+        return null;
+    }
+
+    /// <summary>
+    /// Parses Anchor HTLC account data (after 8-byte account discriminator).
+    /// Layout matches the Rust struct with Borsh encoding:
+    ///   dst_address: String (4-byte len + utf8)
+    ///   dst_chain: String
+    ///   dst_asset: String
+    ///   src_asset: String
+    ///   sender: Pubkey (32 bytes)
+    ///   src_receiver: Pubkey (32 bytes)
+    ///   hashlock: [u8; 32]
+    ///   secret: [u8; 32]
+    ///   amount: u64 (8 bytes LE)
+    ///   reward: u64
+    ///   timelock: u64
+    ///   reward_timelock: u64
+    ///   claimed: u8
+    /// </summary>
+    public static SolanaHTLCAccount? ParseHTLCAccount(byte[] data)
+    {
+        try
+        {
+            var offset = 8; // Skip Anchor account discriminator
+
+            var dstAddress = ReadBorshString(data, ref offset);
+            var dstChain = ReadBorshString(data, ref offset);
+            var dstAsset = ReadBorshString(data, ref offset);
+            var srcAsset = ReadBorshString(data, ref offset);
+
+            var senderBytes = ReadBytes(data, ref offset, 32);
+            var srcReceiverBytes = ReadBytes(data, ref offset, 32);
+            var hashlockBytes = ReadBytes(data, ref offset, 32);
+            var secretBytes = ReadBytes(data, ref offset, 32);
+
+            var amount = BitConverter.ToUInt64(data, offset); offset += 8;
+            var reward = BitConverter.ToUInt64(data, offset); offset += 8;
+            var timelock = BitConverter.ToUInt64(data, offset); offset += 8;
+            var rewardTimelock = BitConverter.ToUInt64(data, offset); offset += 8;
+            var claimed = data[offset];
+
+            return new SolanaHTLCAccount
+            {
+                DstAddress = dstAddress,
+                DstChain = dstChain,
+                DstAsset = dstAsset,
+                SrcAsset = srcAsset,
+                Sender = new PublicKey(senderBytes).Key,
+                SrcReceiver = new PublicKey(srcReceiverBytes).Key,
+                Hashlock = Convert.ToHexString(hashlockBytes).ToLowerInvariant(),
+                Secret = Convert.ToHexString(secretBytes).ToLowerInvariant(),
+                Amount = amount,
+                Reward = reward,
+                Timelock = (long)timelock,
+                RewardTimelock = (long)rewardTimelock,
+                Claimed = claimed
+            };
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Derives the PDA address for an HTLC given its Id and program ID.
+    /// PDA = findProgramAddress([Id], programId)
+    /// </summary>
+    public static string? DerivePDA(byte[] id, string programId)
+    {
+        try
+        {
+            PublicKey.TryFindProgramAddress(
+                [id],
+                new PublicKey(programId),
+                out var pda,
+                out _);
+            return pda?.Key;
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    #region Borsh Write Helpers
+
+    public static void WriteBorshU64(List<byte> buf, ulong value)
+    {
+        Span<byte> tmp = stackalloc byte[8];
+        BitConverter.TryWriteBytes(tmp, value);
+        buf.AddRange(tmp.ToArray());
+    }
+
+    public static void WriteBorshString(List<byte> buf, string value)
+    {
+        var utf8 = Encoding.UTF8.GetBytes(value);
+        Span<byte> lenBytes = stackalloc byte[4];
+        BitConverter.TryWriteBytes(lenBytes, (uint)utf8.Length);
+        buf.AddRange(lenBytes.ToArray());
+        buf.AddRange(utf8);
+    }
+
+    public static void WriteBorshPubkey(List<byte> buf, string base58Pubkey)
+    {
+        var pk = new PublicKey(base58Pubkey);
+        buf.AddRange(pk.KeyBytes);
+    }
+
+    public static void WriteBorshBytes32(List<byte> buf, byte[] data)
+    {
+        if (data.Length != 32) throw new ArgumentException("Expected 32 bytes", nameof(data));
+        buf.AddRange(data);
+    }
+
+    #endregion
+
+    #region Instruction Data Builders
+
+    /// <summary>
+    /// Builds instruction data for lock(): discriminator + Id[32] + hashlock[32] + timelock(u64) + amount(u64)
+    /// + dst_chain(String) + dst_address(String) + dst_asset(String) + src_asset(String) + src_receiver(Pubkey)
+    /// </summary>
+    public static byte[] BuildLockInstructionData(
+        byte[] hashlock, ulong timelock, ulong amount,
+        string dstChain, string dstAddress, string dstAsset, string srcAsset, string srcReceiver)
+    {
+        var buf = new List<byte>(256);
+        buf.AddRange(LockDiscriminator);
+        WriteBorshBytes32(buf, hashlock);   // Id = hashlock for lock()
+        WriteBorshBytes32(buf, hashlock);   // hashlock
+        WriteBorshU64(buf, timelock);
+        WriteBorshU64(buf, amount);
+        WriteBorshString(buf, dstChain);
+        WriteBorshString(buf, dstAddress);
+        WriteBorshString(buf, dstAsset);
+        WriteBorshString(buf, srcAsset);
+        WriteBorshPubkey(buf, srcReceiver);
+        return buf.ToArray();
+    }
+
+    /// <summary>
+    /// Builds instruction data for redeem(): discriminator + Id[32] + secret[32]
+    /// </summary>
+    public static byte[] BuildRedeemInstructionData(byte[] id, byte[] secret)
+    {
+        var buf = new List<byte>(72);
+        buf.AddRange(RedeemDiscriminator);
+        WriteBorshBytes32(buf, id);
+        WriteBorshBytes32(buf, secret);
+        return buf.ToArray();
+    }
+
+    /// <summary>
+    /// Builds instruction data for refund(): discriminator + Id[32]
+    /// </summary>
+    public static byte[] BuildRefundInstructionData(byte[] id)
+    {
+        var buf = new List<byte>(40);
+        buf.AddRange(RefundDiscriminator);
+        WriteBorshBytes32(buf, id);
+        return buf.ToArray();
+    }
+
+    #endregion
+
+    #region Borsh Read Helpers
+
+    private static string ReadBorshString(byte[] data, ref int offset)
+    {
+        var length = BitConverter.ToInt32(data, offset);
+        offset += 4;
+        var str = Encoding.UTF8.GetString(data, offset, length);
+        offset += length;
+        return str;
+    }
+
+    private static byte[] ReadBytes(byte[] data, ref int offset, int count)
+    {
+        var result = new byte[count];
+        Array.Copy(data, offset, result, 0, count);
+        offset += count;
+        return result;
+    }
+
+    #endregion
+}
diff --git a/csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs b/csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs
new file mode 100644
index 00000000..b6d8b491
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs
@@ -0,0 +1,111 @@
+using Solnet.Rpc.Models;
+using Solnet.Wallet;
+using Train.Solver.Workflow.Solana.Models;
+
+namespace Train.Solver.Workflow.Solana.Helpers;
+
+public static class SolanaHelper
+{
+    /// <summary>
+    /// Solana System Program address — used as the "native token address" for SOL.
+    /// </summary>
+    public const string SystemProgramId = "11111111111111111111111111111111";
+
+    /// <summary>
+    /// ComputeBudget program address for setting compute unit limit and price.
+    /// </summary>
+    public const string ComputeBudgetProgramId = "ComputeBudget111111111111111111111111111111";
+
+    /// <summary>
+    /// Train HTLC program on Solana devnet.
+    /// </summary>
+    public const string HTLCProgramId = "7ZT5gs8CG7BAv34bLYSke31DJeg5RRUa4G7p9GNcbPE";
+
+    /// <summary>
+    /// Null address convention (EVM-style) — also treated as native SOL.
+    /// </summary>
+    private const string NullAddress = "0x0000000000000000000000000000000000000000";
+
+    /// <summary>
+    /// Checks if the token contract represents native SOL.
+    /// </summary>
+    public static bool IsNativeToken(string tokenContract) =>
+        string.Equals(tokenContract, SystemProgramId, StringComparison.OrdinalIgnoreCase) ||
+        string.Equals(tokenContract, NullAddress, StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Validates a Solana address (base58-encoded, 32 bytes).
+    /// </summary>
+    public static bool IsValidSolanaAddress(string address)
+    {
+        if (string.IsNullOrWhiteSpace(address))
+            return false;
+
+        try
+        {
+            var pubkey = new PublicKey(address);
+            // PublicKey constructor validates base58 and 32-byte length
+            return pubkey.Key == address;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Creates a SetComputeUnitLimit instruction (discriminant 0x02 + 4-byte LE u32).
+    /// </summary>
+    public static TransactionInstruction SetComputeUnitLimit(uint units)
+    {
+        var data = new byte[5];
+        data[0] = 0x02; // SetComputeUnitLimit discriminant
+        BitConverter.TryWriteBytes(data.AsSpan(1), units); // LE u32
+        return new TransactionInstruction
+        {
+            ProgramId = new PublicKey(ComputeBudgetProgramId).KeyBytes,
+            Keys = [],
+            Data = data
+        };
+    }
+
+    /// <summary>
+    /// Creates a SetComputeUnitPrice instruction (discriminant 0x03 + 8-byte LE u64).
+    /// </summary>
+    public static TransactionInstruction SetComputeUnitPrice(ulong microLamports)
+    {
+        var data = new byte[9];
+        data[0] = 0x03; // SetComputeUnitPrice discriminant
+        BitConverter.TryWriteBytes(data.AsSpan(1), microLamports); // LE u64
+        return new TransactionInstruction
+        {
+            ProgramId = new PublicKey(ComputeBudgetProgramId).KeyBytes,
+            Keys = [],
+            Data = data
+        };
+    }
+
+    /// <summary>
+    /// Classifies a Solana RPC error into a publish outcome.
+    /// </summary>
+    public static SolanaPublishOutcome ClassifyError(string? errorMessage)
+    {
+        if (string.IsNullOrEmpty(errorMessage))
+            return SolanaPublishOutcome.Failed;
+
+        if (errorMessage.Contains("AlreadyProcessed", StringComparison.OrdinalIgnoreCase) ||
+            errorMessage.Contains("already been processed", StringComparison.OrdinalIgnoreCase))
+            return SolanaPublishOutcome.DuplicateTransaction;
+
+        if (errorMessage.Contains("insufficient lamports", StringComparison.OrdinalIgnoreCase) ||
+            errorMessage.Contains("InsufficientFunds", StringComparison.OrdinalIgnoreCase) ||
+            errorMessage.Contains("insufficient funds", StringComparison.OrdinalIgnoreCase))
+            return SolanaPublishOutcome.InsufficientFunds;
+
+        if (errorMessage.Contains("Blockhash not found", StringComparison.OrdinalIgnoreCase) ||
+            errorMessage.Contains("BlockhashNotFound", StringComparison.OrdinalIgnoreCase))
+            return SolanaPublishOutcome.BlockhashNotFound;
+
+        return SolanaPublishOutcome.Failed;
+    }
+}
diff --git a/csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs b/csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs
new file mode 100644
index 00000000..86b068b6
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs
@@ -0,0 +1,160 @@
+namespace Train.Solver.Workflow.Solana.Models;
+
+#region On-Chain Account State
+
+/// <summary>
+/// Parsed HTLC PDA account data (Borsh-decoded after 8-byte Anchor discriminator).
+/// Maps to the Rust HTLC struct in the native_htlc program.
+/// </summary>
+public record SolanaHTLCAccount
+{
+    public string DstAddress { get; init; } = string.Empty;
+    public string DstChain { get; init; } = string.Empty;
+    public string DstAsset { get; init; } = string.Empty;
+    public string SrcAsset { get; init; } = string.Empty;
+    public string Sender { get; init; } = string.Empty;
+    public string SrcReceiver { get; init; } = string.Empty;
+    public string Hashlock { get; init; } = string.Empty;
+    public string Secret { get; init; } = string.Empty;
+    public ulong Amount { get; init; }
+    public ulong Reward { get; init; }
+    public long Timelock { get; init; }
+    public long RewardTimelock { get; init; }
+
+    /// <summary>
+    /// 1 = active, 2 = refunded, 3 = redeemed
+    /// </summary>
+    public byte Claimed { get; init; }
+}
+
+#endregion
+
+#region Activity Request
+
+/// <summary>
+/// Request for the GetHTLCEventsAsync activity.
+/// </summary>
+public record SolanaGetHTLCEventsRequest
+{
+    public required string ProgramId { get; init; }
+    public required string NodeUrl { get; init; }
+    public required string NetworkSlug { get; init; }
+
+    /// <summary>
+    /// Last processed transaction signature for pagination (passed to "until" in getSignaturesForAddress).
+    /// Null on first poll.
+    /// </summary>
+    public string? LastSignature { get; init; }
+
+    /// <summary>
+    /// Solver wallet addresses — used to distinguish user vs solver events for redeem/refund.
+    /// </summary>
+    public List<string> SolverWalletAddresses { get; init; } = [];
+}
+
+#endregion
+
+#region Activity Result
+
+/// <summary>
+/// Batch result from GetHTLCEventsAsync — contains categorized events and pagination state.
+/// </summary>
+public record SolanaHTLCEventResult
+{
+    public List<SolanaHTLCLockedEvent> LockedEvents { get; init; } = [];
+    public List<SolanaHTLCRedeemedEvent> RedeemedEvents { get; init; } = [];
+    public List<SolanaHTLCRefundedEvent> RefundedEvents { get; init; } = [];
+
+    /// <summary>
+    /// Most recent signature processed — used as "until" for the next poll.
+    /// </summary>
+    public string? LastProcessedSignature { get; init; }
+
+    /// <summary>
+    /// Slot of the most recently processed transaction — used for checkpoint.
+    /// </summary>
+    public ulong LastProcessedSlot { get; init; }
+}
+
+#endregion
+
+#region Event Models
+
+/// <summary>
+/// Detected HTLC lock event (from lock() or add_lock()/add_lock_sig() instructions).
+/// </summary>
+public record SolanaHTLCLockedEvent
+{
+    public required string TxSignature { get; init; }
+    public required ulong Slot { get; init; }
+    public required string Hashlock { get; init; }
+    public required string Sender { get; init; }
+    public required string SrcReceiver { get; init; }
+    public required ulong Amount { get; init; }
+    public required ulong Reward { get; init; }
+    public required long Timelock { get; init; }
+    public required long RewardTimelock { get; init; }
+    public required string DstAddress { get; init; }
+    public required string DstChain { get; init; }
+    public required string DstAsset { get; init; }
+    public required string SrcAsset { get; init; }
+
+    /// <summary>
+    /// True if this is a user lock (add_lock/add_lock_sig), false if solver lock (lock).
+    /// </summary>
+    public required bool IsUserLock { get; init; }
+}
+
+/// <summary>
+/// Detected HTLC redeem event (from redeem() instruction).
+/// </summary>
+public record SolanaHTLCRedeemedEvent
+{
+    public required string TxSignature { get; init; }
+    public required ulong Slot { get; init; }
+    public required string Hashlock { get; init; }
+    public required string Secret { get; init; }
+    public required string RedeemAddress { get; init; }
+
+    /// <summary>
+    /// True if the solver's lock was redeemed (HTLC.sender is solver), false if user's lock.
+    /// </summary>
+    public required bool IsSolverLock { get; init; }
+}
+
+/// <summary>
+/// Detected HTLC refund event (from refund() instruction).
+/// </summary>
+public record SolanaHTLCRefundedEvent
+{
+    public required string TxSignature { get; init; }
+    public required ulong Slot { get; init; }
+    public required string Hashlock { get; init; }
+
+    /// <summary>
+    /// True if the solver's lock was refunded (HTLC.sender is solver), false if user's lock.
+    /// </summary>
+    public required bool IsSolverLock { get; init; }
+}
+
+#endregion
+
+#region Checkpoint
+
+/// <summary>
+/// Solana listener checkpoint — stored in Redis for crash recovery.
+/// </summary>
+public record SolanaListenerCheckpoint
+{
+    /// <summary>
+    /// Last processed slot number (analogous to block number).
+    /// </summary>
+    public ulong LastProcessedSlot { get; init; }
+
+    /// <summary>
+    /// Last processed transaction signature — used for getSignaturesForAddress pagination.
+    /// </summary>
+    public string? LastSignature { get; init; }
+}
+
+#endregion
diff --git a/csharp/src/Workflow.Solana/Models/SolanaModels.cs b/csharp/src/Workflow.Solana/Models/SolanaModels.cs
new file mode 100644
index 00000000..62dcc2ca
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Models/SolanaModels.cs
@@ -0,0 +1,226 @@
+using System.Numerics;
+using Train.Solver.Shared.Models;
+using Train.Solver.Workflow.Abstractions.Workflows;
+
+namespace Train.Solver.Workflow.Solana.Models;
+
+#region Transaction Processor Args
+
+public record SolanaTransactionProcessorArgs
+{
+    public required string NetworkSlug { get; init; }
+    public required string WalletAddress { get; init; }
+    public required string SignerAgentUrl { get; init; }
+    public List<SolanaQueuedRequest> QueuedRequests { get; init; } = [];
+    public List<SolanaPendingTransaction> PendingTransactions { get; init; } = [];
+    public List<SolanaInFlightTransaction> InFlightTransactions { get; init; } = [];
+    public List<string> ProcessedCorrelationIds { get; init; } = [];
+}
+
+#endregion
+
+#region Pipeline Types
+
+public record SolanaQueuedRequest
+{
+    public required string CorrelationId { get; init; }
+    public required TransactionCallback Callback { get; init; }
+    public required TransactionType Type { get; init; }
+    public required string SenderAddress { get; init; }
+    public required string TokenContract { get; init; }
+    public TransferTransactionRequest? TransferRequest { get; init; }
+    public LockTransactionRequest? LockRequest { get; init; }
+    public RedeemTransactionRequest? RedeemRequest { get; init; }
+    public RefundTransactionRequest? RefundRequest { get; init; }
+    public int RetryCount { get; init; }
+    public ulong PriorityFeeMicroLamports { get; init; }
+}
+
+public record SolanaPendingTransaction
+{
+    public required string CorrelationId { get; init; }
+    public required TransactionCallback Callback { get; init; }
+    public required TransactionType Type { get; init; }
+    public required string SenderAddress { get; init; }
+    public required string TokenContract { get; init; }
+    public required ulong LastValidBlockHeight { get; init; }
+    public required ulong PriorityFeeMicroLamports { get; init; }
+    public required int RetryCount { get; init; }
+    public TransferTransactionRequest? TransferRequest { get; init; }
+    public LockTransactionRequest? LockRequest { get; init; }
+    public RedeemTransactionRequest? RedeemRequest { get; init; }
+    public RefundTransactionRequest? RefundRequest { get; init; }
+    public required string SignedTxBase64 { get; init; }
+}
+
+public record SolanaInFlightTransaction
+{
+    public required string CorrelationId { get; init; }
+    public required TransactionCallback Callback { get; init; }
+    public required TransactionType Type { get; init; }
+    public required string SenderAddress { get; init; }
+    public required string TokenContract { get; init; }
+    public required ulong LastValidBlockHeight { get; init; }
+    public required ulong PriorityFeeMicroLamports { get; init; }
+    public required int RetryCount { get; init; }
+    public TransferTransactionRequest? TransferRequest { get; init; }
+    public LockTransactionRequest? LockRequest { get; init; }
+    public RedeemTransactionRequest? RedeemRequest { get; init; }
+    public RefundTransactionRequest? RefundRequest { get; init; }
+    public required string TxSignature { get; init; }
+    public required DateTime PublishedAt { get; init; }
+}
+
+#endregion
+
+#region State Persistence
+
+public record SolanaTransactionProcessorSnapshot
+{
+    public List<SolanaQueuedRequest> QueuedRequests { get; init; } = [];
+    public List<SolanaPendingTransaction> PendingTransactions { get; init; } = [];
+    public List<SolanaInFlightTransaction> InFlightTransactions { get; init; } = [];
+    public List<string> ProcessedCorrelationIds { get; init; } = [];
+}
+
+#endregion
+
+#region Publish Result
+
+public enum SolanaPublishOutcome
+{
+    Published,
+    DuplicateTransaction,
+    InsufficientFunds,
+    BlockhashNotFound,
+    Failed
+}
+
+public record SolanaPublishResult
+{
+    public required SolanaPublishOutcome Outcome { get; init; }
+    public string? TxSignature { get; init; }
+    public string? ErrorMessage { get; init; }
+}
+
+#endregion
+
+#region Activity Request/Response Models
+
+public record SolanaBlockhashInfo
+{
+    public required string Blockhash { get; init; }
+    public required ulong LastValidBlockHeight { get; init; }
+}
+
+public record SolanaGetPriorityFeeRequest
+{
+    public required string NodeUrl { get; init; }
+    public List<string> AccountKeys { get; init; } = [];
+}
+
+public record SolanaGetTransactionRequest
+{
+    public required string NodeUrl { get; init; }
+    public required string TxSignature { get; init; }
+}
+
+public record SolanaBuildTransferRequest
+{
+    public required string NodeUrl { get; init; }
+    public required string FromAddress { get; init; }
+    public required string ToAddress { get; init; }
+    public required string TokenContract { get; init; }
+    public required BigInteger Amount { get; init; }
+    public required string RecentBlockhash { get; init; }
+    public ulong PriorityFeeMicroLamports { get; init; }
+    public uint ComputeUnitLimit { get; init; } = 200_000;
+}
+
+public record SolanaSignRequest
+{
+    public required string SignerAgentUrl { get; init; }
+    public required string WalletAddress { get; init; }
+    public required string UnsignedTxBase64 { get; init; }
+}
+
+public record SolanaPublishRequest
+{
+    public required string NodeUrl { get; init; }
+    public required string SignedTxBase64 { get; init; }
+}
+
+public record SolanaBalanceRequest
+{
+    public required string NodeUrl { get; init; }
+    public required string Address { get; init; }
+    public required string TokenContract { get; init; }
+}
+
+public record SolanaGetSignatureStatusRequest
+{
+    public required string NodeUrl { get; init; }
+    public required List<string> TxSignatures { get; init; }
+}
+
+public record SolanaSignatureStatus
+{
+    public required string TxSignature { get; init; }
+    public bool Confirmed { get; init; }
+    public bool Failed { get; init; }
+    public string? ErrorMessage { get; init; }
+    public ulong? Slot { get; init; }
+}
+
+#endregion
+
+#region HTLC Build Requests
+
+public record SolanaBuildHTLCLockRequest
+{
+    public required string NodeUrl { get; init; }
+    public required string SenderAddress { get; init; }
+    public required string SrcReceiver { get; init; }
+    public required byte[] Hashlock { get; init; }
+    public required ulong Timelock { get; init; }
+    public required ulong Amount { get; init; }
+    public required string DstChain { get; init; }
+    public required string DstAddress { get; init; }
+    public required string DstAsset { get; init; }
+    public required string SrcAsset { get; init; }
+    public required string RecentBlockhash { get; init; }
+    public ulong PriorityFeeMicroLamports { get; init; }
+    public uint ComputeUnitLimit { get; init; } = 400_000;
+}
+
+public record SolanaBuildHTLCRedeemRequest
+{
+    public required string NodeUrl { get; init; }
+    public required string SignerAddress { get; init; }
+    public required string SenderAddress { get; init; }
+    public required string SrcReceiverAddress { get; init; }
+    public required byte[] Id { get; init; }
+    public required byte[] Secret { get; init; }
+    public required string RecentBlockhash { get; init; }
+    public ulong PriorityFeeMicroLamports { get; init; }
+    public uint ComputeUnitLimit { get; init; } = 400_000;
+}
+
+public record SolanaBuildHTLCRefundRequest
+{
+    public required string NodeUrl { get; init; }
+    public required string SignerAddress { get; init; }
+    public required string SenderAddress { get; init; }
+    public required byte[] Id { get; init; }
+    public required string RecentBlockhash { get; init; }
+    public ulong PriorityFeeMicroLamports { get; init; }
+    public uint ComputeUnitLimit { get; init; } = 400_000;
+}
+
+public record SolanaGetHTLCAccountRequest
+{
+    public required string NodeUrl { get; init; }
+    public required byte[] Id { get; init; }
+}
+
+#endregion
diff --git a/csharp/src/Workflow.Solana/Program.cs b/csharp/src/Workflow.Solana/Program.cs
new file mode 100644
index 00000000..da720dc3
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Program.cs
@@ -0,0 +1,21 @@
+using Train.Solver.Infrastructure.DependencyInjection;
+using Train.Solver.Infrastrucutre.Secret.Treasury.Extensions;
+using Train.Solver.Workflow.Solana.Extensions;
+
+IHost host = Host.CreateDefaultBuilder(args)
+    .ConfigureAppConfiguration(builder =>
+        builder.SetBasePath(AppContext.BaseDirectory)
+            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
+            .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT")}.json", optional: true, reloadOnChange: true)
+            .AddJsonFile($"appsettings.Local.json", optional: true, reloadOnChange: true)
+            .AddEnvironmentVariables())
+    .ConfigureServices((hostContext, services) =>
+    {
+        services
+            .AddTrainSolver(hostContext.Configuration)
+            .WithTreasury()
+            .WithSolanaWorkflows();
+    })
+    .Build();
+
+await host.RunAsync();
diff --git a/csharp/src/Workflow.Solana/Properties/launchSettings.json b/csharp/src/Workflow.Solana/Properties/launchSettings.json
new file mode 100644
index 00000000..cf6f2569
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Properties/launchSettings.json
@@ -0,0 +1,11 @@
+{
+  "profiles": {
+    "Workflow.Solana": {
+      "commandName": "Project",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}
diff --git a/csharp/src/Workflow.Solana/SolanaListenerCapabilities.cs b/csharp/src/Workflow.Solana/SolanaListenerCapabilities.cs
new file mode 100644
index 00000000..97605d1c
--- /dev/null
+++ b/csharp/src/Workflow.Solana/SolanaListenerCapabilities.cs
@@ -0,0 +1,124 @@
+using Train.Solver.Workflow.Abstractions;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Common;
+
+namespace Train.Solver.Workflow.Solana;
+
+/// <summary>
+/// Static routing config for event→workflow dispatch (same shape as EVM's DispatchRule).
+/// </summary>
+public record SolanaDispatchRule
+{
+    public required string SignalName { get; init; }
+    public string? TargetWorkflowIdPrefix { get; init; }
+    public string? StartWorkflowType { get; init; }
+    public string? StartWorkflowTaskQueue { get; init; }
+    public object[]? StartWorkflowArgs { get; init; }
+}
+
+/// <summary>
+/// Solana-specific listener capabilities and dispatch rules.
+/// Solana only supports a single RPC-based listener (polls getSignaturesForAddress).
+/// </summary>
+public static class SolanaListenerCapabilities
+{
+    /// <summary>
+    /// Routes events to OrderWorkflow via hashlock (same pattern as EVM).
+    /// </summary>
+    public static readonly Dictionary<string, SolanaDispatchRule> DispatchRules = new()
+    {
+        [EventTypes.UserTokenLocked] = new()
+        {
+            SignalName = "OnUserTokenLocked",
+            TargetWorkflowIdPrefix = "order-",
+            StartWorkflowType = CoreWorkflowNames.OrderWorkflow,
+            StartWorkflowTaskQueue = Constants.CoreTaskQueue,
+            StartWorkflowArgs = [new OrderWorkflowArgs()],
+        },
+        [EventTypes.SolverTokenLocked] = new()
+        {
+            SignalName = "OnSolverTokenLocked",
+            TargetWorkflowIdPrefix = "order-",
+        },
+        [EventTypes.UserTokenRedeemed] = new()
+        {
+            SignalName = "OnUserTokenRedeemed",
+            TargetWorkflowIdPrefix = "order-",
+        },
+        [EventTypes.SolverTokenRedeemed] = new()
+        {
+            SignalName = "OnSolverTokenRedeemed",
+            TargetWorkflowIdPrefix = "order-",
+        },
+        [EventTypes.UserTokenRefunded] = new()
+        {
+            SignalName = "OnUserTokenRefunded",
+            TargetWorkflowIdPrefix = "order-",
+        },
+        [EventTypes.SolverTokenRefunded] = new()
+        {
+            SignalName = "OnSolverTokenRefunded",
+            TargetWorkflowIdPrefix = "order-",
+        },
+    };
+
+    /// <summary>
+    /// Solana only supports the RPC log event listener.
+    /// </summary>
+    public static readonly Dictionary<string, string[]> SupportedEventTypes = new()
+    {
+        [NetworkWorkflowNames.RPCLogEventListener] =
+        [
+            EventTypes.UserTokenLocked, EventTypes.SolverTokenLocked,
+            EventTypes.UserTokenRedeemed, EventTypes.SolverTokenRedeemed,
+            EventTypes.UserTokenRefunded, EventTypes.SolverTokenRefunded
+        ],
+    };
+
+    public static readonly Dictionary<string, string[]> RequiredSettings = new()
+    {
+        [NetworkWorkflowNames.RPCLogEventListener] = [],
+    };
+
+    public static readonly Dictionary<string, Dictionary<string, string>> DefaultSettings = new()
+    {
+        [NetworkWorkflowNames.RPCLogEventListener] = new()
+        {
+            ["PollingIntervalSeconds"] = "5",
+        },
+    };
+
+    public static readonly string[] AllListenerTypes =
+    [
+        NetworkWorkflowNames.RPCLogEventListener,
+    ];
+
+    /// <summary>
+    /// Compose subscriptions for a Solana listener type.
+    /// </summary>
+    public static List<EventSubscription> ComposeSubscriptions(string listenerType, string[] filterAddresses)
+    {
+        var supported = SupportedEventTypes.GetValueOrDefault(listenerType, []);
+        var subscriptions = new List<EventSubscription>();
+
+        foreach (var (eventType, rule) in DispatchRules)
+        {
+            if (!supported.Contains(eventType))
+                continue;
+
+            subscriptions.Add(new EventSubscription
+            {
+                EventType = eventType,
+                SubscriberId = "network-runtime",
+                SignalName = rule.SignalName,
+                FilterAddresses = eventType == EventTypes.UserTokenLocked ? filterAddresses : [],
+                TargetWorkflowIdPrefix = rule.TargetWorkflowIdPrefix,
+                StartWorkflowType = rule.StartWorkflowType,
+                StartWorkflowTaskQueue = rule.StartWorkflowTaskQueue,
+                StartWorkflowArgs = rule.StartWorkflowArgs,
+            });
+        }
+
+        return subscriptions;
+    }
+}
diff --git a/csharp/src/Workflow.Solana/Workflow.Solana.csproj b/csharp/src/Workflow.Solana/Workflow.Solana.csproj
new file mode 100644
index 00000000..c4ed0c37
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Workflow.Solana.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.Worker">
+
+	<PropertyGroup>
+		<AssemblyName>Train.Solver.Workflow.Solana</AssemblyName>
+		<RootNamespace>Train.Solver.Workflow.Solana</RootNamespace>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <Content Remove="Properties\launchSettings.json" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <None Include="Properties\launchSettings.json" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Solnet.Rpc" Version="6.1.0" />
+		<PackageReference Include="Solnet.Programs" Version="6.1.0" />
+		<PackageReference Include="Solnet.Wallet" Version="6.1.0" />
+		<PackageReference Include="StackExchange.Redis" Version="2.8.58" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\Infrastructure.Secret.Treasury\Infrastructure.Secret.Treasury.csproj" />
+		<ProjectReference Include="..\Workflow.Common\Workflow.Common.csproj" />
+	</ItemGroup>
+
+</Project>
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaAddressGenerator.cs b/csharp/src/Workflow.Solana/Workflows/SolanaAddressGenerator.cs
new file mode 100644
index 00000000..2c517b36
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaAddressGenerator.cs
@@ -0,0 +1,27 @@
+using Temporalio.Workflows;
+using Train.Solver.Workflow.Abstractions;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Solana.Activities;
+using static Temporalio.Workflows.Workflow;
+
+namespace Train.Solver.Workflow.Solana.Workflows;
+
+[Workflow(name: NetworkWorkflowNames.AddressGenerator)]
+public class SolanaAddressGenerator : IAddressGenerator
+{
+    private static readonly LocalActivityOptions DefaultLocalActivityOptions = new()
+    {
+        StartToCloseTimeout = TimeSpan.FromSeconds(30),
+        RetryPolicy = new() { MaximumAttempts = 3 }
+    };
+
+    [WorkflowRun]
+    public async Task<GenerateAddressResponse> RunAsync(GenerateAddressRequest request)
+    {
+        var address = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GenerateAddressAsync(request),
+            DefaultLocalActivityOptions);
+
+        return new GenerateAddressResponse { Address = address };
+    }
+}
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaEventListenerBase.cs b/csharp/src/Workflow.Solana/Workflows/SolanaEventListenerBase.cs
new file mode 100644
index 00000000..9a3de72f
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaEventListenerBase.cs
@@ -0,0 +1,239 @@
+using Temporalio.Workflows;
+using Train.Solver.Workflow.Abstractions.Activities;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Solana.Activities;
+using Train.Solver.Workflow.Solana.Models;
+using static Temporalio.Workflows.Workflow;
+
+namespace Train.Solver.Workflow.Solana.Workflows;
+
+/// <summary>
+/// Base class for Solana event listeners. Self-contained (no dependency on Workflow.EVM).
+/// Provides shared state, subscription management, dedup, event emission, and checkpoint.
+/// </summary>
+public abstract class SolanaEventListenerBase
+{
+    protected const int MaxProcessedHashesToKeep = 10000;
+
+    private static readonly LocalActivityOptions CheckpointLocalActivityOptions = new()
+    {
+        StartToCloseTimeout = TimeSpan.FromSeconds(10),
+        RetryPolicy = new() { MaximumAttempts = 3 }
+    };
+
+    protected List<string> _processedTransactionHashes = [];
+    protected HashSet<string> _processedTxHashSet = [];
+    protected List<EventSubscription> _subscriptions = [];
+    protected string _networkSlug = string.Empty;
+    protected ulong? _lastProcessedSlot;
+    protected string? _lastProcessedSignature;
+    protected bool _restartRequested;
+
+    protected string ListenerTypeName => Info.WorkflowType;
+
+    #region Initialization
+
+    protected async Task InitializeFromArgsAsync(EventListenerArgs args)
+    {
+        _processedTransactionHashes = [.. args.ProcessedTransactionHashes];
+        _processedTxHashSet = new HashSet<string>(_processedTransactionHashes);
+        _subscriptions = [.. args.Subscriptions];
+        _networkSlug = args.NetworkSlug;
+        _lastProcessedSlot = args.LastProcessedBlockNumber;
+
+        // Restore checkpoint from Redis if no state from continue-as-new
+        if (!_lastProcessedSlot.HasValue)
+        {
+            var checkpoint = await ExecuteLocalActivityAsync(
+                (ISolanaWorkflowActivities x) => x.GetListenerCheckpointAsync(args.NetworkSlug, ListenerTypeName),
+                CheckpointLocalActivityOptions);
+
+            if (checkpoint != null)
+            {
+                _lastProcessedSlot = checkpoint.LastProcessedSlot;
+                _lastProcessedSignature = checkpoint.LastSignature;
+
+                Logger.LogInformation(
+                    "{ListenerType} restored checkpoint for {Network}: slot {Slot}, sig {Sig}",
+                    ListenerTypeName, args.NetworkSlug, _lastProcessedSlot, _lastProcessedSignature);
+            }
+        }
+
+        Logger.LogInformation(
+            "{ListenerType} started for {Network} with {Subscriptions} dispatch rules",
+            ListenerTypeName, args.NetworkSlug, _subscriptions.Count);
+    }
+
+    #endregion
+
+    #region Subscription Signals & Queries
+
+    public virtual Task UpdateSubscriptionsAsync(List<EventSubscription> subscriptions)
+    {
+        _subscriptions = subscriptions;
+        Logger.LogInformation(
+            "{ListenerType} updated subscriptions on {Network}: {Count} rules",
+            ListenerTypeName, _networkSlug, subscriptions.Count);
+        return Task.CompletedTask;
+    }
+
+    public virtual Task RequestRestartAsync()
+    {
+        Logger.LogInformation("{ListenerType} for {Network} received restart request", ListenerTypeName, _networkSlug);
+        _restartRequested = true;
+        return Task.CompletedTask;
+    }
+
+    public virtual IReadOnlyCollection<EventSubscription> GetSubscriptions() => _subscriptions;
+
+    public virtual ulong? GetLastProcessedBlock() => _lastProcessedSlot;
+
+    #endregion
+
+    #region Dedup Helpers
+
+    protected bool IsAlreadyProcessed(string key) => _processedTxHashSet.Contains(key);
+
+    protected bool TryMarkProcessed(string key)
+    {
+        if (!_processedTxHashSet.Add(key))
+            return false;
+
+        _processedTransactionHashes.Add(key);
+        return true;
+    }
+
+    protected void TrimProcessedHashesIfNeeded()
+    {
+        if (_processedTransactionHashes.Count > MaxProcessedHashesToKeep)
+        {
+            _processedTransactionHashes = _processedTransactionHashes
+                .TakeLast(MaxProcessedHashesToKeep)
+                .ToList();
+            _processedTxHashSet = new HashSet<string>(_processedTransactionHashes);
+        }
+    }
+
+    #endregion
+
+    #region Address Filtering
+
+    protected bool MatchesFilterAddresses(string eventType, params string?[] addressesToCheck)
+    {
+        var sub = _subscriptions.FirstOrDefault(s => s.EventType == eventType);
+        var filterAddresses = sub?.FilterAddresses;
+
+        if (filterAddresses == null || filterAddresses.Length == 0)
+            return true;
+
+        foreach (var addr in addressesToCheck)
+        {
+            if (string.IsNullOrEmpty(addr)) continue;
+            if (filterAddresses.Any(f => f.Equals(addr, StringComparison.OrdinalIgnoreCase)))
+                return true;
+        }
+
+        return false;
+    }
+
+    #endregion
+
+    #region Event Emission
+
+    protected async Task EmitEventAsync<TEvent>(string eventType, TEvent evt, string? routingKey = null)
+    {
+        var subscribers = _subscriptions.Where(s => s.EventType == eventType).ToList();
+
+        if (subscribers.Count == 0)
+        {
+            Logger.LogDebug("No subscribers for {EventType} on {Network}, skipping", eventType, _networkSlug);
+            return;
+        }
+
+        foreach (var sub in subscribers)
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(sub.TargetWorkflowIdPrefix) && !string.IsNullOrEmpty(routingKey))
+                {
+                    var targetWorkflowId = $"{sub.TargetWorkflowIdPrefix}{routingKey}";
+
+                    if (!string.IsNullOrEmpty(sub.StartWorkflowType))
+                    {
+                        await ExecuteActivityAsync(
+                            (IWorkflowActivities x) => x.StartWorkflowAsync(new StartWorkflowRequest
+                            {
+                                WorkflowType = sub.StartWorkflowType,
+                                WorkflowId = targetWorkflowId,
+                                TaskQueue = sub.StartWorkflowTaskQueue!,
+                                Args = sub.StartWorkflowArgs,
+                            }),
+                            new ActivityOptions
+                            {
+                                TaskQueue = sub.StartWorkflowTaskQueue,
+                                StartToCloseTimeout = TimeSpan.FromSeconds(15),
+                                RetryPolicy = new() { MaximumAttempts = 3 }
+                            });
+                    }
+
+                    await GetExternalWorkflowHandle(targetWorkflowId)
+                        .SignalAsync(sub.SignalName, [evt]);
+                }
+                else
+                {
+                    await GetExternalWorkflowHandle(sub.SubscriberId)
+                        .SignalAsync(sub.SignalName, [evt]);
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex,
+                    "Failed to dispatch {EventType} for {Subscriber} on {Network}",
+                    eventType, sub.SubscriberId, _networkSlug);
+            }
+        }
+    }
+
+    #endregion
+
+    #region Continue-as-new & Checkpoint
+
+    protected EventListenerArgs BuildContinueAsNewArgs()
+    {
+        var hashesToKeep = _processedTransactionHashes.Count > MaxProcessedHashesToKeep
+            ? _processedTransactionHashes.TakeLast(MaxProcessedHashesToKeep).ToList()
+            : _processedTransactionHashes;
+
+        return new EventListenerArgs
+        {
+            NetworkSlug = _networkSlug,
+            LastProcessedBlockNumber = _lastProcessedSlot,
+            ProcessedTransactionHashes = hashesToKeep,
+            Subscriptions = _subscriptions,
+        };
+    }
+
+    protected async Task SaveCheckpointAsync()
+    {
+        if (!_lastProcessedSlot.HasValue) return;
+
+        try
+        {
+            await ExecuteLocalActivityAsync(
+                (ISolanaWorkflowActivities x) => x.SaveListenerCheckpointAsync(
+                    _networkSlug, ListenerTypeName,
+                    new SolanaListenerCheckpoint
+                    {
+                        LastProcessedSlot = _lastProcessedSlot.Value,
+                        LastSignature = _lastProcessedSignature,
+                    }),
+                CheckpointLocalActivityOptions);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Failed to save checkpoint for {Network}", _networkSlug);
+        }
+    }
+
+    #endregion
+}
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs b/csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs
new file mode 100644
index 00000000..9b9fc2b4
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs
@@ -0,0 +1,726 @@
+using Temporalio.Workflows;
+using Train.Solver.Shared.Models;
+using Train.Solver.Workflow.Abstractions;
+using Train.Solver.Workflow.Abstractions.Activities;
+using Train.Solver.Workflow.Abstractions.Models;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Common.Helpers;
+using Train.Solver.Workflow.Solana.Activities;
+using Train.Solver.Workflow.Solana.Helpers;
+using Train.Solver.Workflow.Solana.Models;
+using static Temporalio.Workflows.Workflow;
+using Constants = Train.Solver.Workflow.Common.Constants;
+
+namespace Train.Solver.Workflow.Solana.Workflows;
+
+[Workflow(name: NetworkWorkflowNames.NetworkRuntime,
+    FailureExceptionTypes = [typeof(Temporalio.Exceptions.WorkflowNondeterminismException)])]
+public class SolanaNetworkRuntime : INetworkRuntime
+{
+    private const int MaxIterationsBeforeContinueAsNew = 200;
+
+    private static readonly LocalActivityOptions DefaultLocalActivityOptions = new()
+    {
+        StartToCloseTimeout = TimeSpan.FromSeconds(30),
+        RetryPolicy = new() { MaximumAttempts = 3 }
+    };
+
+    private bool _initialized;
+    private bool _restartRequested;
+    private string _networkSlug = string.Empty;
+    private int _operationCount;
+    private DetailedNetworkDto? _network;
+    private List<ActiveListener> _activeListeners = [];
+    private List<string> _activeTransactionProcessorIds = [];
+    private string[] _activeFilterAddresses = [];
+    private DateTime? _lastHealthCheckTime;
+
+    [WorkflowRun]
+    public async Task RunAsync(NetworkRuntimeArgs args)
+    {
+        _networkSlug = args.NetworkSlug;
+        _operationCount = 0;
+        _activeListeners = new List<ActiveListener>(args.ActiveListeners);
+        _activeTransactionProcessorIds = new List<string>(args.ActiveTransactionProcessorIds);
+        _activeFilterAddresses = args.ActiveFilterAddresses ?? [];
+
+        Logger.LogInformation("SolanaNetworkRuntime started for {Network} with {Listeners} listeners, {TPs} processors",
+            _networkSlug, _activeListeners.Count, _activeTransactionProcessorIds.Count);
+
+        try
+        {
+            await BootstrapInfrastructureAsync();
+            _initialized = true;
+
+            while (!Temporalio.Workflows.Workflow.CancellationToken.IsCancellationRequested)
+            {
+                if (_operationCount >= MaxIterationsBeforeContinueAsNew)
+                {
+                    Logger.LogInformation("SolanaNetworkRuntime for {Network} resetting after {Count} operations",
+                        _networkSlug, _operationCount);
+                    throw CreateContinueAsNewException<SolanaNetworkRuntime>(
+                        r => r.RunAsync(BuildContinueAsNewArgs()));
+                }
+
+                if (_restartRequested)
+                {
+                    Logger.LogInformation("SolanaNetworkRuntime for {Network} restarting (signal received)",
+                        _networkSlug);
+                    throw CreateContinueAsNewException<SolanaNetworkRuntime>(
+                        r => r.RunAsync(BuildContinueAsNewArgs()));
+                }
+
+                CurrentDetails = $"Solana Runtime on {_networkSlug} | {_operationCount} ops | {_activeListeners.Count} listeners | {_activeTransactionProcessorIds.Count} TPs";
+                await DelayAsync(TimeSpan.FromMinutes(1));
+
+                await HealthCheckAsync();
+                _operationCount++;
+            }
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException and not ContinueAsNewException)
+        {
+            Logger.LogError(ex, "Unhandled error in SolanaNetworkRuntime for {Network}, continuing as new",
+                _networkSlug);
+            throw CreateContinueAsNewException<SolanaNetworkRuntime>(
+                r => r.RunAsync(BuildContinueAsNewArgs()));
+        }
+    }
+
+    #region Infrastructure Bootstrap
+
+    private async Task BootstrapInfrastructureAsync()
+    {
+        _network = await ExecuteActivityAsync(
+            (INetworkActivities x) => x.GetNetworkAsync(_networkSlug),
+            TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+        var wallets = await ExecuteActivityAsync(
+            (IWalletActivities x) => x.GetNetworkWalletsByTypeAsync(_network.Type.Name),
+            TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+        _activeFilterAddresses = wallets.Select(w => w.Address).Distinct().ToArray();
+
+        // Start event listeners from config
+        await BootstrapListenersAsync();
+
+        // Start TPs for each wallet
+        foreach (var wallet in wallets)
+        {
+            await EnsureTransactionProcessorAsync(wallet);
+        }
+
+        Logger.LogInformation("SolanaNetworkRuntime bootstrapped for {Network}: {Listeners} listeners, {TPs} transaction processors",
+            _networkSlug, _activeListeners.Count, _activeTransactionProcessorIds.Count);
+    }
+
+    private async Task BootstrapListenersAsync()
+    {
+        if (_network?.EventListenerConfigs == null) return;
+
+        var enabledConfigs = _network.EventListenerConfigs
+            .Where(c => c.Enabled && SolanaListenerCapabilities.AllListenerTypes.Contains(c.ListenerType))
+            .ToList();
+
+        foreach (var config in enabledConfigs)
+        {
+            var listenerId = TemporalHelper.BuildListenerId(_networkSlug, config.ListenerType);
+            await EnsureListenerRunningAsync(config.ListenerType, listenerId);
+        }
+
+        _activeListeners = enabledConfigs
+            .Select(c => new ActiveListener
+            {
+                ListenerId = TemporalHelper.BuildListenerId(_networkSlug, c.ListenerType),
+                ListenerType = c.ListenerType
+            })
+            .ToList();
+    }
+
+    private async Task EnsureListenerRunningAsync(string workflowType, string listenerId)
+    {
+        try
+        {
+            var subscriptions = SolanaListenerCapabilities.ComposeSubscriptions(workflowType, _activeFilterAddresses);
+
+            await ExecuteActivityAsync(
+                (IWorkflowActivities x) => x.StartWorkflowAsync(new StartWorkflowRequest
+                {
+                    WorkflowType = workflowType,
+                    WorkflowId = listenerId,
+                    TaskQueue = _network!.Type.Name,
+                    Args = new object[] { new EventListenerArgs
+                    {
+                        NetworkSlug = _networkSlug,
+                        Subscriptions = subscriptions
+                    }}
+                }),
+                TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+            Logger.LogDebug("Started {WorkflowType} for {Network} with {Subs} dispatch rules",
+                workflowType, _networkSlug, subscriptions.Count);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Failed to start listener {ListenerId} on {Network}", listenerId, _networkSlug);
+        }
+    }
+
+    private async Task EnsureTransactionProcessorAsync(NetworkWalletDto wallet)
+    {
+        var tpId = TemporalHelper.BuildTransactionProcessorId(_networkSlug, wallet.Address);
+
+        if (_activeTransactionProcessorIds.Contains(tpId))
+            return;
+
+        try
+        {
+            var args = new SolanaTransactionProcessorArgs
+            {
+                NetworkSlug = _networkSlug,
+                WalletAddress = wallet.Address,
+                SignerAgentUrl = wallet.SignerAgentUrl
+            };
+
+            await ExecuteActivityAsync(
+                (IWorkflowActivities x) => x.StartWorkflowAsync(new StartWorkflowRequest
+                {
+                    WorkflowType = NetworkWorkflowNames.TransactionProcessor,
+                    WorkflowId = tpId,
+                    TaskQueue = _network!.Type.Name,
+                    Args = new object[] { args }
+                }),
+                TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+            _activeTransactionProcessorIds.Add(tpId);
+            Logger.LogInformation("Started Solana TP {TpId} for wallet {Wallet}",
+                tpId, wallet.Address);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Failed to start Solana TP for wallet {Wallet}", wallet.Address);
+        }
+    }
+
+    private async Task HealthCheckAsync()
+    {
+        _lastHealthCheckTime = Temporalio.Workflows.Workflow.UtcNow;
+
+        try
+        {
+            _network = await ExecuteActivityAsync(
+                (INetworkActivities x) => x.GetNetworkAsync(_networkSlug),
+                TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+            var wallets = await ExecuteActivityAsync(
+                (IWalletActivities x) => x.GetNetworkWalletsByTypeAsync(_network.Type.Name),
+                TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+            // Reconcile listeners
+            await ReconcileListenersAsync();
+
+            // Reconcile TPs
+            foreach (var wallet in wallets)
+            {
+                await EnsureTransactionProcessorAsync(wallet);
+            }
+
+            // Update subscriptions if filter addresses changed
+            var newFilterAddresses = wallets.Select(w => w.Address).Distinct().OrderBy(a => a).ToArray();
+            var currentSorted = _activeFilterAddresses.OrderBy(a => a).ToArray();
+
+            if (!newFilterAddresses.SequenceEqual(currentSorted))
+            {
+                _activeFilterAddresses = wallets.Select(w => w.Address).Distinct().ToArray();
+
+                Logger.LogInformation("Filter addresses changed on {Network}, updating subscriptions on {Count} listeners",
+                    _networkSlug, _activeListeners.Count);
+
+                foreach (var listener in _activeListeners)
+                {
+                    await SignalUpdateSubscriptionsAsync(listener);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Health check failed for Solana runtime {Network}", _networkSlug);
+        }
+    }
+
+    private async Task ReconcileListenersAsync()
+    {
+        if (_network?.EventListenerConfigs == null) return;
+
+        var enabledConfigs = _network.EventListenerConfigs
+            .Where(c => c.Enabled && SolanaListenerCapabilities.AllListenerTypes.Contains(c.ListenerType))
+            .ToList();
+
+        var desiredListenerIds = enabledConfigs
+            .Select(c => TemporalHelper.BuildListenerId(_networkSlug, c.ListenerType))
+            .ToHashSet();
+        var activeListenerIds = _activeListeners.Select(x => x.ListenerId).ToHashSet();
+
+        // Start only NEW listeners
+        foreach (var config in enabledConfigs)
+        {
+            var listenerId = TemporalHelper.BuildListenerId(_networkSlug, config.ListenerType);
+            if (!activeListenerIds.Contains(listenerId))
+            {
+                await EnsureListenerRunningAsync(config.ListenerType, listenerId);
+            }
+        }
+
+        _activeListeners = enabledConfigs
+            .Select(c => new ActiveListener
+            {
+                ListenerId = TemporalHelper.BuildListenerId(_networkSlug, c.ListenerType),
+                ListenerType = c.ListenerType
+            })
+            .ToList();
+    }
+
+    private async Task SignalUpdateSubscriptionsAsync(ActiveListener listener)
+    {
+        try
+        {
+            var subscriptions = SolanaListenerCapabilities.ComposeSubscriptions(listener.ListenerType, _activeFilterAddresses);
+            var handle = GetExternalWorkflowHandle(listener.ListenerId);
+            await handle.SignalAsync("UpdateSubscriptions", [subscriptions]);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Failed to update subscriptions on listener {ListenerId}", listener.ListenerId);
+        }
+    }
+
+    #endregion
+
+    #region Update Handlers
+
+    [WorkflowUpdate]
+    public async Task<GetBalanceResponse> GetBalanceAsync(GetBalanceRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+
+        var balance = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetBalanceAsync(new SolanaBalanceRequest
+            {
+                NodeUrl = nodeUrl,
+                Address = request.Address,
+                TokenContract = request.TokenContract
+            }),
+            DefaultLocalActivityOptions);
+
+        return new GetBalanceResponse { Balance = balance };
+    }
+
+    [WorkflowUpdate]
+    public async Task<GetBatchBalancesResponse> GetBatchBalancesAsync(GetBatchBalancesRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+
+        var balances = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetBatchBalancesAsync(
+                nodeUrl, request.Address, request.TokenContracts.ToList()),
+            DefaultLocalActivityOptions);
+
+        return new GetBatchBalancesResponse
+        {
+            Balances = balances.AsReadOnly()
+        };
+    }
+
+    [WorkflowUpdate]
+    public async Task<ValidateAddressResponse> ValidateAddressAsync(string address)
+    {
+        _operationCount++;
+
+        var isValid = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.ValidateAddressAsync(address),
+            DefaultLocalActivityOptions);
+
+        return new ValidateAddressResponse
+        {
+            IsValid = isValid,
+            ErrorMessage = isValid ? null : "Invalid Solana address (must be base58-encoded, 32 bytes)"
+        };
+    }
+
+    [WorkflowUpdate]
+    public async Task<ValidateNodeResponse> ValidateNodeAsync(ValidateNodeRequest request)
+    {
+        _operationCount++;
+
+        try
+        {
+            var slot = await ExecuteLocalActivityAsync(
+                (ISolanaBlockchainActivities x) => x.GetSlotAsync(request.NodeUrl),
+                DefaultLocalActivityOptions);
+
+            return new ValidateNodeResponse
+            {
+                IsValid = true,
+                ChainId = slot.ToString()
+            };
+        }
+        catch (Exception ex)
+        {
+            return new ValidateNodeResponse
+            {
+                IsValid = false,
+                ErrorMessage = ex.Message
+            };
+        }
+    }
+
+    [WorkflowUpdate]
+    public async Task<PrepareTransactionDto> BuildSolverLockTransactionAsync(HTLCLockTransactionPrepareRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+        var hashlock = ParseHexBytes32(request.Hashlock);
+
+        var unsignedTxBase64 = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.BuildHTLCLockTransactionAsync(new SolanaBuildHTLCLockRequest
+            {
+                NodeUrl = nodeUrl,
+                SenderAddress = request.Sender,
+                SrcReceiver = request.Receiver,
+                Hashlock = hashlock,
+                Timelock = (ulong)request.Timelock,
+                Amount = (ulong)request.Amount,
+                DstChain = request.DstChain,
+                DstAddress = request.DestinationAddress,
+                DstAsset = request.DstToken,
+                SrcAsset = request.TokenContract,
+                RecentBlockhash = string.Empty // placeholder — TP will set the real blockhash
+            }),
+            DefaultLocalActivityOptions);
+
+        var pdaAddress = SolanaAnchorHelper.DerivePDA(hashlock, SolanaHelper.HTLCProgramId) ?? string.Empty;
+
+        return new PrepareTransactionDto
+        {
+            Data = unsignedTxBase64,
+            ToAddress = pdaAddress,
+            ContractAddress = _network!.Type.NativeTokenAddress,
+            Type = TransactionType.HTLCLock,
+            Amount = request.Amount
+        };
+    }
+
+    [WorkflowUpdate]
+    public async Task<PrepareTransactionDto> BuildUserLockTransactionAsync(HTLCLockTransactionPrepareRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+        var hashlock = ParseHexBytes32(request.Hashlock);
+
+        var unsignedTxBase64 = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.BuildHTLCLockTransactionAsync(new SolanaBuildHTLCLockRequest
+            {
+                NodeUrl = nodeUrl,
+                SenderAddress = request.Sender,
+                SrcReceiver = request.Receiver,
+                Hashlock = hashlock,
+                Timelock = (ulong)request.Timelock,
+                Amount = (ulong)request.Amount,
+                DstChain = request.DstChain,
+                DstAddress = request.DestinationAddress,
+                DstAsset = request.DstToken,
+                SrcAsset = request.TokenContract,
+                RecentBlockhash = string.Empty
+            }),
+            DefaultLocalActivityOptions);
+
+        var pdaAddress = SolanaAnchorHelper.DerivePDA(hashlock, SolanaHelper.HTLCProgramId) ?? string.Empty;
+
+        return new PrepareTransactionDto
+        {
+            Data = unsignedTxBase64,
+            ToAddress = pdaAddress,
+            ContractAddress = _network!.Type.NativeTokenAddress,
+            Type = TransactionType.UserHTLCLock,
+            Amount = request.Amount
+        };
+    }
+
+    [WorkflowUpdate]
+    public async Task<PrepareTransactionDto> BuildSolverRedeemTransactionAsync(HTLCRedeemTransactionBuilderRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+        var id = ParseHexBytes32(request.Hashlock);
+        var secret = ParseHexBytes32(request.Secret);
+        var signerAddress = GetFirstWalletAddress();
+
+        // Read PDA to get sender and src_receiver
+        var htlcAccount = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
+            {
+                NodeUrl = nodeUrl,
+                Id = id
+            }),
+            DefaultLocalActivityOptions);
+
+        if (htlcAccount == null)
+            throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
+
+        var unsignedTxBase64 = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.BuildHTLCRedeemTransactionAsync(new SolanaBuildHTLCRedeemRequest
+            {
+                NodeUrl = nodeUrl,
+                SignerAddress = signerAddress,
+                SenderAddress = htlcAccount.Sender,
+                SrcReceiverAddress = htlcAccount.SrcReceiver,
+                Id = id,
+                Secret = secret,
+                RecentBlockhash = string.Empty
+            }),
+            DefaultLocalActivityOptions);
+
+        return new PrepareTransactionDto
+        {
+            Data = unsignedTxBase64,
+            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ContractAddress = request.ContractAddress,
+            Type = TransactionType.HTLCRedeem,
+            Amount = 0
+        };
+    }
+
+    [WorkflowUpdate]
+    public async Task<PrepareTransactionDto> BuildUserRedeemTransactionAsync(HTLCRedeemTransactionBuilderRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+        var id = ParseHexBytes32(request.Hashlock);
+        var secret = ParseHexBytes32(request.Secret);
+        var signerAddress = GetFirstWalletAddress();
+
+        var htlcAccount = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
+            {
+                NodeUrl = nodeUrl,
+                Id = id
+            }),
+            DefaultLocalActivityOptions);
+
+        if (htlcAccount == null)
+            throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
+
+        var unsignedTxBase64 = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.BuildHTLCRedeemTransactionAsync(new SolanaBuildHTLCRedeemRequest
+            {
+                NodeUrl = nodeUrl,
+                SignerAddress = signerAddress,
+                SenderAddress = htlcAccount.Sender,
+                SrcReceiverAddress = htlcAccount.SrcReceiver,
+                Id = id,
+                Secret = secret,
+                RecentBlockhash = string.Empty
+            }),
+            DefaultLocalActivityOptions);
+
+        return new PrepareTransactionDto
+        {
+            Data = unsignedTxBase64,
+            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ContractAddress = request.ContractAddress,
+            Type = TransactionType.UserHTLCRedeem,
+            Amount = 0
+        };
+    }
+
+    [WorkflowUpdate]
+    public async Task<PrepareTransactionDto> BuildSolverRefundTransactionAsync(HTLCRefundTransactionPrepareRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+        var id = ParseHexBytes32(request.Hashlock);
+        var signerAddress = GetFirstWalletAddress();
+
+        var htlcAccount = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
+            {
+                NodeUrl = nodeUrl,
+                Id = id
+            }),
+            DefaultLocalActivityOptions);
+
+        if (htlcAccount == null)
+            throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
+
+        var unsignedTxBase64 = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.BuildHTLCRefundTransactionAsync(new SolanaBuildHTLCRefundRequest
+            {
+                NodeUrl = nodeUrl,
+                SignerAddress = signerAddress,
+                SenderAddress = htlcAccount.Sender,
+                Id = id,
+                RecentBlockhash = string.Empty
+            }),
+            DefaultLocalActivityOptions);
+
+        return new PrepareTransactionDto
+        {
+            Data = unsignedTxBase64,
+            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ContractAddress = request.ContractAddress,
+            Type = TransactionType.HTLCRefund,
+            Amount = 0
+        };
+    }
+
+    [WorkflowUpdate]
+    public async Task<PrepareTransactionDto> BuildUserRefundTransactionAsync(HTLCRefundTransactionPrepareRequest request)
+    {
+        _operationCount++;
+        var nodeUrl = GetNodeUrl();
+        var id = ParseHexBytes32(request.Hashlock);
+        var signerAddress = GetFirstWalletAddress();
+
+        var htlcAccount = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
+            {
+                NodeUrl = nodeUrl,
+                Id = id
+            }),
+            DefaultLocalActivityOptions);
+
+        if (htlcAccount == null)
+            throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
+
+        var unsignedTxBase64 = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.BuildHTLCRefundTransactionAsync(new SolanaBuildHTLCRefundRequest
+            {
+                NodeUrl = nodeUrl,
+                SignerAddress = signerAddress,
+                SenderAddress = htlcAccount.Sender,
+                Id = id,
+                RecentBlockhash = string.Empty
+            }),
+            DefaultLocalActivityOptions);
+
+        return new PrepareTransactionDto
+        {
+            Data = unsignedTxBase64,
+            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ContractAddress = request.ContractAddress,
+            Type = TransactionType.UserHTLCRefund,
+            Amount = 0
+        };
+    }
+
+    [WorkflowUpdate]
+    public Task<TransactionResponse> GetTransactionAsync(GetTransactionRequest request)
+    {
+        throw new NotSupportedException("GetTransaction not yet implemented for Solana");
+    }
+
+    [WorkflowUpdate]
+    public Task<PublishTransactionResponse> PublishUserLockTransactionAsync(PublishTransactionRequest request)
+    {
+        throw new NotSupportedException("PublishUserLockTransaction not supported on Solana");
+    }
+
+    #endregion
+
+    #region Signal Handlers
+
+    [WorkflowSignal]
+    public async Task SoftRestartInfrastructureAsync()
+    {
+        // Signal all listeners to restart
+        foreach (var listener in _activeListeners)
+        {
+            try
+            {
+                var handle = GetExternalWorkflowHandle(listener.ListenerId);
+                await handle.SignalAsync("RequestRestart", Array.Empty<object>());
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex, "Failed to signal restart to listener {ListenerId}", listener.ListenerId);
+            }
+        }
+
+        // Signal all TPs to restart
+        foreach (var tpId in _activeTransactionProcessorIds)
+        {
+            try
+            {
+                var handle = GetExternalWorkflowHandle(tpId);
+                await handle.SignalAsync("RequestRestart", Array.Empty<object>());
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex, "Failed to signal restart to TP {TpId}", tpId);
+            }
+        }
+    }
+
+    [WorkflowSignal]
+    public Task RestartInfrastructureAsync()
+    {
+        _restartRequested = true;
+        return Task.CompletedTask;
+    }
+
+    #endregion
+
+    #region Queries
+
+    [WorkflowQuery]
+    public string GetNetworkSlug() => _networkSlug;
+
+    [WorkflowQuery]
+    public NetworkRuntimeHealth GetHealth() => new()
+    {
+        IsRunning = _initialized,
+        NetworkSlug = _networkSlug,
+        OperationCount = _operationCount,
+        ActiveListenerCount = _activeListeners.Count,
+        ActiveTransactionProcessorCount = _activeTransactionProcessorIds.Count,
+        LastHealthCheckTime = _lastHealthCheckTime
+    };
+
+    #endregion
+
+    #region Helpers
+
+    private string GetNodeUrl()
+    {
+        var httpNodes = _network?.HttpNodes?.ToList();
+        if (httpNodes == null || httpNodes.Count == 0)
+            throw new Exception($"No HTTP nodes configured for network {_networkSlug}");
+        return httpNodes[0].Url;
+    }
+
+    private NetworkRuntimeArgs BuildContinueAsNewArgs() => new()
+    {
+        NetworkSlug = _networkSlug,
+        ActiveListeners = new List<ActiveListener>(_activeListeners),
+        ActiveTransactionProcessorIds = [.. _activeTransactionProcessorIds],
+        ActiveFilterAddresses = _activeFilterAddresses
+    };
+
+    private string GetFirstWalletAddress()
+    {
+        if (_activeFilterAddresses.Length == 0)
+            throw new Exception($"No wallet addresses available for network {_networkSlug}");
+        return _activeFilterAddresses[0];
+    }
+
+    private static byte[] ParseHexBytes32(string hexString)
+    {
+        var trimmed = hexString.StartsWith("0x", StringComparison.OrdinalIgnoreCase)
+            ? hexString[2..]
+            : hexString;
+        return Convert.FromHexString(trimmed);
+    }
+
+    #endregion
+}
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs b/csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs
new file mode 100644
index 00000000..ecb4d955
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs
@@ -0,0 +1,229 @@
+using Temporalio.Workflows;
+using Train.Solver.Workflow.Abstractions;
+using Train.Solver.Workflow.Abstractions.Activities;
+using Train.Solver.Workflow.Abstractions.Events;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Common.Extensions;
+using Train.Solver.Workflow.Common.Helpers;
+using Train.Solver.Workflow.Solana.Activities;
+using Train.Solver.Workflow.Solana.Helpers;
+using Train.Solver.Workflow.Solana.Models;
+using CommonConstants = Train.Solver.Workflow.Common.Constants;
+using static Temporalio.Workflows.Workflow;
+
+namespace Train.Solver.Workflow.Solana.Workflows;
+
+[Workflow(name: NetworkWorkflowNames.RPCLogEventListener)]
+public interface ISolanaRPCEventListener : IEventListener { }
+
+[Workflow(name: NetworkWorkflowNames.RPCLogEventListener,
+    FailureExceptionTypes = [typeof(Temporalio.Exceptions.WorkflowNondeterminismException)])]
+public class SolanaRPCEventListener : SolanaEventListenerBase, ISolanaRPCEventListener
+{
+    private const int MaxIterationsBeforeContinueAsNew = 50;
+    private const int CheckpointSaveInterval = 3;
+
+    [WorkflowRun]
+    public async Task RunAsync(EventListenerArgs args)
+    {
+        await InitializeFromArgsAsync(args);
+
+        var iteration = 0;
+
+        // Fetch network config
+        var network = await ExecuteActivityAsync(
+            (INetworkActivities x) => x.GetNetworkAsync(args.NetworkSlug),
+            new ActivityOptions
+            {
+                TaskQueue = CommonConstants.CoreTaskQueue,
+                StartToCloseTimeout = TimeSpan.FromSeconds(20),
+                ScheduleToCloseTimeout = TimeSpan.FromMinutes(20),
+                RetryPolicy = new()
+                {
+                    InitialInterval = TimeSpan.FromSeconds(5),
+                    BackoffCoefficient = 1f,
+                }
+            });
+
+        var listenerConfig = network.EventListenerConfigs?
+            .FirstOrDefault(c => c.ListenerType == NetworkWorkflowNames.RPCLogEventListener);
+        var waitInterval = listenerConfig?.GetIntSetting("PollingIntervalSeconds", 5) ?? 5;
+
+        // Get first HTTP node URL
+        var nodeUrl = network.Nodes?
+            .FirstOrDefault(n => !n.Url.StartsWith("ws", StringComparison.OrdinalIgnoreCase))?.Url;
+
+        if (string.IsNullOrEmpty(nodeUrl))
+        {
+            Logger.LogError("No HTTP node available for {Network}", args.NetworkSlug);
+            throw CreateContinueAsNewException<SolanaRPCEventListener>(x => x.RunAsync(BuildContinueAsNewArgs()));
+        }
+
+        while (!Temporalio.Workflows.Workflow.CancellationToken.IsCancellationRequested)
+        {
+            CurrentDetails = $"Polling HTLC events on {args.NetworkSlug} | slot: {_lastProcessedSlot} | {_subscriptions.Count} subs";
+
+            if (iteration >= MaxIterationsBeforeContinueAsNew || _restartRequested)
+            {
+                await SaveCheckpointAsync();
+                throw CreateContinueAsNewException<SolanaRPCEventListener>(x => x.RunAsync(BuildContinueAsNewArgs()));
+            }
+
+            if (iteration > 0 && iteration % CheckpointSaveInterval == 0)
+            {
+                await SaveCheckpointAsync();
+            }
+
+            try
+            {
+                await PollAndProcessEventsAsync(network.Slug, nodeUrl, waitInterval);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError(ex, "Error in Solana RPC event listener for {Network}, continuing as new", args.NetworkSlug);
+                await SaveCheckpointAsync();
+                throw CreateContinueAsNewException<SolanaRPCEventListener>(x => x.RunAsync(BuildContinueAsNewArgs()));
+            }
+
+            iteration++;
+        }
+    }
+
+    private async Task PollAndProcessEventsAsync(string networkSlug, string nodeUrl, int waitInterval)
+    {
+        if (_subscriptions.Count == 0)
+        {
+            await DelayAsync(TimeSpan.FromSeconds(waitInterval));
+            return;
+        }
+
+        // Get solver wallet addresses from subscriptions' filter addresses
+        var solverWalletAddresses = _subscriptions
+            .Where(s => s.EventType == EventTypes.UserTokenLocked)
+            .SelectMany(s => s.FilterAddresses ?? [])
+            .Distinct()
+            .ToList();
+
+        var result = await ExecuteActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetHTLCEventsAsync(new SolanaGetHTLCEventsRequest
+            {
+                ProgramId = SolanaHelper.HTLCProgramId,
+                NodeUrl = nodeUrl,
+                NetworkSlug = networkSlug,
+                LastSignature = _lastProcessedSignature,
+                SolverWalletAddresses = solverWalletAddresses,
+            }),
+            TemporalHelper.DefaultActivityOptions(null));
+
+        // Process locked events
+        foreach (var locked in result.LockedEvents)
+        {
+            var key = $"locked:{locked.TxSignature}";
+            if (!TryMarkProcessed(key))
+                continue;
+
+            var eventType = locked.IsUserLock
+                ? EventTypes.UserTokenLocked
+                : EventTypes.SolverTokenLocked;
+
+            // For user locks, check filter addresses (solver must be srcReceiver)
+            if (locked.IsUserLock && !MatchesFilterAddresses(EventTypes.UserTokenLocked, locked.SrcReceiver))
+                continue;
+
+            await EmitEventAsync(eventType, new TokenLockedEvent
+            {
+                Id = NewGuid().ToString(),
+                Source = ListenerTypeName,
+                NetworkName = networkSlug,
+                TransactionId = locked.TxSignature,
+                HashLock = locked.Hashlock,
+                TimeLock = locked.Timelock,
+                Sender = locked.Sender,
+                SrcReceiver = locked.SrcReceiver,
+                Token = locked.SrcAsset,
+                Amount = locked.Amount.ToString(),
+                Reward = locked.Reward.ToString(),
+                RewardTimelock = locked.RewardTimelock,
+                DstChain = locked.DstChain,
+                DstAddress = locked.DstAddress,
+                DstToken = locked.DstAsset,
+                BlockNumber = locked.Slot,
+            }, locked.Hashlock);
+        }
+
+        // Process redeemed events
+        foreach (var redeemed in result.RedeemedEvents)
+        {
+            var key = $"redeemed:{redeemed.TxSignature}";
+            if (!TryMarkProcessed(key))
+                continue;
+
+            // IsSolverLock = solver's lock was redeemed (user redeemed it) → UserTokenRedeemed
+            var eventType = redeemed.IsSolverLock
+                ? EventTypes.UserTokenRedeemed
+                : EventTypes.SolverTokenRedeemed;
+
+            await EmitEventAsync(eventType, new TokenRedeemedEvent
+            {
+                Id = NewGuid().ToString(),
+                Source = ListenerTypeName,
+                NetworkName = networkSlug,
+                TransactionId = redeemed.TxSignature,
+                Hashlock = redeemed.Hashlock,
+                Secret = redeemed.Secret,
+                RedeemAddress = redeemed.RedeemAddress,
+                BlockNumber = redeemed.Slot,
+            }, redeemed.Hashlock);
+        }
+
+        // Process refunded events
+        foreach (var refunded in result.RefundedEvents)
+        {
+            var key = $"refunded:{refunded.TxSignature}";
+            if (!TryMarkProcessed(key))
+                continue;
+
+            var eventType = refunded.IsSolverLock
+                ? EventTypes.SolverTokenRefunded
+                : EventTypes.UserTokenRefunded;
+
+            await EmitEventAsync(eventType, new TokenRefundedEvent
+            {
+                Id = NewGuid().ToString(),
+                Source = ListenerTypeName,
+                NetworkName = networkSlug,
+                TransactionId = refunded.TxSignature,
+                Hashlock = refunded.Hashlock,
+                BlockNumber = refunded.Slot,
+            }, refunded.Hashlock);
+        }
+
+        // Update pagination state
+        if (!string.IsNullOrEmpty(result.LastProcessedSignature))
+        {
+            _lastProcessedSignature = result.LastProcessedSignature;
+            _lastProcessedSlot = result.LastProcessedSlot;
+        }
+
+        TrimProcessedHashesIfNeeded();
+
+        await DelayAsync(TimeSpan.FromSeconds(waitInterval));
+    }
+
+    #region Temporal Signal & Query Overrides
+
+    [WorkflowSignal]
+    public override Task UpdateSubscriptionsAsync(List<EventSubscription> subscriptions)
+        => base.UpdateSubscriptionsAsync(subscriptions);
+
+    [WorkflowSignal]
+    public override Task RequestRestartAsync() => base.RequestRestartAsync();
+
+    [WorkflowQuery]
+    public override IReadOnlyCollection<EventSubscription> GetSubscriptions() => base.GetSubscriptions();
+
+    [WorkflowQuery]
+    public override ulong? GetLastProcessedBlock() => base.GetLastProcessedBlock();
+
+    #endregion
+}
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs b/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
new file mode 100644
index 00000000..4b146fd3
--- /dev/null
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
@@ -0,0 +1,935 @@
+using Temporalio.Workflows;
+using Train.Solver.Shared.Models;
+using Train.Solver.Workflow.Abstractions;
+using Train.Solver.Workflow.Abstractions.Activities;
+using Train.Solver.Workflow.Abstractions.Workflows;
+using Train.Solver.Workflow.Common.Helpers;
+using Train.Solver.Workflow.Solana.Activities;
+using Train.Solver.Workflow.Solana.Models;
+using static Temporalio.Workflows.Workflow;
+using Constants = Train.Solver.Workflow.Common.Constants;
+
+namespace Train.Solver.Workflow.Solana.Workflows;
+
+[Workflow(name: NetworkWorkflowNames.TransactionProcessor,
+    FailureExceptionTypes = [typeof(Temporalio.Exceptions.WorkflowNondeterminismException)])]
+public class SolanaTransactionProcessor : ITransactionProcessor
+{
+    private const int MaxIterationsBeforeContinueAsNew = 50;
+    private const int MaxRecentEvents = 50;
+    private const int MaxProcessedCorrelationIds = 500;
+    private const int DefaultMaxInFlightTransactions = 10;
+    private const int DefaultStuckTimeoutSeconds = 120;
+    private const int DefaultPollingIntervalSeconds = 5;
+    private const int MaxRetries = 3;
+    private const double PriorityFeeEscalationMultiplier = 1.5;
+    private const ulong DefaultPriorityFeeMicroLamports = 1000;
+
+    private List<SolanaQueuedRequest> _queuedRequests = [];
+    private List<SolanaPendingTransaction> _pendingTransactions = [];
+    private List<SolanaInFlightTransaction> _inFlightTransactions = [];
+    private List<string> _processedCorrelationIds = [];
+    private NetworkWithTPConfigurationDto _network = null!;
+    private DetailedWalletDto _wallet = null!;
+    private string _signerAgentUrl = string.Empty;
+    private bool _initialized;
+    private bool _restartRequested;
+    private int _iteration;
+    private string _processorId = string.Empty;
+
+    private int _maxInFlightTransactions;
+    private int _stuckTimeoutSeconds;
+    private int _pollingIntervalSeconds;
+
+    // Debug counters and event log
+    private int _totalReceived;
+    private int _totalPublished;
+    private int _totalConfirmed;
+    private int _totalFailed;
+    private int _totalRetries;
+    private readonly List<string> _recentEvents = [];
+
+    [WorkflowRun]
+    public async Task RunAsync(SolanaTransactionProcessorArgs args)
+    {
+        _queuedRequests = [.. args.QueuedRequests];
+        _pendingTransactions = [.. args.PendingTransactions];
+        _inFlightTransactions = [.. args.InFlightTransactions];
+        _processedCorrelationIds = [.. args.ProcessedCorrelationIds];
+        _signerAgentUrl = args.SignerAgentUrl;
+
+        _network = await ExecuteActivityAsync(
+            (INetworkActivities x) => x.GetNetworkForTransactionProcessorAsync(args.NetworkSlug),
+            TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+        LoadConfiguration();
+
+        _wallet = await ExecuteActivityAsync(
+            (IWalletActivities x) => x.GetWalletAsync(_network.Type.Name, args.WalletAddress),
+            TemporalHelper.DefaultActivityOptions(Constants.CoreTaskQueue));
+
+        _initialized = true;
+        _processorId = TemporalHelper.BuildTransactionProcessorId(args.NetworkSlug, args.WalletAddress);
+
+        // If args have empty state, try restoring from Redis
+        if (_queuedRequests.Count == 0 && _pendingTransactions.Count == 0 && _inFlightTransactions.Count == 0)
+        {
+            try
+            {
+                var snapshot = await ExecuteLocalActivityAsync(
+                    (ISolanaWorkflowActivities x) => x.LoadTransactionStateAsync(_network.Slug, _wallet.Address),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(10), 3));
+
+                if (snapshot != null)
+                {
+                    _queuedRequests = [.. snapshot.QueuedRequests];
+                    _pendingTransactions = [.. snapshot.PendingTransactions];
+                    _inFlightTransactions = [.. snapshot.InFlightTransactions];
+                    _processedCorrelationIds = [.. snapshot.ProcessedCorrelationIds];
+                    RecordEvent($"Restored state from Redis: {_queuedRequests.Count} queued, {_pendingTransactions.Count} pending, {_inFlightTransactions.Count} in-flight");
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex, "[SolanaTP:{Network}] Failed to load state from Redis", _network.Slug);
+            }
+        }
+
+        _iteration = 0;
+
+        RecordEvent($"Initialized | wallet={_wallet.Address} | maxInFlight={_maxInFlightTransactions} | stuckTimeout={_stuckTimeoutSeconds}s | carried over {_queuedRequests.Count} queued, {_pendingTransactions.Count} pending, {_inFlightTransactions.Count} in-flight");
+
+        while (!Temporalio.Workflows.Workflow.CancellationToken.IsCancellationRequested)
+        {
+            if (_iteration >= MaxIterationsBeforeContinueAsNew || _restartRequested)
+            {
+                RecordEvent($"ContinueAsNew ({(_restartRequested ? "requested" : $"iteration {_iteration}")})");
+                await SaveStateAsync();
+                throw CreateContinueAsNewException<SolanaTransactionProcessor>(x => x.RunAsync(BuildContinueAsNewArgs()));
+            }
+
+            try
+            {
+                // Check in-flight transactions for confirmation
+                await CheckInFlightTransactionsAsync();
+
+                // Process queued requests when capacity is available
+                await ProcessQueuedRequestsAsync();
+
+                // Publish pending transactions
+                await PublishPendingTransactionsAsync();
+
+                // Check confirmations immediately after publishing
+                if (_inFlightTransactions.Count > 0)
+                    await CheckInFlightTransactionsAsync();
+
+                var pollingInterval = _inFlightTransactions.Count > 0
+                    ? TimeSpan.FromSeconds(_pollingIntervalSeconds)
+                    : TimeSpan.FromHours(1);
+
+                var sigList = string.Join(",", _inFlightTransactions.Select(t => t.TxSignature[..Math.Min(8, t.TxSignature.Length)]));
+                CurrentDetails = _inFlightTransactions.Count > 0
+                    ? $"{_network.Slug} | q={_queuedRequests.Count} | {_inFlightTransactions.Count} in-flight ({sigList}) | iter={_iteration}"
+                    : $"{_network.Slug} | q={_queuedRequests.Count} | idle | iter={_iteration} | ok={_totalConfirmed} fail={_totalFailed} retry={_totalRetries}";
+
+                await WaitConditionAsync(
+                    () => _queuedRequests.Count > 0 || _pendingTransactions.Count > 0,
+                    pollingInterval);
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                RecordEvent($"Loop error at iteration {_iteration}: {ex.Message}");
+                throw CreateContinueAsNewException<SolanaTransactionProcessor>(x => x.RunAsync(BuildContinueAsNewArgs()));
+            }
+
+            _iteration++;
+            await SaveStateAsync();
+        }
+    }
+
+    #region Signal Handlers
+
+    [WorkflowSignal]
+    public Task SubmitLockAsync(LockTransactionRequest request)
+    {
+        if (IsKnownCorrelationId(request.CorrelationId))
+        {
+            RecordEvent($"DEDUP HTLCLock | corr={request.CorrelationId} | already known");
+            return Task.CompletedTask;
+        }
+
+        _totalReceived++;
+        RecordEvent($"QUEUED HTLCLock | corr={request.CorrelationId} | hashlock={request.Hashlock[..Math.Min(16, request.Hashlock.Length)]}");
+        _queuedRequests.Add(new SolanaQueuedRequest
+        {
+            CorrelationId = request.CorrelationId,
+            Callback = request.Callback,
+            Type = TransactionType.HTLCLock,
+            SenderAddress = request.Sender,
+            TokenContract = request.TokenContract,
+            LockRequest = request
+        });
+        return Task.CompletedTask;
+    }
+
+    [WorkflowSignal]
+    public Task SubmitRedeemAsync(RedeemTransactionRequest request)
+    {
+        if (IsKnownCorrelationId(request.CorrelationId))
+        {
+            RecordEvent($"DEDUP HTLCRedeem | corr={request.CorrelationId} | already known");
+            return Task.CompletedTask;
+        }
+
+        _totalReceived++;
+        RecordEvent($"QUEUED HTLCRedeem | corr={request.CorrelationId} | hashlock={request.Hashlock[..Math.Min(16, request.Hashlock.Length)]}");
+        _queuedRequests.Add(new SolanaQueuedRequest
+        {
+            CorrelationId = request.CorrelationId,
+            Callback = request.Callback,
+            Type = TransactionType.HTLCRedeem,
+            SenderAddress = request.Sender,
+            TokenContract = request.TokenContract,
+            RedeemRequest = request
+        });
+        return Task.CompletedTask;
+    }
+
+    [WorkflowSignal]
+    public Task SubmitRefundAsync(RefundTransactionRequest request)
+    {
+        if (IsKnownCorrelationId(request.CorrelationId))
+        {
+            RecordEvent($"DEDUP HTLCRefund | corr={request.CorrelationId} | already known");
+            return Task.CompletedTask;
+        }
+
+        _totalReceived++;
+        RecordEvent($"QUEUED HTLCRefund | corr={request.CorrelationId} | hashlock={request.Hashlock[..Math.Min(16, request.Hashlock.Length)]}");
+        _queuedRequests.Add(new SolanaQueuedRequest
+        {
+            CorrelationId = request.CorrelationId,
+            Callback = request.Callback,
+            Type = TransactionType.HTLCRefund,
+            SenderAddress = request.Sender,
+            TokenContract = request.TokenContract,
+            RefundRequest = request
+        });
+        return Task.CompletedTask;
+    }
+
+    [WorkflowSignal]
+    public Task SubmitUserRefundAsync(RefundTransactionRequest request)
+    {
+        if (IsKnownCorrelationId(request.CorrelationId))
+        {
+            RecordEvent($"DEDUP UserHTLCRefund | corr={request.CorrelationId} | already known");
+            return Task.CompletedTask;
+        }
+
+        _totalReceived++;
+        RecordEvent($"QUEUED UserHTLCRefund | corr={request.CorrelationId} | hashlock={request.Hashlock[..Math.Min(16, request.Hashlock.Length)]}");
+        _queuedRequests.Add(new SolanaQueuedRequest
+        {
+            CorrelationId = request.CorrelationId,
+            Callback = request.Callback,
+            Type = TransactionType.UserHTLCRefund,
+            SenderAddress = request.Sender,
+            TokenContract = request.TokenContract,
+            RefundRequest = request
+        });
+        return Task.CompletedTask;
+    }
+
+    [WorkflowSignal]
+    public Task SubmitTransferAsync(TransferTransactionRequest request)
+    {
+        if (IsKnownCorrelationId(request.CorrelationId))
+        {
+            RecordEvent($"DEDUP Transfer | corr={request.CorrelationId} | already known");
+            return Task.CompletedTask;
+        }
+
+        _totalReceived++;
+        RecordEvent($"QUEUED Transfer | corr={request.CorrelationId} | callback={request.Callback.WorkflowId}");
+        _queuedRequests.Add(new SolanaQueuedRequest
+        {
+            CorrelationId = request.CorrelationId,
+            Callback = request.Callback,
+            Type = TransactionType.Transfer,
+            SenderAddress = request.Sender,
+            TokenContract = request.TokenContract,
+            TransferRequest = request
+        });
+        return Task.CompletedTask;
+    }
+
+    [WorkflowSignal]
+    public async Task SubmitApproveAsync(ApproveTransactionRequest request)
+    {
+        RecordEvent($"REJECTED Approve | corr={request.CorrelationId} | Approve not applicable on Solana");
+        await SignalFailureAsync(request.Callback, request.CorrelationId, "Approve not applicable on Solana");
+    }
+
+    [WorkflowSignal]
+    public async Task SubmitCustomAsync(CustomTransactionRequest request)
+    {
+        RecordEvent($"REJECTED Custom | corr={request.CorrelationId} | Custom transactions not supported on Solana");
+        await SignalFailureAsync(request.Callback, request.CorrelationId, "Custom transactions not supported on Solana");
+    }
+
+    [WorkflowSignal]
+    public Task ForceUnreserveOrphanedAsync(long nonce)
+    {
+        RecordEvent($"ForceUnreserveOrphaned ignored (not applicable on Solana)");
+        return Task.CompletedTask;
+    }
+
+    [WorkflowSignal]
+    public Task RequestRestartAsync()
+    {
+        _restartRequested = true;
+        return Task.CompletedTask;
+    }
+
+    #endregion
+
+    #region Queries
+
+    [WorkflowQuery]
+    public TransactionProcessorHealth GetHealth() => new()
+    {
+        IsRunning = _initialized,
+        NetworkSlug = _network?.Slug ?? "",
+        WalletAddress = _wallet?.Address ?? "",
+        QueuedCount = _queuedRequests.Count,
+        PendingCount = _pendingTransactions.Count,
+        InFlightCount = _inFlightTransactions.Count,
+        OrphanedCount = 0
+    };
+
+    [WorkflowQuery]
+    public int GetPendingCount() => _pendingTransactions.Count;
+
+    [WorkflowQuery]
+    public TransactionProcessorDetailedStatus GetDetailedStatus() => new()
+    {
+        NetworkSlug = _network?.Slug ?? "",
+        WalletAddress = _wallet?.Address ?? "",
+        IsInitialized = _initialized,
+        Iteration = _iteration,
+        MaxInFlightTransactions = _maxInFlightTransactions,
+        StuckTransactionTimeoutSeconds = _stuckTimeoutSeconds,
+        MaxGasBumpAttempts = MaxRetries,
+        ConfirmationPollingIntervalSeconds = _pollingIntervalSeconds,
+        TotalReceived = _totalReceived,
+        TotalPublished = _totalPublished,
+        TotalConfirmed = _totalConfirmed,
+        TotalFailed = _totalFailed,
+        QueuedCount = _queuedRequests.Count,
+        PendingTransactions = _pendingTransactions.Select((p, i) => new PendingTransactionInfo
+        {
+            CorrelationId = p.CorrelationId,
+            Nonce = $"bh:{p.LastValidBlockHeight}",
+            Type = p.Type.ToString(),
+            CallbackWorkflowId = p.Callback.WorkflowId,
+            QueuePosition = i
+        }).ToList(),
+        InFlightTransactions = _inFlightTransactions.Select(f => new InFlightTransactionInfo
+        {
+            CorrelationId = f.CorrelationId,
+            Nonce = $"bh:{f.LastValidBlockHeight}",
+            Type = f.Type.ToString(),
+            TxHashes = [f.TxSignature],
+            PublishedAt = f.PublishedAt,
+            ElapsedSeconds = (Temporalio.Workflows.Workflow.UtcNow - f.PublishedAt).TotalSeconds,
+            GasBumpCount = f.RetryCount,
+            CallbackWorkflowId = f.Callback.WorkflowId,
+            IsOrphaned = false,
+            Status = $"InFlight (retry {f.RetryCount}/{MaxRetries})"
+        }).ToList(),
+        RecentEvents = [.. _recentEvents]
+    };
+
+    #endregion
+
+    #region Pipeline
+
+    private async Task ProcessQueuedRequestsAsync()
+    {
+        var capacity = _maxInFlightTransactions - _inFlightTransactions.Count - _pendingTransactions.Count;
+        if (capacity <= 0 || _queuedRequests.Count == 0) return;
+
+        var toProcess = _queuedRequests.Take(capacity).ToList();
+
+        foreach (var queued in toProcess)
+        {
+            try
+            {
+                var nodeUrl = GetNodeUrl();
+
+                // Get latest blockhash
+                var blockhashInfo = await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.GetLatestBlockhashAsync(nodeUrl),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
+
+                // Determine priority fee: use escalated fee on retry, otherwise fetch fresh estimate
+                var priorityFee = await GetPriorityFeeAsync(nodeUrl, queued.PriorityFeeMicroLamports);
+
+                // Build unsigned transaction based on type
+                var unsignedTxBase64 = await BuildUnsignedTransactionForQueuedAsync(queued, nodeUrl, blockhashInfo.Blockhash, priorityFee);
+
+                // Sign via treasury
+                var signedTxBase64 = await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.SignTransactionAsync(new SolanaSignRequest
+                    {
+                        SignerAgentUrl = _signerAgentUrl,
+                        WalletAddress = _wallet.Address,
+                        UnsignedTxBase64 = unsignedTxBase64
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
+
+                _pendingTransactions.Add(new SolanaPendingTransaction
+                {
+                    CorrelationId = queued.CorrelationId,
+                    Callback = queued.Callback,
+                    Type = queued.Type,
+                    SenderAddress = queued.SenderAddress,
+                    TokenContract = queued.TokenContract,
+                    LastValidBlockHeight = blockhashInfo.LastValidBlockHeight,
+                    PriorityFeeMicroLamports = priorityFee,
+                    RetryCount = queued.RetryCount,
+                    TransferRequest = queued.TransferRequest,
+                    LockRequest = queued.LockRequest,
+                    RedeemRequest = queued.RedeemRequest,
+                    RefundRequest = queued.RefundRequest,
+                    SignedTxBase64 = signedTxBase64
+                });
+
+                _queuedRequests.Remove(queued);
+                RecordEvent($"PREPARED {queued.Type} | corr={queued.CorrelationId} | bh={blockhashInfo.Blockhash[..8]} | fee={priorityFee}µL | retry={queued.RetryCount}");
+            }
+            catch (Exception ex)
+            {
+                RecordEvent($"PREPARE FAILED {queued.Type} | corr={queued.CorrelationId} | {ex.Message}");
+                await SignalFailureAsync(queued.Callback, queued.CorrelationId, ex.Message);
+                _queuedRequests.Remove(queued);
+                TrackCorrelationId(queued.CorrelationId);
+                _totalFailed++;
+            }
+        }
+    }
+
+    private async Task PublishPendingTransactionsAsync()
+    {
+        var toPublish = _pendingTransactions.ToList();
+
+        foreach (var pending in toPublish)
+        {
+            try
+            {
+                var nodeUrl = GetNodeUrl();
+                var publishResult = await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.PublishTransactionAsync(new SolanaPublishRequest
+                    {
+                        NodeUrl = nodeUrl,
+                        SignedTxBase64 = pending.SignedTxBase64
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
+
+                if (publishResult.Outcome == SolanaPublishOutcome.Published && publishResult.TxSignature != null)
+                {
+                    _inFlightTransactions.Add(new SolanaInFlightTransaction
+                    {
+                        CorrelationId = pending.CorrelationId,
+                        Callback = pending.Callback,
+                        Type = pending.Type,
+                        SenderAddress = pending.SenderAddress,
+                        TokenContract = pending.TokenContract,
+                        LastValidBlockHeight = pending.LastValidBlockHeight,
+                        PriorityFeeMicroLamports = pending.PriorityFeeMicroLamports,
+                        RetryCount = pending.RetryCount,
+                        TransferRequest = pending.TransferRequest,
+                        LockRequest = pending.LockRequest,
+                        RedeemRequest = pending.RedeemRequest,
+                        RefundRequest = pending.RefundRequest,
+                        TxSignature = publishResult.TxSignature,
+                        PublishedAt = Temporalio.Workflows.Workflow.UtcNow
+                    });
+
+                    _pendingTransactions.Remove(pending);
+                    _totalPublished++;
+                    RecordEvent($"PUBLISHED {pending.Type} | corr={pending.CorrelationId} | sig={publishResult.TxSignature[..Math.Min(16, publishResult.TxSignature.Length)]}");
+                }
+                else if (publishResult.Outcome == SolanaPublishOutcome.BlockhashNotFound)
+                {
+                    // Blockhash expired before we could publish — retry with new blockhash
+                    _pendingTransactions.Remove(pending);
+                    if (pending.RetryCount < MaxRetries && HasRetryableRequest(pending))
+                    {
+                        RequeueForRetry(pending);
+                        RecordEvent($"BLOCKHASH EXPIRED (publish) {pending.Type} | corr={pending.CorrelationId} | requeued retry={pending.RetryCount + 1}");
+                    }
+                    else
+                    {
+                        await SignalFailureAsync(pending.Callback, pending.CorrelationId,
+                            publishResult.ErrorMessage ?? "Blockhash expired, max retries reached");
+                        TrackCorrelationId(pending.CorrelationId);
+                        _totalFailed++;
+                    }
+                }
+                else if (publishResult.Outcome == SolanaPublishOutcome.DuplicateTransaction)
+                {
+                    RecordEvent($"DUPLICATE {pending.Type} | corr={pending.CorrelationId} | {publishResult.ErrorMessage}");
+                    await SignalFailureAsync(pending.Callback, pending.CorrelationId, publishResult.ErrorMessage ?? "Duplicate transaction");
+                    _pendingTransactions.Remove(pending);
+                    TrackCorrelationId(pending.CorrelationId);
+                    _totalFailed++;
+                }
+                else
+                {
+                    RecordEvent($"PUBLISH FAILED {pending.Type} | corr={pending.CorrelationId} | {publishResult.Outcome}: {publishResult.ErrorMessage}");
+                    await SignalFailureAsync(pending.Callback, pending.CorrelationId, publishResult.ErrorMessage ?? "Publish failed");
+                    _pendingTransactions.Remove(pending);
+                    TrackCorrelationId(pending.CorrelationId);
+                    _totalFailed++;
+                }
+            }
+            catch (Exception ex)
+            {
+                RecordEvent($"PUBLISH ERROR {pending.Type} | corr={pending.CorrelationId} | {ex.Message}");
+                await SignalFailureAsync(pending.Callback, pending.CorrelationId, ex.Message);
+                _pendingTransactions.Remove(pending);
+                TrackCorrelationId(pending.CorrelationId);
+                _totalFailed++;
+            }
+        }
+    }
+
+    private async Task CheckInFlightTransactionsAsync()
+    {
+        if (_inFlightTransactions.Count == 0) return;
+
+        var nodeUrl = GetNodeUrl();
+        var signatures = _inFlightTransactions.Select(f => f.TxSignature).ToList();
+
+        List<SolanaSignatureStatus> statuses;
+        try
+        {
+            statuses = await ExecuteLocalActivityAsync(
+                (ISolanaBlockchainActivities x) => x.GetSignatureStatusesAsync(new SolanaGetSignatureStatusRequest
+                {
+                    NodeUrl = nodeUrl,
+                    TxSignatures = signatures
+                }),
+                GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
+        }
+        catch (Exception ex)
+        {
+            RecordEvent($"GetSignatureStatuses failed: {ex.Message}");
+            return;
+        }
+
+        // Fetch current block height for expiry check (fall back to time-only if RPC fails)
+        ulong? currentBlockHeight = null;
+        try
+        {
+            currentBlockHeight = await ExecuteLocalActivityAsync(
+                (ISolanaBlockchainActivities x) => x.GetBlockHeightAsync(nodeUrl),
+                GetLocalActivityOptions(TimeSpan.FromSeconds(10), 2));
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "[SolanaTP:{Network}] Failed to get block height, using time-only expiry", _network.Slug);
+        }
+
+        var toRemove = new List<SolanaInFlightTransaction>();
+
+        foreach (var inFlight in _inFlightTransactions)
+        {
+            var status = statuses.FirstOrDefault(s => s.TxSignature == inFlight.TxSignature);
+
+            if (status?.Confirmed == true && status.Failed != true)
+            {
+                // Confirmed successfully
+                RecordEvent($"CONFIRMED {inFlight.Type} | corr={inFlight.CorrelationId} | sig={inFlight.TxSignature[..Math.Min(16, inFlight.TxSignature.Length)]} | slot={status.Slot}");
+                await SignalSuccessAsync(inFlight.Callback, inFlight.CorrelationId, inFlight.TxSignature, status.Slot);
+                TrackCorrelationId(inFlight.CorrelationId);
+                toRemove.Add(inFlight);
+                _totalConfirmed++;
+            }
+            else if (status?.Failed == true)
+            {
+                // Transaction failed on-chain
+                RecordEvent($"ON-CHAIN FAIL {inFlight.Type} | corr={inFlight.CorrelationId} | {status.ErrorMessage}");
+                await SignalFailureAsync(inFlight.Callback, inFlight.CorrelationId, status.ErrorMessage ?? "Transaction failed on-chain");
+                TrackCorrelationId(inFlight.CorrelationId);
+                toRemove.Add(inFlight);
+                _totalFailed++;
+            }
+            else
+            {
+                // Still pending — check for blockhash expiry or timeout
+                var blockhashExpired = currentBlockHeight.HasValue && currentBlockHeight.Value > inFlight.LastValidBlockHeight;
+                var elapsed = (Temporalio.Workflows.Workflow.UtcNow - inFlight.PublishedAt).TotalSeconds;
+                var timedOut = elapsed > _stuckTimeoutSeconds;
+
+                if (blockhashExpired || timedOut)
+                {
+                    var reason = blockhashExpired ? $"blockhash expired (height {currentBlockHeight} > {inFlight.LastValidBlockHeight})" : $"timed out after {elapsed:F0}s";
+
+                    if (inFlight.RetryCount < MaxRetries && HasRetryableRequest(inFlight))
+                    {
+                        RecordEvent($"RETRY {inFlight.Type} | corr={inFlight.CorrelationId} | {reason} | retry={inFlight.RetryCount + 1}/{MaxRetries}");
+                        RequeueForRetry(inFlight);
+                        toRemove.Add(inFlight);
+                        _totalRetries++;
+                    }
+                    else
+                    {
+                        RecordEvent($"EXPIRED {inFlight.Type} | corr={inFlight.CorrelationId} | {reason} | retries exhausted");
+                        await SignalFailureAsync(inFlight.Callback, inFlight.CorrelationId, $"Transaction expired: {reason}");
+                        TrackCorrelationId(inFlight.CorrelationId);
+                        toRemove.Add(inFlight);
+                        _totalFailed++;
+                    }
+                }
+            }
+        }
+
+        foreach (var item in toRemove)
+            _inFlightTransactions.Remove(item);
+    }
+
+    #endregion
+
+    #region Retry Helpers
+
+    private void RequeueForRetry(SolanaPendingTransaction pending)
+    {
+        var escalatedFee = (ulong)(pending.PriorityFeeMicroLamports * PriorityFeeEscalationMultiplier);
+
+        _queuedRequests.Add(new SolanaQueuedRequest
+        {
+            CorrelationId = pending.CorrelationId,
+            Callback = pending.Callback,
+            Type = pending.Type,
+            SenderAddress = pending.SenderAddress,
+            TokenContract = pending.TokenContract,
+            TransferRequest = pending.TransferRequest,
+            LockRequest = pending.LockRequest,
+            RedeemRequest = pending.RedeemRequest,
+            RefundRequest = pending.RefundRequest,
+            RetryCount = pending.RetryCount + 1,
+            PriorityFeeMicroLamports = escalatedFee
+        });
+    }
+
+    private void RequeueForRetry(SolanaInFlightTransaction inFlight)
+    {
+        var escalatedFee = (ulong)(inFlight.PriorityFeeMicroLamports * PriorityFeeEscalationMultiplier);
+
+        _queuedRequests.Add(new SolanaQueuedRequest
+        {
+            CorrelationId = inFlight.CorrelationId,
+            Callback = inFlight.Callback,
+            Type = inFlight.Type,
+            SenderAddress = inFlight.SenderAddress,
+            TokenContract = inFlight.TokenContract,
+            TransferRequest = inFlight.TransferRequest,
+            LockRequest = inFlight.LockRequest,
+            RedeemRequest = inFlight.RedeemRequest,
+            RefundRequest = inFlight.RefundRequest,
+            RetryCount = inFlight.RetryCount + 1,
+            PriorityFeeMicroLamports = escalatedFee
+        });
+    }
+
+    #endregion
+
+    #region Helpers
+
+    private void LoadConfiguration()
+    {
+        var config = _network.TransactionProcessorConfiguration;
+        _maxInFlightTransactions = config.MaxInFlightTransactions > 0 ? config.MaxInFlightTransactions : DefaultMaxInFlightTransactions;
+        _stuckTimeoutSeconds = config.StuckTransactionTimeoutSeconds > 0 ? config.StuckTransactionTimeoutSeconds : DefaultStuckTimeoutSeconds;
+        _pollingIntervalSeconds = config.ConfirmationPollingIntervalSeconds > 0 ? config.ConfirmationPollingIntervalSeconds : DefaultPollingIntervalSeconds;
+    }
+
+    private string GetNodeUrl()
+    {
+        var httpNodes = _network.HttpNodes?.ToList();
+        if (httpNodes == null || httpNodes.Count == 0)
+            throw new Exception($"No HTTP nodes configured for network {_network.Slug}");
+        return httpNodes[0].Url;
+    }
+
+    private bool IsKnownCorrelationId(string correlationId)
+    {
+        if (_processedCorrelationIds.Contains(correlationId)) return true;
+        if (_queuedRequests.Any(q => q.CorrelationId == correlationId)) return true;
+        if (_pendingTransactions.Any(p => p.CorrelationId == correlationId)) return true;
+        if (_inFlightTransactions.Any(f => f.CorrelationId == correlationId)) return true;
+        return false;
+    }
+
+    private void TrackCorrelationId(string correlationId)
+    {
+        _processedCorrelationIds.Add(correlationId);
+        if (_processedCorrelationIds.Count > MaxProcessedCorrelationIds)
+            _processedCorrelationIds = _processedCorrelationIds.TakeLast(MaxProcessedCorrelationIds).ToList();
+    }
+
+    private void RecordEvent(string message)
+    {
+        var entry = $"[{Temporalio.Workflows.Workflow.UtcNow:HH:mm:ss}] {message}";
+        _recentEvents.Add(entry);
+        if (_recentEvents.Count > MaxRecentEvents)
+            _recentEvents.RemoveAt(0);
+        Logger.LogInformation("[SolanaTP:{Network}] {Message}", _network?.Slug ?? "init", message);
+    }
+
+    private async Task SignalSuccessAsync(TransactionCallback callback, string correlationId, string txSignature, ulong? slot)
+    {
+        try
+        {
+            var result = new TransactionResult
+            {
+                Success = true,
+                TxHash = txSignature,
+                BlockNumber = slot,
+                CorrelationId = correlationId
+            };
+
+            var handle = Temporalio.Workflows.Workflow.GetExternalWorkflowHandle(callback.WorkflowId);
+            await handle.SignalAsync(callback.OnSuccessSignal, [result]);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "[SolanaTP:{Network}] Failed to signal success for {CorrelationId}", _network.Slug, correlationId);
+        }
+    }
+
+    private async Task SignalFailureAsync(TransactionCallback callback, string correlationId, string reason)
+    {
+        try
+        {
+            var result = new TransactionResult
+            {
+                Success = false,
+                FailureReason = reason,
+                CorrelationId = correlationId
+            };
+
+            var signalName = callback.OnFailureSignal ?? callback.OnSuccessSignal;
+            var handle = Temporalio.Workflows.Workflow.GetExternalWorkflowHandle(callback.WorkflowId);
+            await handle.SignalAsync(signalName, [result]);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "[SolanaTP:{Network}] Failed to signal failure for {CorrelationId}", _network.Slug, correlationId);
+        }
+    }
+
+    private async Task SaveStateAsync()
+    {
+        try
+        {
+            await ExecuteLocalActivityAsync(
+                (ISolanaWorkflowActivities x) => x.SaveTransactionStateAsync(_network.Slug, _wallet.Address, BuildSnapshot()),
+                GetLocalActivityOptions(TimeSpan.FromSeconds(10), 3));
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "[SolanaTP:{Network}] Failed to save state to Redis", _network.Slug);
+        }
+    }
+
+    private SolanaTransactionProcessorSnapshot BuildSnapshot() => new()
+    {
+        QueuedRequests = [.. _queuedRequests],
+        PendingTransactions = [.. _pendingTransactions],
+        InFlightTransactions = [.. _inFlightTransactions],
+        ProcessedCorrelationIds = [.. _processedCorrelationIds]
+    };
+
+    private SolanaTransactionProcessorArgs BuildContinueAsNewArgs() => new()
+    {
+        NetworkSlug = _network.Slug,
+        WalletAddress = _wallet.Address,
+        SignerAgentUrl = _signerAgentUrl,
+        QueuedRequests = [.. _queuedRequests],
+        PendingTransactions = [.. _pendingTransactions],
+        InFlightTransactions = [.. _inFlightTransactions],
+        ProcessedCorrelationIds = [.. _processedCorrelationIds]
+    };
+
+    private async Task<ulong> GetPriorityFeeAsync(string nodeUrl, ulong existingFee)
+    {
+        if (existingFee > 0)
+            return existingFee;
+
+        try
+        {
+            return await ExecuteLocalActivityAsync(
+                (ISolanaBlockchainActivities x) => x.GetRecentPriorityFeeAsync(new SolanaGetPriorityFeeRequest
+                {
+                    NodeUrl = nodeUrl
+                }),
+                GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "[SolanaTP:{Network}] Failed to get priority fee, using default", _network.Slug);
+            return DefaultPriorityFeeMicroLamports;
+        }
+    }
+
+    private async Task<string> BuildUnsignedTransactionForQueuedAsync(
+        SolanaQueuedRequest queued, string nodeUrl, string blockhash, ulong priorityFee)
+    {
+        switch (queued.Type)
+        {
+            case TransactionType.Transfer:
+            {
+                if (queued.TransferRequest == null)
+                    throw new Exception("TransferRequest is null for Transfer type");
+
+                return await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.BuildTransferTransactionAsync(new SolanaBuildTransferRequest
+                    {
+                        NodeUrl = nodeUrl,
+                        FromAddress = queued.TransferRequest.Sender,
+                        ToAddress = queued.TransferRequest.Receiver,
+                        TokenContract = queued.TransferRequest.TokenContract,
+                        Amount = queued.TransferRequest.Amount,
+                        RecentBlockhash = blockhash,
+                        PriorityFeeMicroLamports = priorityFee
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
+            }
+
+            case TransactionType.HTLCLock:
+            {
+                if (queued.LockRequest == null)
+                    throw new Exception("LockRequest is null for HTLCLock type");
+
+                var hashlock = ParseHashlock(queued.LockRequest.Hashlock);
+
+                return await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.BuildHTLCLockTransactionAsync(new SolanaBuildHTLCLockRequest
+                    {
+                        NodeUrl = nodeUrl,
+                        SenderAddress = queued.LockRequest.Sender,
+                        SrcReceiver = queued.LockRequest.Receiver,
+                        Hashlock = hashlock,
+                        Timelock = (ulong)queued.LockRequest.Timelock,
+                        Amount = (ulong)queued.LockRequest.Amount,
+                        DstChain = queued.LockRequest.DstChain,
+                        DstAddress = queued.LockRequest.DestinationAddress,
+                        DstAsset = queued.LockRequest.DestinationToken,
+                        SrcAsset = queued.LockRequest.TokenContract,
+                        RecentBlockhash = blockhash,
+                        PriorityFeeMicroLamports = priorityFee
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
+            }
+
+            case TransactionType.HTLCRedeem:
+            {
+                if (queued.RedeemRequest == null)
+                    throw new Exception("RedeemRequest is null for HTLCRedeem type");
+
+                var id = ParseHashlock(queued.RedeemRequest.Hashlock);
+                var secret = ParseHashlock(queued.RedeemRequest.Secret);
+
+                // Read PDA account to get sender and src_receiver for account metas
+                var htlcAccount = await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
+                    {
+                        NodeUrl = nodeUrl,
+                        Id = id
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
+
+                if (htlcAccount == null)
+                    throw new Exception($"HTLC account not found for hashlock {queued.RedeemRequest.Hashlock}");
+
+                return await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.BuildHTLCRedeemTransactionAsync(new SolanaBuildHTLCRedeemRequest
+                    {
+                        NodeUrl = nodeUrl,
+                        SignerAddress = _wallet.Address,
+                        SenderAddress = htlcAccount.Sender,
+                        SrcReceiverAddress = htlcAccount.SrcReceiver,
+                        Id = id,
+                        Secret = secret,
+                        RecentBlockhash = blockhash,
+                        PriorityFeeMicroLamports = priorityFee
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
+            }
+
+            case TransactionType.HTLCRefund:
+            case TransactionType.UserHTLCRefund:
+            {
+                if (queued.RefundRequest == null)
+                    throw new Exception("RefundRequest is null for refund type");
+
+                var id = ParseHashlock(queued.RefundRequest.Hashlock);
+
+                // Read PDA account to get sender for account metas
+                var htlcAccount = await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
+                    {
+                        NodeUrl = nodeUrl,
+                        Id = id
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
+
+                if (htlcAccount == null)
+                    throw new Exception($"HTLC account not found for hashlock {queued.RefundRequest.Hashlock}");
+
+                return await ExecuteLocalActivityAsync(
+                    (ISolanaBlockchainActivities x) => x.BuildHTLCRefundTransactionAsync(new SolanaBuildHTLCRefundRequest
+                    {
+                        NodeUrl = nodeUrl,
+                        SignerAddress = _wallet.Address,
+                        SenderAddress = htlcAccount.Sender,
+                        Id = id,
+                        RecentBlockhash = blockhash,
+                        PriorityFeeMicroLamports = priorityFee
+                    }),
+                    GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
+            }
+
+            default:
+                throw new Exception($"Unsupported transaction type: {queued.Type}");
+        }
+    }
+
+    private static byte[] ParseHashlock(string hexString)
+    {
+        var trimmed = hexString.StartsWith("0x", StringComparison.OrdinalIgnoreCase)
+            ? hexString[2..]
+            : hexString;
+        return Convert.FromHexString(trimmed);
+    }
+
+    private static bool HasRetryableRequest(SolanaPendingTransaction pending) =>
+        pending.TransferRequest != null || pending.LockRequest != null ||
+        pending.RedeemRequest != null || pending.RefundRequest != null;
+
+    private static bool HasRetryableRequest(SolanaInFlightTransaction inFlight) =>
+        inFlight.TransferRequest != null || inFlight.LockRequest != null ||
+        inFlight.RedeemRequest != null || inFlight.RefundRequest != null;
+
+    private static LocalActivityOptions GetLocalActivityOptions(TimeSpan timeout, int maxAttempts) => new()
+    {
+        StartToCloseTimeout = timeout,
+        RetryPolicy = new() { MaximumAttempts = maxAttempts }
+    };
+
+    #endregion
+}
diff --git a/csharp/src/Workflow.Solana/appsettings.json b/csharp/src/Workflow.Solana/appsettings.json
new file mode 100644
index 00000000..818cf47a
--- /dev/null
+++ b/csharp/src/Workflow.Solana/appsettings.json
@@ -0,0 +1,12 @@
+{
+  "TrainSolver": {
+    "TemporalServerHost": "<TEMPORAL_SERVER>",
+    "DatabaseConnectionString": "<DB_CONNECTION_STRING>",
+    "RedisConnectionString": "<REDIS_CONNECTION_STRING>",
+    "TreasuryUrl": "<TREASURY_URL>",
+    "OpenTelemetryUrl": "<OPENTELEMETRY_EXPLORER_URL>"
+  },
+  "QuoteSigning": {
+    "HmacSecretKey": "dev-secret-key-change-in-production"
+  }
+}
diff --git a/treasury/src/treasury/solana/solana.service.ts b/treasury/src/treasury/solana/solana.service.ts
index 0b925ef1..3d650c03 100644
--- a/treasury/src/treasury/solana/solana.service.ts
+++ b/treasury/src/treasury/solana/solana.service.ts
@@ -19,13 +19,17 @@ export class SolanaTreasuryService extends TreasuryService {
     
     const privateKey = await this.privateKeyService.getAsync(request.address);
 
-    const account = Keypair.fromSecretKey(bs58.decode(privateKey));
+    const secretKey = privateKey.includes(',')
+      ? Uint8Array.from(privateKey.split(',').map(Number))
+      : bs58.decode(privateKey);
+
+    const account = Keypair.fromSecretKey(secretKey);
 
     let transaction: Transaction = Transaction.from(Buffer.from(request.unsignedTxn, 'base64'));
 
-    transaction.sign(account);
+    transaction.partialSign(account);
 
-    return { signedTxn: transaction.serialize().toString('base64') };
+    return { signedTxn: transaction.serialize({ requireAllSignatures: false }).toString('base64') };
   }
 
   async generate(): Promise<GenerateResponse> {

From 2e23a893ad84bd5d5168de228c31a30e88c6e7f7 Mon Sep 17 00:00:00 2001
From: erkostandyan <erik.kostandyan2003@gmail.com>
Date: Thu, 5 Mar 2026 16:08:39 +0400
Subject: [PATCH 2/5] Add solana configs.

---
 csharp/src/AppHost/AppHost.cs                 |    1 +
 .../ModelBuilderSeedDataExtensions.cs         |   40 +-
 ...0304204847_AddSolanaDevnetSeed.Designer.cs | 2539 +++++++++++++++++
 .../20260304204847_AddSolanaDevnetSeed.cs     |  142 +
 .../SolverDbContextModelSnapshot.cs           |  102 +-
 5 files changed, 2812 insertions(+), 12 deletions(-)
 create mode 100644 csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.Designer.cs
 create mode 100644 csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.cs

diff --git a/csharp/src/AppHost/AppHost.cs b/csharp/src/AppHost/AppHost.cs
index a776422e..76440e77 100644
--- a/csharp/src/AppHost/AppHost.cs
+++ b/csharp/src/AppHost/AppHost.cs
@@ -195,6 +195,7 @@ and assign Generated Token's Policies "train-write-policy.hcl"
     .WithReplicas(1)
     .WaitFor(treasuryApi)
     .WithEnvironment("TrainSolver__NetworkType", "solana")
+    .WithEnvironment("TrainSolver__NetworkSlug", "solana-devnet")
     .WithEnvironment("QuoteSigning__HmacSecretKey", quoteSigningKey);
 
 builder.AddProject<Projects.StationAPI>("station-api")
diff --git a/csharp/src/Data.Npgsql/Extensions/ModelBuilderSeedDataExtensions.cs b/csharp/src/Data.Npgsql/Extensions/ModelBuilderSeedDataExtensions.cs
index a951e2df..5efedf14 100644
--- a/csharp/src/Data.Npgsql/Extensions/ModelBuilderSeedDataExtensions.cs
+++ b/csharp/src/Data.Npgsql/Extensions/ModelBuilderSeedDataExtensions.cs
@@ -40,6 +40,7 @@ private static void SeedTokenPrices(ModelBuilder modelBuilder)
         modelBuilder.Entity<TokenPrice>().HasData(
             new TokenPrice { Id = 1, Symbol = "ETH", PriceInUsd = 2000.0m, ExternalId = "ETHUSDT", LastUpdated = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero) },
             new TokenPrice { Id = 2, Symbol = "BNB", PriceInUsd = 600.0m, ExternalId = "BNBUSDT", LastUpdated = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero) },
+            new TokenPrice { Id = 3, Symbol = "SOL", PriceInUsd = 140.0m, ExternalId = "SOLUSDT", LastUpdated = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero) },
             new TokenPrice { Id = 4, Symbol = "TRX", PriceInUsd = 0.25m, ExternalId = "TRXUSDT", LastUpdated = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero) }
         );
     }
@@ -71,7 +72,8 @@ private static void SeedWallets(ModelBuilder modelBuilder)
     {
         modelBuilder.Entity<Wallet>().HasData(
             new Wallet { Id = 1, Name = "Main", Address = "0x32edfaa9157eda19a458373ddfb10464d2d39796", NetworkTypeId = 1, SignerAgentId = 1 },
-            new Wallet { Id = 2, Name = "AztecMain", Address = "0x1104fc77d3409942ce902994d181acdc1e39cf68a693375690d30a4704b1425c", NetworkTypeId = 5, SignerAgentId = 1 }
+            new Wallet { Id = 2, Name = "AztecMain", Address = "0x1104fc77d3409942ce902994d181acdc1e39cf68a693375690d30a4704b1425c", NetworkTypeId = 5, SignerAgentId = 1 },
+            new Wallet { Id = 3, Name = "SolanaMain", Address = "9ivTbFdPJRg4bgYdUzvf2eXdb6JDhv4iKFL1wTrDwKTf", NetworkTypeId = 2, SignerAgentId = 1 }
         );
     }
 
@@ -85,7 +87,8 @@ private static void SeedNetworks(ModelBuilder modelBuilder)
             new { Id = 4, Slug = "bsc-testnet",      DisplayName = "BSC Testnet",       NetworkTypeId = 1, ChainId = "97" },
             new { Id = 5, Slug = "aztec-devnet",     DisplayName = "Aztec Devnet",      NetworkTypeId = 5, ChainId = "aztec-devnet" },
             new { Id = 6, Slug = "starknet-sepolia", DisplayName = "Starknet Sepolia",  NetworkTypeId = 3, ChainId = "SN_SEPOLIA" },
-            new { Id = 7, Slug = "tron-nile",         DisplayName = "Tron Nile Testnet", NetworkTypeId = 6, ChainId = "3448148188" }
+            new { Id = 7, Slug = "tron-nile",         DisplayName = "Tron Nile Testnet", NetworkTypeId = 6, ChainId = "3448148188" },
+            new { Id = 8, Slug = "solana-devnet",     DisplayName = "Solana Devnet",     NetworkTypeId = 2, ChainId = "devnet" }
         );
 
         // GasConfiguration
@@ -96,7 +99,8 @@ private static void SeedNetworks(ModelBuilder modelBuilder)
             new { NetworkId = 4, IsEip1559 = false, HasL1Fee = false, BaseFeePercentageIncrease = 25, PriorityFeePercentageIncrease = 10, ReplacementFeePercentageIncrease = 15 },
             new { NetworkId = 5, IsEip1559 = false, HasL1Fee = false, BaseFeePercentageIncrease = 0, PriorityFeePercentageIncrease = 0, ReplacementFeePercentageIncrease = 0 },
             new { NetworkId = 6, IsEip1559 = false, HasL1Fee = false, BaseFeePercentageIncrease = 0, PriorityFeePercentageIncrease = 0, ReplacementFeePercentageIncrease = 0 },
-            new { NetworkId = 7, IsEip1559 = false, HasL1Fee = false, BaseFeePercentageIncrease = 0, PriorityFeePercentageIncrease = 0, ReplacementFeePercentageIncrease = 0 }
+            new { NetworkId = 7, IsEip1559 = false, HasL1Fee = false, BaseFeePercentageIncrease = 0, PriorityFeePercentageIncrease = 0, ReplacementFeePercentageIncrease = 0 },
+            new { NetworkId = 8, IsEip1559 = false, HasL1Fee = false, BaseFeePercentageIncrease = 0, PriorityFeePercentageIncrease = 0, ReplacementFeePercentageIncrease = 0 }
         );
 
         // LiquidityConfiguration
@@ -107,7 +111,8 @@ private static void SeedNetworks(ModelBuilder modelBuilder)
             new { NetworkId = 4, MinGasBalance = "100000000000000000", MinBalanceThreshold = "0", MaxBalanceThreshold = "0", TargetBalance = "0", AutoRebalanceEnabled = false },
             new { NetworkId = 5, MinGasBalance = "0", MinBalanceThreshold = "0", MaxBalanceThreshold = "0", TargetBalance = "0", AutoRebalanceEnabled = false },
             new { NetworkId = 6, MinGasBalance = "0", MinBalanceThreshold = "0", MaxBalanceThreshold = "0", TargetBalance = "0", AutoRebalanceEnabled = false },
-            new { NetworkId = 7, MinGasBalance = "10000000", MinBalanceThreshold = "0", MaxBalanceThreshold = "0", TargetBalance = "0", AutoRebalanceEnabled = false }
+            new { NetworkId = 7, MinGasBalance = "10000000", MinBalanceThreshold = "0", MaxBalanceThreshold = "0", TargetBalance = "0", AutoRebalanceEnabled = false },
+            new { NetworkId = 8, MinGasBalance = "10000000", MinBalanceThreshold = "0", MaxBalanceThreshold = "0", TargetBalance = "0", AutoRebalanceEnabled = false }
         );
 
         // TimelockConfiguration
@@ -118,7 +123,8 @@ private static void SeedNetworks(ModelBuilder modelBuilder)
             new { NetworkId = 4, UserTimelockTimeSpanInSeconds = 7200L, SolverTimelockTimeSpanInSeconds = 3600L, RewardTimelockTimeSpanInSeconds = 1800L, QuoteExpiryInSeconds = 900L },
             new { NetworkId = 5, UserTimelockTimeSpanInSeconds = 7200L, SolverTimelockTimeSpanInSeconds = 3600L, RewardTimelockTimeSpanInSeconds = 1800L, QuoteExpiryInSeconds = 900L },
             new { NetworkId = 6, UserTimelockTimeSpanInSeconds = 7200L, SolverTimelockTimeSpanInSeconds = 3600L, RewardTimelockTimeSpanInSeconds = 1800L, QuoteExpiryInSeconds = 900L },
-            new { NetworkId = 7, UserTimelockTimeSpanInSeconds = 7200L, SolverTimelockTimeSpanInSeconds = 3600L, RewardTimelockTimeSpanInSeconds = 1800L, QuoteExpiryInSeconds = 900L }
+            new { NetworkId = 7, UserTimelockTimeSpanInSeconds = 7200L, SolverTimelockTimeSpanInSeconds = 3600L, RewardTimelockTimeSpanInSeconds = 1800L, QuoteExpiryInSeconds = 900L },
+            new { NetworkId = 8, UserTimelockTimeSpanInSeconds = 7200L, SolverTimelockTimeSpanInSeconds = 3600L, RewardTimelockTimeSpanInSeconds = 1800L, QuoteExpiryInSeconds = 900L }
         );
 
         // TransactionProcessorConfiguration
@@ -129,7 +135,8 @@ private static void SeedNetworks(ModelBuilder modelBuilder)
             new { NetworkId = 4, MaxInFlightTransactions = 5, StuckTransactionTimeoutSeconds = 60, MaxGasBumpAttempts = 3, ConfirmationPollingIntervalSeconds = 3, RequiredConfirmations = 0 },
             new { NetworkId = 5, MaxInFlightTransactions = 1, StuckTransactionTimeoutSeconds = 300, MaxGasBumpAttempts = 0, ConfirmationPollingIntervalSeconds = 5, RequiredConfirmations = 0 },
             new { NetworkId = 6, MaxInFlightTransactions = 1, StuckTransactionTimeoutSeconds = 300, MaxGasBumpAttempts = 0, ConfirmationPollingIntervalSeconds = 5, RequiredConfirmations = 0 },
-            new { NetworkId = 7, MaxInFlightTransactions = 5, StuckTransactionTimeoutSeconds = 90, MaxGasBumpAttempts = 0, ConfirmationPollingIntervalSeconds = 5, RequiredConfirmations = 0 }
+            new { NetworkId = 7, MaxInFlightTransactions = 5, StuckTransactionTimeoutSeconds = 90, MaxGasBumpAttempts = 0, ConfirmationPollingIntervalSeconds = 5, RequiredConfirmations = 0 },
+            new { NetworkId = 8, MaxInFlightTransactions = 10, StuckTransactionTimeoutSeconds = 120, MaxGasBumpAttempts = 0, ConfirmationPollingIntervalSeconds = 5, RequiredConfirmations = 0 }
         );
 
         // RewardConfiguration
@@ -140,7 +147,8 @@ private static void SeedNetworks(ModelBuilder modelBuilder)
             new { NetworkId = 4, DeltaPercentage = 10m },
             new { NetworkId = 5, DeltaPercentage = 10m },
             new { NetworkId = 6, DeltaPercentage = 10m },
-            new { NetworkId = 7, DeltaPercentage = 10m }
+            new { NetworkId = 7, DeltaPercentage = 10m },
+            new { NetworkId = 8, DeltaPercentage = 10m }
         );
     }
 
@@ -173,7 +181,10 @@ private static void SeedEventListenerConfigs(ModelBuilder modelBuilder)
                 Settings = new() { ["ReconnectDelaySeconds"] = "10", ["HeartbeatIntervalSeconds"] = "5" } },
             // aztec-devnet: RPC Log only
             new EventListenerConfig { Id = 10, NetworkId = 5, ListenerType = "rpc-log-event-listener", Enabled = true, CatchUpGapThreshold = 0,
-                Settings = new() { ["PollingIntervalSeconds"] = "5", ["BlockBatchSize"] = "10", ["BlockConfirmations"] = "0" } }
+                Settings = new() { ["PollingIntervalSeconds"] = "5", ["BlockBatchSize"] = "10", ["BlockConfirmations"] = "0" } },
+            // solana-devnet: RPC Log only
+            new EventListenerConfig { Id = 11, NetworkId = 8, ListenerType = "rpc-log-event-listener", Enabled = true, CatchUpGapThreshold = 0,
+                Settings = new() { ["PollingIntervalSeconds"] = "5" } }
         );
     }
 
@@ -189,7 +200,8 @@ private static void SeedNodes(ModelBuilder modelBuilder)
             new Node { Id = 7, Url = "wss://bsc-testnet-rpc.publicnode.com",                                     ProviderName = "publicnode", NetworkId = 4, Protocol = NodeProtocol.WebSocket },
             new Node { Id = 8, Url = "https://v4-devnet-2.aztec-labs.com",                                       ProviderName = "aztec",      NetworkId = 5, Protocol = NodeProtocol.Http },
             new Node { Id = 9, Url = "https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/v0_8/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ", ProviderName = "alchemy", NetworkId = 6, Protocol = NodeProtocol.Http },
-            new Node { Id = 10, Url = "https://tron-testnet.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ", ProviderName = "alchemy", NetworkId = 7, Protocol = NodeProtocol.Http }
+            new Node { Id = 10, Url = "https://tron-testnet.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ", ProviderName = "alchemy", NetworkId = 7, Protocol = NodeProtocol.Http },
+            new Node { Id = 11, Url = "https://api.devnet.solana.com", ProviderName = "solana", NetworkId = 8, Protocol = NodeProtocol.Http }
         );
     }
 
@@ -218,7 +230,8 @@ private static void SeedTokens(ModelBuilder modelBuilder)
             new Token { Id = 4, Symbol = "BNB", Decimals = 18, ContractAddress = "0x0000000000000000000000000000000000000000", TokenPriceId = 2, NetworkId = 4 },
             new Token { Id = 5, Symbol = "ETH", Decimals = 18, ContractAddress = "0x02c31306cad429e0a00d3a4ee8ba251853099f835101ee2c637e9b3b9351a056", TokenPriceId = 1, NetworkId = 5 },
             new Token { Id = 6, Symbol = "STRK", Decimals = 18, ContractAddress = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d", TokenPriceId = 1, NetworkId = 6 },
-            new Token { Id = 7, Symbol = "TRX", Decimals = 6, ContractAddress = "0x0000000000000000000000000000000000000000", TokenPriceId = 4, NetworkId = 7 }
+            new Token { Id = 7, Symbol = "TRX", Decimals = 6, ContractAddress = "0x0000000000000000000000000000000000000000", TokenPriceId = 4, NetworkId = 7 },
+            new Token { Id = 8, Symbol = "SOL", Decimals = 9, ContractAddress = "11111111111111111111111111111111", TokenPriceId = 3, NetworkId = 8 }
         );
     }
 
@@ -257,7 +270,12 @@ private static void SeedRoutes(ModelBuilder modelBuilder)
             new Route { Id = 13, SourceTokenId = 5, DestinationTokenId = 1, SourceWalletId = 2, DestinationWalletId = 1, RateProviderId = 1, ServiceFeeId = 1, MinAmountInSource = "100000000000", MaxAmountInSource = "5000000000000000", Status = RouteStatus.Active, AutoRefundUser = false },
             new Route { Id = 14, SourceTokenId = 1, DestinationTokenId = 5, SourceWalletId = 1, DestinationWalletId = 2, RateProviderId = 1, ServiceFeeId = 1, MinAmountInSource = "100000000000", MaxAmountInSource = "5000000000000000", Status = RouteStatus.Active, AutoRefundUser = false },
             new Route { Id = 15, SourceTokenId = 5, DestinationTokenId = 2, SourceWalletId = 2, DestinationWalletId = 1, RateProviderId = 1, ServiceFeeId = 1, MinAmountInSource = "100000000000", MaxAmountInSource = "5000000000000000", Status = RouteStatus.Active, AutoRefundUser = false },
-            new Route { Id = 16, SourceTokenId = 2, DestinationTokenId = 5, SourceWalletId = 1, DestinationWalletId = 2, RateProviderId = 1, ServiceFeeId = 1, MinAmountInSource = "100000000000", MaxAmountInSource = "5000000000000000", Status = RouteStatus.Active, AutoRefundUser = false }
+            new Route { Id = 16, SourceTokenId = 2, DestinationTokenId = 5, SourceWalletId = 1, DestinationWalletId = 2, RateProviderId = 1, ServiceFeeId = 1, MinAmountInSource = "100000000000", MaxAmountInSource = "5000000000000000", Status = RouteStatus.Active, AutoRefundUser = false },
+            // Solana <-> EVM routes (TokenPrice rate provider, SOL has 9 decimals)
+            new Route { Id = 17, SourceTokenId = 8, DestinationTokenId = 1, SourceWalletId = 3, DestinationWalletId = 1, RateProviderId = 3, ServiceFeeId = 1, MinAmountInSource = "1000000", MaxAmountInSource = "50000000000", Status = RouteStatus.Active, AutoRefundUser = false },
+            new Route { Id = 18, SourceTokenId = 1, DestinationTokenId = 8, SourceWalletId = 1, DestinationWalletId = 3, RateProviderId = 3, ServiceFeeId = 1, MinAmountInSource = "100000000000", MaxAmountInSource = "5000000000000000", Status = RouteStatus.Active, AutoRefundUser = false },
+            new Route { Id = 19, SourceTokenId = 8, DestinationTokenId = 2, SourceWalletId = 3, DestinationWalletId = 1, RateProviderId = 3, ServiceFeeId = 1, MinAmountInSource = "1000000", MaxAmountInSource = "50000000000", Status = RouteStatus.Active, AutoRefundUser = false },
+            new Route { Id = 20, SourceTokenId = 2, DestinationTokenId = 8, SourceWalletId = 1, DestinationWalletId = 3, RateProviderId = 3, ServiceFeeId = 1, MinAmountInSource = "100000000000", MaxAmountInSource = "5000000000000000", Status = RouteStatus.Active, AutoRefundUser = false }
         );
     }
 }
diff --git a/csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.Designer.cs b/csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.Designer.cs
new file mode 100644
index 00000000..065e9836
--- /dev/null
+++ b/csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.Designer.cs
@@ -0,0 +1,2539 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Train.Solver.Data.Npgsql;
+
+#nullable disable
+
+namespace Train.Solver.Data.Npgsql.Migrations
+{
+    [DbContext(typeof(SolverDbContext))]
+    [Migration("20260304204847_AddSolanaDevnetSeed")]
+    partial class AddSolanaDevnetSeed
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.13")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Contract", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<int>("NetworkId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkId");
+
+                    b.HasIndex("Type", "NetworkId")
+                        .IsUnique();
+
+                    b.ToTable("Contracts");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Address = "0x9A0E4E619d391f6352E112cC4c452344a3EB4119",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 1,
+                            Type = "Train",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Address = "0xcA11bde05977b3631167028862bE2a173976CA11",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 1,
+                            Type = "Multicall",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Address = "0xCf6D47Cdd0cB259E78262832b4dB3F4F4F909dcB",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 2,
+                            Type = "Train",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Address = "0xcA11bde05977b3631167028862bE2a173976CA11",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 2,
+                            Type = "Multicall",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Address = "0xED6e07cAF602FEB2D535267b06b24bC6cb457975",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 3,
+                            Type = "Train",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Address = "0xcA11bde05977b3631167028862bE2a173976CA11",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 3,
+                            Type = "Multicall",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 7,
+                            Address = "0x4e25d1f421dc2d578bc846178d5ca594e121f2ec",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 4,
+                            Type = "Train",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 8,
+                            Address = "0xcA11bde05977b3631167028862bE2a173976CA11",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 4,
+                            Type = "Multicall",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 9,
+                            Address = "0x2b9192d4571cceb33c689f750bcf380a7baae350846cc55616a278523cfd0dfc",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 5,
+                            Type = "Train",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 10,
+                            Address = "0x1d7fd349c411467f17d293608462dc0b8529082d",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 7,
+                            Type = "Train",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.EventListenerConfig", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CatchUpGapThreshold")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ListenerType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("NetworkId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Settings")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("jsonb")
+                        .HasDefaultValueSql("'{}'::jsonb");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkId", "ListenerType");
+
+                    b.ToTable("EventListenerConfigs");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CatchUpGapThreshold = 100,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "rpc-log-event-listener",
+                            NetworkId = 1,
+                            Settings = "{\"PollingIntervalSeconds\":\"1\",\"BlockBatchSize\":\"100\",\"BlockConfirmations\":\"0\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CatchUpGapThreshold = 100,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "websocket-event-listener",
+                            NetworkId = 1,
+                            Settings = "{\"ReconnectDelaySeconds\":\"10\",\"HeartbeatIntervalSeconds\":\"5\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "rpc-log-event-listener",
+                            NetworkId = 2,
+                            Settings = "{\"PollingIntervalSeconds\":\"1\",\"BlockBatchSize\":\"100\",\"BlockConfirmations\":\"0\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "websocket-event-listener",
+                            NetworkId = 2,
+                            Settings = "{\"ReconnectDelaySeconds\":\"10\",\"HeartbeatIntervalSeconds\":\"10\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "rpc-log-event-listener",
+                            NetworkId = 3,
+                            Settings = "{\"PollingIntervalSeconds\":\"12\",\"BlockBatchSize\":\"100\",\"BlockConfirmations\":\"12\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "mempool-event-listener",
+                            NetworkId = 1,
+                            Settings = "{\"ReconnectDelaySeconds\":\"5\",\"HeartbeatIntervalSeconds\":\"15\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 7,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "mempool-event-listener",
+                            NetworkId = 2,
+                            Settings = "{\"ReconnectDelaySeconds\":\"5\",\"HeartbeatIntervalSeconds\":\"15\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 8,
+                            CatchUpGapThreshold = 100,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "rpc-log-event-listener",
+                            NetworkId = 4,
+                            Settings = "{\"PollingIntervalSeconds\":\"3\",\"BlockBatchSize\":\"100\",\"BlockConfirmations\":\"0\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 9,
+                            CatchUpGapThreshold = 100,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "websocket-event-listener",
+                            NetworkId = 4,
+                            Settings = "{\"ReconnectDelaySeconds\":\"10\",\"HeartbeatIntervalSeconds\":\"5\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 10,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "rpc-log-event-listener",
+                            NetworkId = 5,
+                            Settings = "{\"PollingIntervalSeconds\":\"5\",\"BlockBatchSize\":\"10\",\"BlockConfirmations\":\"0\"}",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 11,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "rpc-log-event-listener",
+                            NetworkId = 8,
+                            Settings = "{\"PollingIntervalSeconds\":\"5\"}",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Network", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ChainId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("NetworkTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkTypeId");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.HasIndex("ChainId", "NetworkTypeId")
+                        .IsUnique();
+
+                    b.ToTable("Networks");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            ChainId = "11155111",
+                            DisplayName = "Ethereum Sepolia",
+                            NetworkTypeId = 1,
+                            Slug = "eth-sepolia"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            ChainId = "421614",
+                            DisplayName = "Arbitrum Sepolia",
+                            NetworkTypeId = 1,
+                            Slug = "arb-sepolia"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            ChainId = "84532",
+                            DisplayName = "Base Sepolia",
+                            NetworkTypeId = 1,
+                            Slug = "base-sepolia"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            ChainId = "97",
+                            DisplayName = "BSC Testnet",
+                            NetworkTypeId = 1,
+                            Slug = "bsc-testnet"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            ChainId = "aztec-devnet",
+                            DisplayName = "Aztec Devnet",
+                            NetworkTypeId = 5,
+                            Slug = "aztec-devnet"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            ChainId = "SN_SEPOLIA",
+                            DisplayName = "Starknet Sepolia",
+                            NetworkTypeId = 3,
+                            Slug = "starknet-sepolia"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            ChainId = "3448148188",
+                            DisplayName = "Tron Nile Testnet",
+                            NetworkTypeId = 6,
+                            Slug = "tron-nile"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            ChainId = "devnet",
+                            DisplayName = "Solana Devnet",
+                            NetworkTypeId = 2,
+                            Slug = "solana-devnet"
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.NetworkMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("NetworkId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkId", "Key")
+                        .IsUnique();
+
+                    b.ToTable("NetworkMetadata");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.NetworkType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AddressFormat")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("AddressLength")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Curve")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NativeTokenAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("NetworkTypes");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            AddressFormat = "hex",
+                            AddressLength = 20,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Curve = "secp256k1",
+                            DisplayName = "EVM",
+                            Name = "eip155",
+                            NativeTokenAddress = "0x0000000000000000000000000000000000000000",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            AddressFormat = "base58",
+                            AddressLength = 32,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Curve = "ed25519",
+                            DisplayName = "Solana",
+                            Name = "solana",
+                            NativeTokenAddress = "11111111111111111111111111111111",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            AddressFormat = "hex",
+                            AddressLength = 32,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Curve = "stark",
+                            DisplayName = "Starknet",
+                            Name = "starknet",
+                            NativeTokenAddress = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 4,
+                            AddressFormat = "hex",
+                            AddressLength = 32,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Curve = "secp256k1",
+                            DisplayName = "Fuel",
+                            Name = "fuel",
+                            NativeTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000000",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 5,
+                            AddressFormat = "hex",
+                            AddressLength = 32,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Curve = "grumpkin",
+                            DisplayName = "Aztec",
+                            Name = "aztec",
+                            NativeTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000000",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 6,
+                            AddressFormat = "hex",
+                            AddressLength = 20,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Curve = "secp256k1",
+                            DisplayName = "Tron",
+                            Name = "tron",
+                            NativeTokenAddress = "0x0000000000000000000000000000000000000000",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Node", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<int>("NetworkId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Protocol")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProviderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkId");
+
+                    b.HasIndex("ProviderName", "NetworkId", "Protocol")
+                        .IsUnique();
+
+                    b.ToTable("Nodes");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 1,
+                            Protocol = 0,
+                            ProviderName = "alchemy",
+                            Url = "https://eth-sepolia.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 2,
+                            Protocol = 0,
+                            ProviderName = "alchemy",
+                            Url = "https://arb-sepolia.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 3,
+                            Protocol = 0,
+                            ProviderName = "publicnode",
+                            Url = "https://base-sepolia-rpc.publicnode.com",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 1,
+                            Protocol = 1,
+                            ProviderName = "alchemy",
+                            Url = "wss://eth-sepolia.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 2,
+                            Protocol = 1,
+                            ProviderName = "alchemy",
+                            Url = "wss://arb-sepolia.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 4,
+                            Protocol = 0,
+                            ProviderName = "publicnode",
+                            Url = "https://bsc-testnet-rpc.publicnode.com",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 7,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 4,
+                            Protocol = 1,
+                            ProviderName = "publicnode",
+                            Url = "wss://bsc-testnet-rpc.publicnode.com",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 8,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 5,
+                            Protocol = 0,
+                            ProviderName = "aztec",
+                            Url = "https://v4-devnet-2.aztec-labs.com",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 9,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 6,
+                            Protocol = 0,
+                            ProviderName = "alchemy",
+                            Url = "https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/v0_8/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 10,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 7,
+                            Protocol = 0,
+                            ProviderName = "alchemy",
+                            Url = "https://tron-testnet.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 11,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 8,
+                            Protocol = 0,
+                            ProviderName = "solana",
+                            Url = "https://api.devnet.solana.com",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Order", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("CompletedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("DestinationAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DestinationAmount")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FailureReason")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FeeAmount")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Hashlock")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RouteId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SolverLockIndex")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("SolverLockTimelock")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("SourceAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SourceAmount")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer")
+                        .HasComment("Created=0,ReservingBalance=1,LPLocking=2,LPLocked=3,Redeeming=4,Completed=5,Refunding=6,SolverRefunded=7,UserRefunding=8,UserRefunded=9,Failed=10");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.Property<string>("WorkflowId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedDate");
+
+                    b.HasIndex("DestinationAddress");
+
+                    b.HasIndex("Hashlock")
+                        .IsUnique();
+
+                    b.HasIndex("RouteId");
+
+                    b.HasIndex("SourceAddress");
+
+                    b.ToTable("Orders");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.OrderMetric", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<double>("CompletionTimeInSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("DestinationNetwork")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DestinationToken")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("OrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("ProfitInUsd")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("SourceNetwork")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SourceToken")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.Property<decimal>("VolumeInUsd")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedDate");
+
+                    b.HasIndex("DestinationNetwork");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("SourceNetwork");
+
+                    b.ToTable("OrderMetrics");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.RateProvider", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("RateProviders");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "SameAsset",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "Binance",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "TokenPrice",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Route", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("AutoRefundUser")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<int>("DestinationTokenId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("DestinationWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MaxAmountInSource")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MinAmountInSource")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RateProviderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ServiceFeeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SourceTokenId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SourceWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer")
+                        .HasComment("Active=0,Inactive=1,Archived=2");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DestinationTokenId");
+
+                    b.HasIndex("DestinationWalletId");
+
+                    b.HasIndex("RateProviderId");
+
+                    b.HasIndex("ServiceFeeId");
+
+                    b.HasIndex("SourceWalletId");
+
+                    b.HasIndex("SourceTokenId", "DestinationTokenId")
+                        .IsUnique();
+
+                    b.ToTable("Routes");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 2,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 1,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 1,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 2,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 3,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 1,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 4,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 1,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 3,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 5,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 3,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 2,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 6,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 2,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 3,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 7,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 4,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 3,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 1,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 8,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 1,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 3,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 4,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 9,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 4,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 3,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 2,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 10,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 2,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 3,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 4,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 11,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 4,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 3,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 3,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 12,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 3,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 3,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 4,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 13,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 1,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 5,
+                            SourceWalletId = 2,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 14,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 5,
+                            DestinationWalletId = 2,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 1,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 15,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 2,
+                            DestinationWalletId = 1,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 5,
+                            SourceWalletId = 2,
+                            Status = 0,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 16,
+                            AutoRefundUser = false,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            DestinationTokenId = 5,
+                            DestinationWalletId = 2,
+                            MaxAmountInSource = "5000000000000000",
+                            MinAmountInSource = "100000000000",
+                            RateProviderId = 1,
+                            ServiceFeeId = 1,
+                            SourceTokenId = 2,
+                            SourceWalletId = 1,
+                            Status = 0,
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.ServiceFee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<decimal>("FeeInUsd")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("FeePercentage")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool>("IncludeExpenseFee")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ServiceFees");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            FeeInUsd = 0m,
+                            FeePercentage = 0m,
+                            IncludeExpenseFee = false,
+                            Name = "Free",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.SignerAgent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("SignerAgents");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "Treasury",
+                            Url = "http://localhost:3000",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Token", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ContractAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<int>("Decimals")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("NetworkId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("TokenPriceId")
+                        .HasColumnType("integer");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenPriceId");
+
+                    b.HasIndex("NetworkId", "ContractAddress")
+                        .IsUnique();
+
+                    b.ToTable("Tokens");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            ContractAddress = "0x0000000000000000000000000000000000000000",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 18,
+                            NetworkId = 1,
+                            Symbol = "ETH",
+                            TokenPriceId = 1,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            ContractAddress = "0x0000000000000000000000000000000000000000",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 18,
+                            NetworkId = 2,
+                            Symbol = "ETH",
+                            TokenPriceId = 1,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            ContractAddress = "0x0000000000000000000000000000000000000000",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 18,
+                            NetworkId = 3,
+                            Symbol = "ETH",
+                            TokenPriceId = 1,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 4,
+                            ContractAddress = "0x0000000000000000000000000000000000000000",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 18,
+                            NetworkId = 4,
+                            Symbol = "BNB",
+                            TokenPriceId = 2,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 5,
+                            ContractAddress = "0x02c31306cad429e0a00d3a4ee8ba251853099f835101ee2c637e9b3b9351a056",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 18,
+                            NetworkId = 5,
+                            Symbol = "ETH",
+                            TokenPriceId = 1,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 6,
+                            ContractAddress = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 18,
+                            NetworkId = 6,
+                            Symbol = "STRK",
+                            TokenPriceId = 1,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 7,
+                            ContractAddress = "0x0000000000000000000000000000000000000000",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 6,
+                            NetworkId = 7,
+                            Symbol = "TRX",
+                            TokenPriceId = 4,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 8,
+                            ContractAddress = "11111111111111111111111111111111",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 9,
+                            NetworkId = 8,
+                            Symbol = "SOL",
+                            TokenPriceId = 3,
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.TokenPrice", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("LastUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("PriceInUsd")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Symbol")
+                        .IsUnique();
+
+                    b.ToTable("TokenPrices");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            ExternalId = "ETHUSDT",
+                            LastUpdated = new DateTimeOffset(new DateTime(2025, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            PriceInUsd = 2000.0m,
+                            Symbol = "ETH",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            ExternalId = "BNBUSDT",
+                            LastUpdated = new DateTimeOffset(new DateTime(2025, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            PriceInUsd = 600.0m,
+                            Symbol = "BNB",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            ExternalId = "SOLUSDT",
+                            LastUpdated = new DateTimeOffset(new DateTime(2025, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            PriceInUsd = 140.0m,
+                            Symbol = "SOL",
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            ExternalId = "TRXUSDT",
+                            LastUpdated = new DateTimeOffset(new DateTime(2025, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            PriceInUsd = 0.25m,
+                            Symbol = "TRX",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Transaction", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("FeeAmount")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("NetworkId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("OrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer")
+                        .HasComment("Completed=0,Initiated=1,Failed=2");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TransactionHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasComment("Transfer=0,Approve=1,HTLCLock=2,HTLCRedeem=3,HTLCRefund=4,Custom=5,UserHTLCLock=6,UserHTLCRedeem=7,UserHTLCRefund=8");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkId");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TransactionHash");
+
+                    b.HasIndex("Type");
+
+                    b.HasIndex("TransactionHash", "NetworkId")
+                        .IsUnique();
+
+                    b.ToTable("Transactions");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.TrustedWallet", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("NetworkTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkTypeId");
+
+                    b.HasIndex("Address", "NetworkTypeId");
+
+                    b.HasIndex("Name", "NetworkTypeId")
+                        .IsUnique();
+
+                    b.ToTable("TrustedWallets");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Wallet", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("NetworkTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SignerAgentId")
+                        .HasColumnType("integer");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NetworkTypeId");
+
+                    b.HasIndex("SignerAgentId");
+
+                    b.HasIndex("Address", "NetworkTypeId");
+
+                    b.HasIndex("Name", "NetworkTypeId")
+                        .IsUnique();
+
+                    b.ToTable("Wallets");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Address = "0x32edfaa9157eda19a458373ddfb10464d2d39796",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "Main",
+                            NetworkTypeId = 1,
+                            SignerAgentId = 1,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Address = "0x1104fc77d3409942ce902994d181acdc1e39cf68a693375690d30a4704b1425c",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "AztecMain",
+                            NetworkTypeId = 5,
+                            SignerAgentId = 1,
+                            Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Address = "9ivTbFdPJRg4bgYdUzvf2eXdb6JDhv4iKFL1wTrDwKTf",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "SolanaMain",
+                            NetworkTypeId = 2,
+                            SignerAgentId = 1,
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.WebhookSubscriber", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.PrimitiveCollection<string[]>("EventTypes")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Secret")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<uint>("Version")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("WebhookSubscribers");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EventTypes = new string[0],
+                            IsActive = true,
+                            Name = "station-api",
+                            Secret = "station-webhook-secret-1",
+                            Url = "http://localhost:9690/api/v1/webhooks/plorex",
+                            Version = 0u
+                        });
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Contract", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Network", "Network")
+                        .WithMany("Contracts")
+                        .HasForeignKey("NetworkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Network");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.EventListenerConfig", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Network", "Network")
+                        .WithMany("EventListenerConfigs")
+                        .HasForeignKey("NetworkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Network");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Network", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.NetworkType", "Type")
+                        .WithMany("Networks")
+                        .HasForeignKey("NetworkTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Train.Solver.Data.Abstractions.Entities.GasConfiguration", "GasConfiguration", b1 =>
+                        {
+                            b1.Property<int>("NetworkId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("BaseFeePercentageIncrease")
+                                .HasColumnType("integer");
+
+                            b1.Property<bool>("HasL1Fee")
+                                .HasColumnType("boolean");
+
+                            b1.Property<bool>("IsEip1559")
+                                .HasColumnType("boolean");
+
+                            b1.Property<string>("L1FeeOracleContract")
+                                .HasColumnType("text");
+
+                            b1.Property<int>("PriorityFeePercentageIncrease")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("ReplacementFeePercentageIncrease")
+                                .HasColumnType("integer");
+
+                            b1.HasKey("NetworkId");
+
+                            b1.ToTable("Networks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("NetworkId");
+
+                            b1.HasData(
+                                new
+                                {
+                                    NetworkId = 1,
+                                    BaseFeePercentageIncrease = 25,
+                                    HasL1Fee = false,
+                                    IsEip1559 = true,
+                                    PriorityFeePercentageIncrease = 10,
+                                    ReplacementFeePercentageIncrease = 15
+                                },
+                                new
+                                {
+                                    NetworkId = 2,
+                                    BaseFeePercentageIncrease = 20,
+                                    HasL1Fee = false,
+                                    IsEip1559 = true,
+                                    PriorityFeePercentageIncrease = 10,
+                                    ReplacementFeePercentageIncrease = 15
+                                },
+                                new
+                                {
+                                    NetworkId = 3,
+                                    BaseFeePercentageIncrease = 25,
+                                    HasL1Fee = true,
+                                    IsEip1559 = true,
+                                    L1FeeOracleContract = "0x420000000000000000000000000000000000000F",
+                                    PriorityFeePercentageIncrease = 10,
+                                    ReplacementFeePercentageIncrease = 15
+                                },
+                                new
+                                {
+                                    NetworkId = 4,
+                                    BaseFeePercentageIncrease = 25,
+                                    HasL1Fee = false,
+                                    IsEip1559 = false,
+                                    PriorityFeePercentageIncrease = 10,
+                                    ReplacementFeePercentageIncrease = 15
+                                },
+                                new
+                                {
+                                    NetworkId = 5,
+                                    BaseFeePercentageIncrease = 0,
+                                    HasL1Fee = false,
+                                    IsEip1559 = false,
+                                    PriorityFeePercentageIncrease = 0,
+                                    ReplacementFeePercentageIncrease = 0
+                                },
+                                new
+                                {
+                                    NetworkId = 6,
+                                    BaseFeePercentageIncrease = 0,
+                                    HasL1Fee = false,
+                                    IsEip1559 = false,
+                                    PriorityFeePercentageIncrease = 0,
+                                    ReplacementFeePercentageIncrease = 0
+                                },
+                                new
+                                {
+                                    NetworkId = 7,
+                                    BaseFeePercentageIncrease = 0,
+                                    HasL1Fee = false,
+                                    IsEip1559 = false,
+                                    PriorityFeePercentageIncrease = 0,
+                                    ReplacementFeePercentageIncrease = 0
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    BaseFeePercentageIncrease = 0,
+                                    HasL1Fee = false,
+                                    IsEip1559 = false,
+                                    PriorityFeePercentageIncrease = 0,
+                                    ReplacementFeePercentageIncrease = 0
+                                });
+                        });
+
+                    b.OwnsOne("Train.Solver.Data.Abstractions.Entities.LiquidityConfiguration", "LiquidityConfiguration", b1 =>
+                        {
+                            b1.Property<int>("NetworkId")
+                                .HasColumnType("integer");
+
+                            b1.Property<bool>("AutoRebalanceEnabled")
+                                .HasColumnType("boolean");
+
+                            b1.Property<string>("MaxBalanceThreshold")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("MinBalanceThreshold")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("MinGasBalance")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("TargetBalance")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.HasKey("NetworkId");
+
+                            b1.ToTable("Networks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("NetworkId");
+
+                            b1.HasData(
+                                new
+                                {
+                                    NetworkId = 1,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "10000000000000000",
+                                    TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 2,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "10000000000000000",
+                                    TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 3,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "10000000000000000",
+                                    TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 4,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "100000000000000000",
+                                    TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 5,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "0",
+                                    TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 6,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "0",
+                                    TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 7,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "10000000",
+                                    TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "10000000",
+                                    TargetBalance = "0"
+                                });
+                        });
+
+                    b.OwnsOne("Train.Solver.Data.Abstractions.Entities.RewardConfiguration", "RewardConfiguration", b1 =>
+                        {
+                            b1.Property<int>("NetworkId")
+                                .HasColumnType("integer");
+
+                            b1.Property<decimal>("DeltaPercentage")
+                                .HasColumnType("numeric");
+
+                            b1.HasKey("NetworkId");
+
+                            b1.ToTable("Networks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("NetworkId");
+
+                            b1.HasData(
+                                new
+                                {
+                                    NetworkId = 1,
+                                    DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 2,
+                                    DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 3,
+                                    DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 4,
+                                    DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 5,
+                                    DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 6,
+                                    DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 7,
+                                    DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    DeltaPercentage = 10m
+                                });
+                        });
+
+                    b.OwnsOne("Train.Solver.Data.Abstractions.Entities.TimelockConfiguration", "TimelockConfiguration", b1 =>
+                        {
+                            b1.Property<int>("NetworkId")
+                                .HasColumnType("integer");
+
+                            b1.Property<long>("QuoteExpiryInSeconds")
+                                .HasColumnType("bigint");
+
+                            b1.Property<long>("RewardTimelockTimeSpanInSeconds")
+                                .HasColumnType("bigint");
+
+                            b1.Property<long>("SolverTimelockTimeSpanInSeconds")
+                                .HasColumnType("bigint");
+
+                            b1.Property<long>("UserTimelockTimeSpanInSeconds")
+                                .HasColumnType("bigint");
+
+                            b1.HasKey("NetworkId");
+
+                            b1.ToTable("Networks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("NetworkId");
+
+                            b1.HasData(
+                                new
+                                {
+                                    NetworkId = 1,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 2,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 3,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 4,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 5,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 6,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 7,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
+                                });
+                        });
+
+                    b.OwnsOne("Train.Solver.Data.Abstractions.Entities.TransactionProcessorConfiguration", "TransactionProcessorConfiguration", b1 =>
+                        {
+                            b1.Property<int>("NetworkId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("ConfirmationPollingIntervalSeconds")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("MaxGasBumpAttempts")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("MaxInFlightTransactions")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("RequiredConfirmations")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("StuckTransactionTimeoutSeconds")
+                                .HasColumnType("integer");
+
+                            b1.HasKey("NetworkId");
+
+                            b1.ToTable("Networks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("NetworkId");
+
+                            b1.HasData(
+                                new
+                                {
+                                    NetworkId = 1,
+                                    ConfirmationPollingIntervalSeconds = 1,
+                                    MaxGasBumpAttempts = 3,
+                                    MaxInFlightTransactions = 5,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 60
+                                },
+                                new
+                                {
+                                    NetworkId = 2,
+                                    ConfirmationPollingIntervalSeconds = 1,
+                                    MaxGasBumpAttempts = 3,
+                                    MaxInFlightTransactions = 1,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 60
+                                },
+                                new
+                                {
+                                    NetworkId = 3,
+                                    ConfirmationPollingIntervalSeconds = 1,
+                                    MaxGasBumpAttempts = 3,
+                                    MaxInFlightTransactions = 10,
+                                    RequiredConfirmations = 1,
+                                    StuckTransactionTimeoutSeconds = 120
+                                },
+                                new
+                                {
+                                    NetworkId = 4,
+                                    ConfirmationPollingIntervalSeconds = 3,
+                                    MaxGasBumpAttempts = 3,
+                                    MaxInFlightTransactions = 5,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 60
+                                },
+                                new
+                                {
+                                    NetworkId = 5,
+                                    ConfirmationPollingIntervalSeconds = 5,
+                                    MaxGasBumpAttempts = 0,
+                                    MaxInFlightTransactions = 1,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 300
+                                },
+                                new
+                                {
+                                    NetworkId = 6,
+                                    ConfirmationPollingIntervalSeconds = 5,
+                                    MaxGasBumpAttempts = 0,
+                                    MaxInFlightTransactions = 1,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 300
+                                },
+                                new
+                                {
+                                    NetworkId = 7,
+                                    ConfirmationPollingIntervalSeconds = 5,
+                                    MaxGasBumpAttempts = 0,
+                                    MaxInFlightTransactions = 5,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 90
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    ConfirmationPollingIntervalSeconds = 5,
+                                    MaxGasBumpAttempts = 0,
+                                    MaxInFlightTransactions = 10,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 120
+                                });
+                        });
+
+                    b.Navigation("GasConfiguration")
+                        .IsRequired();
+
+                    b.Navigation("LiquidityConfiguration")
+                        .IsRequired();
+
+                    b.Navigation("RewardConfiguration")
+                        .IsRequired();
+
+                    b.Navigation("TimelockConfiguration")
+                        .IsRequired();
+
+                    b.Navigation("TransactionProcessorConfiguration")
+                        .IsRequired();
+
+                    b.Navigation("Type");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.NetworkMetadata", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Network", "Network")
+                        .WithMany("Metadata")
+                        .HasForeignKey("NetworkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Network");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Node", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Network", "Network")
+                        .WithMany("Nodes")
+                        .HasForeignKey("NetworkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Network");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Order", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Route", "Route")
+                        .WithMany()
+                        .HasForeignKey("RouteId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Route");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.OrderMetric", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Order", "Order")
+                        .WithMany()
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Route", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Token", "DestinationToken")
+                        .WithMany()
+                        .HasForeignKey("DestinationTokenId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Wallet", "DestinationWallet")
+                        .WithMany()
+                        .HasForeignKey("DestinationWalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.RateProvider", "RateProvider")
+                        .WithMany()
+                        .HasForeignKey("RateProviderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.ServiceFee", "ServiceFee")
+                        .WithMany()
+                        .HasForeignKey("ServiceFeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Token", "SourceToken")
+                        .WithMany()
+                        .HasForeignKey("SourceTokenId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Wallet", "SourceWallet")
+                        .WithMany()
+                        .HasForeignKey("SourceWalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DestinationToken");
+
+                    b.Navigation("DestinationWallet");
+
+                    b.Navigation("RateProvider");
+
+                    b.Navigation("ServiceFee");
+
+                    b.Navigation("SourceToken");
+
+                    b.Navigation("SourceWallet");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Token", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Network", "Network")
+                        .WithMany("Tokens")
+                        .HasForeignKey("NetworkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.TokenPrice", "TokenPrice")
+                        .WithMany()
+                        .HasForeignKey("TokenPriceId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Network");
+
+                    b.Navigation("TokenPrice");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Transaction", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Network", "Network")
+                        .WithMany()
+                        .HasForeignKey("NetworkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.Order", "Order")
+                        .WithMany("Transactions")
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Network");
+
+                    b.Navigation("Order");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.TrustedWallet", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.NetworkType", "NetworkType")
+                        .WithMany()
+                        .HasForeignKey("NetworkTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NetworkType");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Wallet", b =>
+                {
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.NetworkType", "NetworkType")
+                        .WithMany("Wallets")
+                        .HasForeignKey("NetworkTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Train.Solver.Data.Abstractions.Entities.SignerAgent", "SignerAgent")
+                        .WithMany()
+                        .HasForeignKey("SignerAgentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NetworkType");
+
+                    b.Navigation("SignerAgent");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Network", b =>
+                {
+                    b.Navigation("Contracts");
+
+                    b.Navigation("EventListenerConfigs");
+
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Nodes");
+
+                    b.Navigation("Tokens");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.NetworkType", b =>
+                {
+                    b.Navigation("Networks");
+
+                    b.Navigation("Wallets");
+                });
+
+            modelBuilder.Entity("Train.Solver.Data.Abstractions.Entities.Order", b =>
+                {
+                    b.Navigation("Transactions");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.cs b/csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.cs
new file mode 100644
index 00000000..abc712a2
--- /dev/null
+++ b/csharp/src/Data.Npgsql/Migrations/20260304204847_AddSolanaDevnetSeed.cs
@@ -0,0 +1,142 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Train.Solver.Data.Npgsql.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSolanaDevnetSeed : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Use ON CONFLICT DO NOTHING since some rows may already exist from manual setup
+            migrationBuilder.Sql("""
+                INSERT INTO "TokenPrices" ("Id", "ExternalId", "LastUpdated", "PriceInUsd", "Symbol")
+                VALUES (3, 'SOLUSDT', '2025-01-01 00:00:00+00', 140.0, 'SOL')
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+
+            migrationBuilder.Sql("""
+                INSERT INTO "Networks" (
+                    "Id", "ChainId", "DisplayName", "NetworkTypeId", "Slug",
+                    "GasConfiguration_BaseFeePercentageIncrease", "GasConfiguration_HasL1Fee", "GasConfiguration_IsEip1559",
+                    "GasConfiguration_PriorityFeePercentageIncrease", "GasConfiguration_ReplacementFeePercentageIncrease",
+                    "LiquidityConfiguration_AutoRebalanceEnabled", "LiquidityConfiguration_MaxBalanceThreshold",
+                    "LiquidityConfiguration_MinBalanceThreshold", "LiquidityConfiguration_MinGasBalance", "LiquidityConfiguration_TargetBalance",
+                    "RewardConfiguration_DeltaPercentage",
+                    "TimelockConfiguration_QuoteExpiryInSeconds", "TimelockConfiguration_RewardTimelockTimeSpanInSeconds",
+                    "TimelockConfiguration_SolverTimelockTimeSpanInSeconds", "TimelockConfiguration_UserTimelockTimeSpanInSeconds",
+                    "TransactionProcessorConfiguration_ConfirmationPollingIntervalS~",
+                    "TransactionProcessorConfiguration_MaxGasBumpAttempts", "TransactionProcessorConfiguration_MaxInFlightTransactions",
+                    "TransactionProcessorConfiguration_RequiredConfirmations", "TransactionProcessorConfiguration_StuckTransactionTimeoutSecon~"
+                ) VALUES (
+                    8, 'devnet', 'Solana Devnet', 2, 'solana-devnet',
+                    0, FALSE, FALSE, 0, 0,
+                    FALSE, '0', '0', '10000000', '0',
+                    10.0,
+                    900, 1800, 3600, 7200,
+                    5, 0, 10, 0, 120
+                ) ON CONFLICT ("Id") DO NOTHING;
+                """);
+
+            migrationBuilder.Sql("""
+                INSERT INTO "Wallets" ("Id", "Address", "Name", "NetworkTypeId", "SignerAgentId")
+                VALUES (3, '9ivTbFdPJRg4bgYdUzvf2eXdb6JDhv4iKFL1wTrDwKTf', 'SolanaMain', 2, 1)
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+
+            migrationBuilder.Sql("""
+                INSERT INTO "EventListenerConfigs" ("Id", "CatchUpGapThreshold", "Enabled", "ListenerType", "NetworkId", "Settings")
+                VALUES (11, 0, TRUE, 'rpc-log-event-listener', 8, '{"PollingIntervalSeconds":"5"}')
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+
+            migrationBuilder.Sql("""
+                INSERT INTO "Nodes" ("Id", "NetworkId", "Protocol", "ProviderName", "Url")
+                VALUES (11, 8, 0, 'solana', 'https://api.devnet.solana.com')
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+
+            migrationBuilder.Sql("""
+                INSERT INTO "Tokens" ("Id", "ContractAddress", "Decimals", "NetworkId", "Symbol", "TokenPriceId")
+                VALUES (8, '11111111111111111111111111111111', 9, 8, 'SOL', 3)
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+
+            // Solana <-> EVM routes (TokenPrice rate provider)
+            migrationBuilder.Sql("""
+                INSERT INTO "Routes" ("Id", "SourceTokenId", "DestinationTokenId", "SourceWalletId", "DestinationWalletId", "RateProviderId", "ServiceFeeId", "MinAmountInSource", "MaxAmountInSource", "Status", "AutoRefundUser")
+                VALUES (17, 8, 1, 3, 1, 3, 1, '1000000', '50000000000', 0, FALSE)
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+            migrationBuilder.Sql("""
+                INSERT INTO "Routes" ("Id", "SourceTokenId", "DestinationTokenId", "SourceWalletId", "DestinationWalletId", "RateProviderId", "ServiceFeeId", "MinAmountInSource", "MaxAmountInSource", "Status", "AutoRefundUser")
+                VALUES (18, 1, 8, 1, 3, 3, 1, '100000000000', '5000000000000000', 0, FALSE)
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+            migrationBuilder.Sql("""
+                INSERT INTO "Routes" ("Id", "SourceTokenId", "DestinationTokenId", "SourceWalletId", "DestinationWalletId", "RateProviderId", "ServiceFeeId", "MinAmountInSource", "MaxAmountInSource", "Status", "AutoRefundUser")
+                VALUES (19, 8, 2, 3, 1, 3, 1, '1000000', '50000000000', 0, FALSE)
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+            migrationBuilder.Sql("""
+                INSERT INTO "Routes" ("Id", "SourceTokenId", "DestinationTokenId", "SourceWalletId", "DestinationWalletId", "RateProviderId", "ServiceFeeId", "MinAmountInSource", "MaxAmountInSource", "Status", "AutoRefundUser")
+                VALUES (20, 2, 8, 1, 3, 3, 1, '100000000000', '5000000000000000', 0, FALSE)
+                ON CONFLICT ("Id") DO NOTHING;
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DeleteData(
+                table: "Routes",
+                keyColumn: "Id",
+                keyValue: 17);
+            migrationBuilder.DeleteData(
+                table: "Routes",
+                keyColumn: "Id",
+                keyValue: 18);
+            migrationBuilder.DeleteData(
+                table: "Routes",
+                keyColumn: "Id",
+                keyValue: 19);
+            migrationBuilder.DeleteData(
+                table: "Routes",
+                keyColumn: "Id",
+                keyValue: 20);
+
+            migrationBuilder.DeleteData(
+                table: "EventListenerConfigs",
+                keyColumn: "Id",
+                keyValue: 11);
+
+            migrationBuilder.DeleteData(
+                table: "Nodes",
+                keyColumn: "Id",
+                keyValue: 11);
+
+            migrationBuilder.DeleteData(
+                table: "Tokens",
+                keyColumn: "Id",
+                keyValue: 8);
+
+            migrationBuilder.DeleteData(
+                table: "Wallets",
+                keyColumn: "Id",
+                keyValue: 3);
+
+            migrationBuilder.DeleteData(
+                table: "Networks",
+                keyColumn: "Id",
+                keyValue: 8);
+
+            migrationBuilder.DeleteData(
+                table: "TokenPrices",
+                keyColumn: "Id",
+                keyValue: 3);
+        }
+    }
+}
diff --git a/csharp/src/Data.Npgsql/Migrations/SolverDbContextModelSnapshot.cs b/csharp/src/Data.Npgsql/Migrations/SolverDbContextModelSnapshot.cs
index d2242ddb..281b0a7b 100644
--- a/csharp/src/Data.Npgsql/Migrations/SolverDbContextModelSnapshot.cs
+++ b/csharp/src/Data.Npgsql/Migrations/SolverDbContextModelSnapshot.cs
@@ -17,7 +17,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "9.0.0")
+                .HasAnnotation("ProductVersion", "9.0.13")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -308,6 +308,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             NetworkId = 5,
                             Settings = "{\"PollingIntervalSeconds\":\"5\",\"BlockBatchSize\":\"10\",\"BlockConfirmations\":\"0\"}",
                             Version = 0u
+                        },
+                        new
+                        {
+                            Id = 11,
+                            CatchUpGapThreshold = 0,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Enabled = true,
+                            ListenerType = "rpc-log-event-listener",
+                            NetworkId = 8,
+                            Settings = "{\"PollingIntervalSeconds\":\"5\"}",
+                            Version = 0u
                         });
                 });
 
@@ -413,6 +424,14 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             DisplayName = "Tron Nile Testnet",
                             NetworkTypeId = 6,
                             Slug = "tron-nile"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            ChainId = "devnet",
+                            DisplayName = "Solana Devnet",
+                            NetworkTypeId = 2,
+                            Slug = "solana-devnet"
                         });
                 });
 
@@ -720,6 +739,16 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             ProviderName = "alchemy",
                             Url = "https://tron-testnet.g.alchemy.com/v2/KMb0Q5To2lB2gcfLSWsOJPwJmYZzSacQ",
                             Version = 0u
+                        },
+                        new
+                        {
+                            Id = 11,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            NetworkId = 8,
+                            Protocol = 0,
+                            ProviderName = "solana",
+                            Url = "https://api.devnet.solana.com",
+                            Version = 0u
                         });
                 });
 
@@ -1465,6 +1494,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             Symbol = "TRX",
                             TokenPriceId = 4,
                             Version = 0u
+                        },
+                        new
+                        {
+                            Id = 8,
+                            ContractAddress = "11111111111111111111111111111111",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Decimals = 9,
+                            NetworkId = 8,
+                            Symbol = "SOL",
+                            TokenPriceId = 3,
+                            Version = 0u
                         });
                 });
 
@@ -1530,6 +1570,16 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             Version = 0u
                         },
                         new
+                        {
+                            Id = 3,
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            ExternalId = "SOLUSDT",
+                            LastUpdated = new DateTimeOffset(new DateTime(2025, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            PriceInUsd = 140.0m,
+                            Symbol = "SOL",
+                            Version = 0u
+                        },
+                        new
                         {
                             Id = 4,
                             CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
@@ -1711,6 +1761,16 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             NetworkTypeId = 5,
                             SignerAgentId = 1,
                             Version = 0u
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Address = "9ivTbFdPJRg4bgYdUzvf2eXdb6JDhv4iKFL1wTrDwKTf",
+                            CreatedDate = new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Name = "SolanaMain",
+                            NetworkTypeId = 2,
+                            SignerAgentId = 1,
+                            Version = 0u
                         });
                 });
 
@@ -1897,6 +1957,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                                     IsEip1559 = false,
                                     PriorityFeePercentageIncrease = 0,
                                     ReplacementFeePercentageIncrease = 0
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    BaseFeePercentageIncrease = 0,
+                                    HasL1Fee = false,
+                                    IsEip1559 = false,
+                                    PriorityFeePercentageIncrease = 0,
+                                    ReplacementFeePercentageIncrease = 0
                                 });
                         });
 
@@ -1994,6 +2063,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                                     MinBalanceThreshold = "0",
                                     MinGasBalance = "10000000",
                                     TargetBalance = "0"
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    AutoRebalanceEnabled = false,
+                                    MaxBalanceThreshold = "0",
+                                    MinBalanceThreshold = "0",
+                                    MinGasBalance = "10000000",
+                                    TargetBalance = "0"
                                 });
                         });
 
@@ -2047,6 +2125,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                                 {
                                     NetworkId = 7,
                                     DeltaPercentage = 10m
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    DeltaPercentage = 10m
                                 });
                         });
 
@@ -2130,6 +2213,14 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                                     RewardTimelockTimeSpanInSeconds = 1800L,
                                     SolverTimelockTimeSpanInSeconds = 3600L,
                                     UserTimelockTimeSpanInSeconds = 7200L
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    QuoteExpiryInSeconds = 900L,
+                                    RewardTimelockTimeSpanInSeconds = 1800L,
+                                    SolverTimelockTimeSpanInSeconds = 3600L,
+                                    UserTimelockTimeSpanInSeconds = 7200L
                                 });
                         });
 
@@ -2223,6 +2314,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                                     MaxInFlightTransactions = 5,
                                     RequiredConfirmations = 0,
                                     StuckTransactionTimeoutSeconds = 90
+                                },
+                                new
+                                {
+                                    NetworkId = 8,
+                                    ConfirmationPollingIntervalSeconds = 5,
+                                    MaxGasBumpAttempts = 0,
+                                    MaxInFlightTransactions = 10,
+                                    RequiredConfirmations = 0,
+                                    StuckTransactionTimeoutSeconds = 120
                                 });
                         });
 

From d5f52bcd4b9cbaec50c727f32b38d3e35da00ce0 Mon Sep 17 00:00:00 2001
From: erkostandyan <erik.kostandyan2003@gmail.com>
Date: Fri, 6 Mar 2026 22:40:20 +0400
Subject: [PATCH 3/5] Changes for solana

---
 CLAUDE.md                                     |  42 +-
 .../Endpoints/TransactionBuilderEndpoints.cs  |  32 +-
 .../TrainSolverBuilderExtensions.cs           |   2 +
 .../Workflow.EVM/Workflows/NetworkRuntime.cs  |   4 +
 .../Activities/SolanaBlockchainActivities.cs  | 451 +++++++++-----
 .../TrainSolverBuilderExtensions.cs           |   3 +
 .../Helpers/SolanaAnchorHelper.cs             | 555 +++++++++++++++---
 .../Workflow.Solana/Helpers/SolanaHelper.cs   |  19 +-
 .../Models/SolanaHTLCModels.cs                |  90 ++-
 .../Workflow.Solana/Models/SolanaModels.cs    | 106 +++-
 .../Workflows/SolanaNetworkRuntime.cs         | 125 +++-
 .../Workflows/SolanaRPCEventListener.cs       |  14 +-
 .../Workflows/SolanaTransactionProcessor.cs   |  57 +-
 13 files changed, 1163 insertions(+), 337 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 11953677..96f64bfd 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -163,23 +163,31 @@ Uses `getLatestBlockhash` for transaction lifetime instead of durable nonce acco
 **Event Listener** (`SolanaRPCEventListener`):
 - Polls `getSignaturesForAddress(HTLCProgramId)` for HTLC program transactions
 - Parses Anchor instruction discriminators (`sha256("global:<fn>")[..8]`) to identify function calls
-- Reads HTLC PDA account data (Borsh-decoded) for hashlock, amounts, addresses
-- Event mapping: `lock()`→SolverTokenLocked, `add_lock()/add_lock_sig()`→UserTokenLocked, `redeem()/refund()`→compare HTLC.sender vs solver wallets
-- Skips `commit()` (no hashlock yet) and `lock_reward()` (supplementary)
+- Function name determines event type directly: `user_lock_sol`→UserTokenLocked, `solver_lock_sol`→SolverTokenLocked, `redeem_user_sol`→SolverTokenRedeemed, `redeem_solver_sol`→UserTokenRedeemed, `refund_user_sol`→UserTokenRefunded, `refund_solver_sol`→SolverTokenRefunded
+- Parses lock instruction data for event fields including reward, solverData, userData (full Borsh Vec<u8> parsing)
+- **Timelock conversion**: Solana stores `timelockDelta` (relative seconds) in instruction data. Activity converts to absolute Unix timestamp via `blockTime + timelockDelta` (from `getTransaction` response). OrderWorkflow expects absolute `TimeLock` for validation.
 - Checkpoint: slot + signature stored in Redis (`solana:checkpoint:{slug}:{type}`)
 - Continue-as-new at 50 iterations
 - Self-contained `SolanaEventListenerBase` (no dependency on Workflow.EVM)
 
-**HTLC Contract** (`7ZT5gs8CG7BAv34bLYSke31DJeg5RRUa4G7p9GNcbPE`):
+**HTLC Contract** (`6zasug6x5AY93zNVjPZPGoqQfdTBd3C1w6CU9NDKtNH8`):
 - Anchor program `native_htlc` on Solana devnet
-- 7 functions: commit, lock, lock_reward, add_lock, add_lock_sig, redeem, refund
-- No Anchor events (`emit!()`) — detection via instruction parsing + PDA account reads
-- PDA seeded by 32-byte `Id` field
-- **lock() account metas**: sender(signer,mut), htlc(init,mut,PDA[Id]), system_program, rent. Id = hashlock for solver locks.
-- **redeem() account metas**: user_signing(signer,mut), sender(unchecked,mut), src_receiver(unchecked,mut), htlc(mut,PDA[Id]), system_program, rent
-- **refund() account metas**: user_signing(signer,mut), htlc(mut,PDA[Id]), sender(unchecked,mut), system_program, rent
-- **Borsh encoding**: `SolanaAnchorHelper` provides `WriteBorshU64`, `WriteBorshString`, `WriteBorshPubkey`, `WriteBorshBytes32` for instruction data serialization
-- **Instruction builders**: `BuildLockInstructionData`, `BuildRedeemInstructionData`, `BuildRefundInstructionData` in `SolanaAnchorHelper`
+- 6 functions with `_sol` suffix: `user_lock_sol`, `solver_lock_sol`, `redeem_user_sol`, `redeem_solver_sol`, `refund_user_sol`, `refund_solver_sol`
+- No Anchor events in instruction data — detection via instruction discriminator parsing + PDA account reads
+- **PDA seeds**: UserLock `["user_lock", hashlock]`, SolverLock `["solver_lock", hashlock, index_u64_le]`, SolverCounter `["solver_count", hashlock]`
+- **Solver lock counter**: SolverCounter PDA tracks how many solver locks exist per hashlock. Next index = counter.count + 1 (or 1 if counter doesn't exist). Layout: `disc(8) + count(u64)`.
+- **PDA account layout** (simplified): `disc(8) + secret(32) + amount(u64) + sender(32) + timelock(u64) + status(u8) + src_receiver(32)`. Status: 0=committed, 1=locked, 2=refunded, 3=redeemed.
+- **user_lock_sol instruction data**: `disc(8) + hashlock(32) + amount(u64) + timelock_delta(u64) + quote_expiry(u64) + sender(borsh_string) + recipient(borsh_string) + src_chain(borsh_string) + dst_chain(borsh_string) + dst_address(borsh_string) + dst_amount(u64) + dst_token(borsh_string) + reward_amount(u64) + reward_token(borsh_string) + reward_recipient(borsh_string) + reward_timelock_delta(u64) + user_data(borsh_vec) + solver_data(borsh_vec)`. RewardRecipient is String type (can be any format).
+- **solver_lock_sol instruction data**: `disc(8) + hashlock(32) + index(u64) + amount(u64) + reward(u64) + timelock_delta(u64) + reward_timelock_delta(u64) + sender(borsh_string) + recipient(borsh_string) + reward_recipient(borsh_pubkey32) + src_chain(borsh_string) + dst_chain(borsh_string) + dst_address(borsh_string) + dst_amount(u64) + dst_token(borsh_string) + data(borsh_vec)`. RewardRecipient is Pubkey type (must be valid Solana address).
+- **user_lock_sol account metas** (3): sender(signer,mut), userLock(init,mut,PDA["user_lock",hashlock]), system_program
+- **solver_lock_sol account metas** (4): sender(signer,mut), solverCounter(init_if_needed,mut,PDA["solver_count",hashlock]), solverLock(init,mut,PDA["solver_lock",hashlock,index_le]), system_program
+- **redeem_user_sol account metas** (4): caller(signer,mut), userLock(mut,PDA["user_lock",hashlock]), recipient(unchecked,mut), system_program
+- **redeem_solver_sol account metas** (5): caller(signer,mut), solverLock(mut,PDA["solver_lock",hashlock,index_le]), recipient(unchecked,mut), rewardRecipient(unchecked,mut), system_program
+- **refund_user_sol account metas** (4): caller(signer,mut), userLock(mut,PDA["user_lock",hashlock]), sender(unchecked,mut), system_program
+- **refund_solver_sol account metas** (4): caller(signer,mut), solverLock(mut,PDA["solver_lock",hashlock,index_le]), sender(unchecked,mut), system_program
+- **Borsh encoding**: `SolanaAnchorHelper` provides `WriteBorshU64`, `WriteBorshString`, `WriteBorshPubkey`, `WriteBorshBytes32`, `WriteBorshVec` for instruction data serialization
+- **Instruction builders**: `BuildUserLockSolInstructionData`, `BuildSolverLockSolInstructionData`, `BuildRedeemUserSolInstructionData`, `BuildRedeemSolverSolInstructionData`, `BuildRefundUserSolInstructionData`, `BuildRefundSolverSolInstructionData` in `SolanaAnchorHelper`
+- **Instruction parsers**: `ParseUserLockInstructionData`, `ParseSolverLockInstructionData` in `SolanaAnchorHelper` — used by event listener for lock events. Redeem/refund don't need parsing (hashlock from PDA).
 
 **Address Generator** (`SolanaAddressGenerator`):
 - Single step: call treasury `/api/treasury/solana/generate` → return address
@@ -189,15 +197,15 @@ Uses `getLatestBlockhash` for transaction lifetime instead of durable nonce acco
 - `GetBalanceAsync`: Native SOL via `rpcClient.GetBalanceAsync`, SPL via `GetTokenAccountsByOwnerAsync`
 - `GetLatestBlockhashAsync`: Returns `SolanaBlockhashInfo { Blockhash, LastValidBlockHeight }`
 - `GetRecentPriorityFeeAsync`: Raw HTTP JSON-RPC `getRecentPrioritizationFees`, returns 75th percentile (floor: 1000 µL)
-- `BuildHTLCLockTransactionAsync`: Builds Anchor `lock()` instruction — PDA from hashlock, Borsh-encoded args (Id, hashlock, timelock, amount, dst_chain, dst_address, dst_asset, src_asset, src_receiver)
-- `BuildHTLCRedeemTransactionAsync`: Builds Anchor `redeem()` instruction — account metas require sender + src_receiver from PDA account data
-- `BuildHTLCRefundTransactionAsync`: Builds Anchor `refund()` instruction — account metas require sender from PDA account data
-- `GetHTLCAccountDataAsync`: Reads HTLC PDA via `getAccountInfo` → Borsh-decodes → returns `SolanaHTLCAccount` (sender, src_receiver, hashlock, etc.)
+- `BuildHTLCLockTransactionAsync`: Builds Anchor `user_lock_sol` or `solver_lock_sol` instruction. Solver lock: reads SolverCounter PDA to get next index, derives SolverLock PDA, 4 accounts. User lock: derives UserLock PDA, 3 accounts. Uses `IsSolverLock` flag.
+- `BuildHTLCRedeemTransactionAsync`: Builds Anchor `redeem_user_sol` (4 accounts) or `redeem_solver_sol` (5 accounts, includes rewardRecipient). Uses `IsRedeemingUserLock` flag, `Index` for solver lock.
+- `BuildHTLCRefundTransactionAsync`: Builds Anchor `refund_user_sol` or `refund_solver_sol` — both 4 accounts, different PDA seeds. Uses `IsRefundingSolverLock` flag, `Index` for solver lock.
+- `GetHTLCAccountDataAsync`: Reads HTLC PDA via `getAccountInfo` → Borsh-decodes → returns `SolanaHTLCAccount`. Uses `IsUserLock` flag and `Index` for correct PDA derivation.
 - `GetBlockHeightAsync`: Current block height for expiry checks
 - `BuildTransferTransactionAsync`: Uses `SetRecentBlockHash` + `SetComputeUnitLimit` + `SetComputeUnitPrice` instructions before `SystemProgram.Transfer`. Builds unsigned tx with zero-byte signature placeholders.
 - `SignTransactionAsync`: POST `/api/treasury/solana/sign` with `{ address, unsignedTxn }` → returns `{ signedTxn }`
 - `PublishTransactionAsync`: `rpcClient.SendTransactionAsync` with error classification (Published, DuplicateTransaction, InsufficientFunds, BlockhashNotFound, Failed)
-- `GetHTLCEventsAsync`: Polls `getSignaturesForAddress` → `getTransaction` → parse Anchor discriminators → read HTLC PDA accounts → returns categorized events
+- `GetHTLCEventsAsync`: Polls `getSignaturesForAddress` → `getTransaction` → parse Anchor discriminators (`user_lock_sol`, `solver_lock_sol`, etc.) → parse instruction data for lock events, read UserLock PDA for redeem/refund → returns categorized events
 
 **Unsigned Transaction Wire Format:**
 `[compact-u16 sig_count][64-zero-bytes per sig][message bytes]` — compatible with treasury's `Transaction.from(buffer)` in `@solana/web3.js` v1.
diff --git a/csharp/src/AdminAPI/Endpoints/TransactionBuilderEndpoints.cs b/csharp/src/AdminAPI/Endpoints/TransactionBuilderEndpoints.cs
index 7b2629b3..c79fcb8f 100644
--- a/csharp/src/AdminAPI/Endpoints/TransactionBuilderEndpoints.cs
+++ b/csharp/src/AdminAPI/Endpoints/TransactionBuilderEndpoints.cs
@@ -74,35 +74,31 @@ private static async Task<IResult> GetQuoteAsync(
 
         try
         {
-            var quoteRequest = new QuoteRequest
-            {
-                SourceNetwork = request.SourceNetwork,
-                SourceTokenContract = request.SourceTokenContract,
-                DestinationNetwork = request.DestinationNetwork,
-                DestinationTokenContract = request.DestinationTokenContract,
-                Amount = amount,
-                IncludeReward = request.IncludeReward,
-            };
-
-            var quote = await quoteService.GetQuoteAsync(quoteRequest);
-
             var sourceNetwork = await networkRepository.GetAsync(request.SourceNetwork);
             var destinationNetwork = await networkRepository.GetAsync(request.DestinationNetwork);
 
             if (sourceNetwork == null)
-            {
                 return Results.NotFound($"Source network '{request.SourceNetwork}' not found.");
-            }
 
             if (destinationNetwork == null)
-            {
                 return Results.NotFound($"Destination network '{request.DestinationNetwork}' not found.");
-            }
 
             var sourceTokenContract = request.SourceTokenContract ?? sourceNetwork.Type.NativeTokenAddress;
-            var sourceHtlcContract = ResolveTrainContractAddress(sourceNetwork);
-
             var destTokenContract = request.DestinationTokenContract ?? destinationNetwork.Type.NativeTokenAddress;
+
+            var quoteRequest = new QuoteRequest
+            {
+                SourceNetwork = request.SourceNetwork,
+                SourceTokenContract = sourceTokenContract,
+                DestinationNetwork = request.DestinationNetwork,
+                DestinationTokenContract = destTokenContract,
+                Amount = amount,
+                IncludeReward = request.IncludeReward,
+            };
+
+            var quote = await quoteService.GetQuoteAsync(quoteRequest);
+
+            var sourceHtlcContract = ResolveTrainContractAddress(sourceNetwork);
             var destHtlcContract = ResolveTrainContractAddress(destinationNetwork);
 
             var response = new GetQuoteResponse
diff --git a/csharp/src/Data.Npgsql/Extensions/TrainSolverBuilderExtensions.cs b/csharp/src/Data.Npgsql/Extensions/TrainSolverBuilderExtensions.cs
index 409614df..3067003f 100644
--- a/csharp/src/Data.Npgsql/Extensions/TrainSolverBuilderExtensions.cs
+++ b/csharp/src/Data.Npgsql/Extensions/TrainSolverBuilderExtensions.cs
@@ -30,6 +30,8 @@ public static TrainSolverBuilder WithNpgsqlRepositories(
         builder.Services.AddDbContext<SolverDbContext>(dbOptions =>
         {
             dbOptions.UseNpgsql(options.DatabaseConnectionString);
+            dbOptions.ConfigureWarnings(w => w.Ignore(
+                Microsoft.EntityFrameworkCore.Diagnostics.RelationalEventId.PendingModelChangesWarning));
 
             if (options.DisableDatabaseLogging)
             {
diff --git a/csharp/src/Workflow.EVM/Workflows/NetworkRuntime.cs b/csharp/src/Workflow.EVM/Workflows/NetworkRuntime.cs
index 733313e0..7d6fb44b 100644
--- a/csharp/src/Workflow.EVM/Workflows/NetworkRuntime.cs
+++ b/csharp/src/Workflow.EVM/Workflows/NetworkRuntime.cs
@@ -163,6 +163,10 @@ await Task.WhenAll(desiredListeners.Select(x =>
 
         _activeFilterAddresses = wallets.Select(w => w.Address).Distinct().ToArray();
 
+        // Push updated subscriptions (with filter addresses) to all listeners
+        await Task.WhenAll(_activeListeners.Select(listener =>
+            SignalUpdateSubscriptionsAsync(listener)));
+
         // Reconcile transaction processors
         var desiredProcessorIds = wallets
             .Select(w => TemporalHelper.BuildTransactionProcessorId(_networkSlug, w.Address))
diff --git a/csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs b/csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs
index cfb3f6d7..8369efaa 100644
--- a/csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs
+++ b/csharp/src/Workflow.Solana/Activities/SolanaBlockchainActivities.cs
@@ -18,7 +18,8 @@
 namespace Train.Solver.Workflow.Solana.Activities;
 
 public class SolanaBlockchainActivities(
-    ILogger<SolanaBlockchainActivities> logger) : ISolanaBlockchainActivities
+    ILogger<SolanaBlockchainActivities> logger,
+    IHttpClientFactory httpClientFactory) : ISolanaBlockchainActivities
 {
     private const string NetworkType = "solana";
     private const ulong DefaultPriorityFeeFloor = 1000; // microLamports
@@ -170,7 +171,7 @@ public virtual async Task<SolanaBlockhashInfo> GetLatestBlockhashAsync(string no
     public virtual async Task<ulong> GetRecentPriorityFeeAsync(SolanaGetPriorityFeeRequest request)
     {
         // getRecentPrioritizationFees is not in SolNet SDK — use raw HTTP JSON-RPC
-        using var httpClient = new HttpClient();
+        using var httpClient = httpClientFactory.CreateClient();
         var rpcPayload = new
         {
             jsonrpc = "2.0",
@@ -328,45 +329,110 @@ public virtual async Task<SolanaPublishResult> PublishTransactionAsync(SolanaPub
     #region HTLC Transaction Building
 
     [Activity]
-    public virtual Task<string> BuildHTLCLockTransactionAsync(SolanaBuildHTLCLockRequest request)
+    public virtual async Task<string> BuildHTLCLockTransactionAsync(SolanaBuildHTLCLockRequest request)
     {
         var senderPubkey = new PublicKey(request.SenderAddress);
         var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
         var systemProgramPubkey = new PublicKey(SolanaHelper.SystemProgramId);
 
-        // Derive PDA from Id (= hashlock for lock())
-        PublicKey.TryFindProgramAddress(
-            [request.Hashlock],
-            programPubkey,
-            out var htlcPda,
-            out _);
-
-        // Build instruction data
-        var instructionData = SolanaAnchorHelper.BuildLockInstructionData(
-            request.Hashlock,
-            request.Timelock,
-            request.Amount,
-            request.DstChain,
-            request.DstAddress,
-            request.DstAsset,
-            request.SrcAsset,
-            request.SrcReceiver);
-
-        // Account metas: sender(signer,mut), htlc(init,mut,PDA), system_program, rent
-        var rentPubkey = new PublicKey("SysvarRent111111111111111111111111111111111");
-        var keys = new List<Solnet.Rpc.Models.AccountMeta>
+        byte[] instructionData;
+        List<Solnet.Rpc.Models.AccountMeta> keys;
+
+        if (request.IsSolverLock)
         {
-            Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, true),
-            Solnet.Rpc.Models.AccountMeta.Writable(htlcPda, false),
-            Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
-            Solnet.Rpc.Models.AccountMeta.ReadOnly(rentPubkey, false)
-        };
+            // Solver lock: need counter PDA and solver lock PDA
+            var counterPda = SolanaAnchorHelper.DeriveSolverCountPDA(request.Hashlock, SolanaHelper.HTLCProgramId);
+
+            // Read counter to get next index (1 if counter doesn't exist)
+            ulong nextIndex = 1;
+            if (counterPda != null)
+            {
+                using var httpClient = httpClientFactory.CreateClient();
+                var counterData = await GetAccountData(httpClient, request.NodeUrl, counterPda.Key);
+                if (counterData != null)
+                {
+                    var count = SolanaAnchorHelper.ParseSolverCounterAccount(counterData);
+                    if (count.HasValue)
+                        nextIndex = count.Value + 1;
+                }
+            }
+
+            var solverLockPda = SolanaAnchorHelper.DeriveSolverLockPDA(request.Hashlock, nextIndex, SolanaHelper.HTLCProgramId);
+
+            var rewardRecipient = string.IsNullOrEmpty(request.RewardRecipient)
+                ? request.SenderAddress
+                : request.RewardRecipient;
+
+            instructionData = SolanaAnchorHelper.BuildSolverLockSolInstructionData(
+                hashlock: request.Hashlock,
+                index: nextIndex,
+                amount: request.Amount,
+                reward: request.Reward,
+                timelockDelta: request.Timelock,
+                rewardTimelockDelta: request.RewardTimelockDelta,
+                sender: request.SenderAddress,
+                recipient: request.SrcReceiver,
+                rewardRecipient: rewardRecipient,
+                srcChain: request.SrcChain,
+                dstChain: request.DstChain,
+                dstAddress: request.DstAddress,
+                dstAmount: request.DstAmount,
+                dstToken: request.DstAsset,
+                data: request.Data);
+
+            // Accounts: signer, counter, solverLock, systemProgram
+            keys =
+            [
+                Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, true),
+                Solnet.Rpc.Models.AccountMeta.Writable(counterPda!, false),
+                Solnet.Rpc.Models.AccountMeta.Writable(solverLockPda!, false),
+                Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
+            ];
+        }
+        else
+        {
+            // User lock: PDA from ["user_lock", hashlock]
+            var userLockPda = SolanaAnchorHelper.DeriveUserLockPDA(request.Hashlock, SolanaHelper.HTLCProgramId);
+
+            var rewardRecipient = string.IsNullOrEmpty(request.RewardRecipient)
+                ? request.SenderAddress
+                : request.RewardRecipient;
+
+            instructionData = SolanaAnchorHelper.BuildUserLockSolInstructionData(
+                hashlock: request.Hashlock,
+                amount: request.Amount,
+                timelockDelta: request.Timelock,
+                quoteExpiry: request.QuoteExpiry,
+                sender: request.SenderAddress,
+                recipient: request.SrcReceiver,
+                srcChain: request.SrcChain,
+                dstChain: request.DstChain,
+                dstAddress: request.DstAddress,
+                dstAmount: request.DstAmount,
+                dstToken: request.DstAsset,
+                rewardAmount: request.RewardAmount,
+                rewardToken: request.RewardToken,
+                rewardRecipient: rewardRecipient,
+                rewardTimelockDelta: request.RewardTimelockDelta,
+                userData: request.UserData,
+                solverData: request.SolverData);
+
+            // Accounts: signer, userLock, systemProgram
+            keys =
+            [
+                Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, true),
+                Solnet.Rpc.Models.AccountMeta.Writable(userLockPda!, false),
+                Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
+            ];
+        }
+
         var htlcInstruction = Solnet.Rpc.Builders.TransactionInstructionFactory.Create(programPubkey, keys, instructionData);
 
         var builder = new TransactionBuilder()
             .SetFeePayer(senderPubkey)
             .SetRecentBlockHash(request.RecentBlockhash);
 
+        builder.AddInstruction(SolanaHelper.RequestHeapFrame());
         builder.AddInstruction(SolanaHelper.SetComputeUnitLimit(request.ComputeUnitLimit));
         if (request.PriorityFeeMicroLamports > 0)
             builder.AddInstruction(SolanaHelper.SetComputeUnitPrice(request.PriorityFeeMicroLamports));
@@ -374,44 +440,63 @@ public virtual Task<string> BuildHTLCLockTransactionAsync(SolanaBuildHTLCLockReq
 
         var messageBytes = builder.CompileMessage();
         var unsignedTx = BuildUnsignedTransaction(messageBytes, 1);
-        return Task.FromResult(Convert.ToBase64String(unsignedTx));
+        return Convert.ToBase64String(unsignedTx);
     }
 
     [Activity]
     public virtual Task<string> BuildHTLCRedeemTransactionAsync(SolanaBuildHTLCRedeemRequest request)
     {
         var signerPubkey = new PublicKey(request.SignerAddress);
-        var senderPubkey = new PublicKey(request.SenderAddress);
-        var srcReceiverPubkey = new PublicKey(request.SrcReceiverAddress);
         var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
         var systemProgramPubkey = new PublicKey(SolanaHelper.SystemProgramId);
 
-        // Derive PDA from Id
-        PublicKey.TryFindProgramAddress(
-            [request.Id],
-            programPubkey,
-            out var htlcPda,
-            out _);
-
-        var instructionData = SolanaAnchorHelper.BuildRedeemInstructionData(request.Id, request.Secret);
+        byte[] instructionData;
+        List<Solnet.Rpc.Models.AccountMeta> keys;
 
-        // Account metas: user_signing(signer,mut), sender(unchecked,mut), src_receiver(unchecked,mut), htlc(mut,PDA), system_program, rent
-        var rentPubkey = new PublicKey("SysvarRent111111111111111111111111111111111");
-        var keys = new List<Solnet.Rpc.Models.AccountMeta>
+        if (request.IsRedeemingUserLock)
         {
-            Solnet.Rpc.Models.AccountMeta.Writable(signerPubkey, true),
-            Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, false),
-            Solnet.Rpc.Models.AccountMeta.Writable(srcReceiverPubkey, false),
-            Solnet.Rpc.Models.AccountMeta.Writable(htlcPda, false),
-            Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
-            Solnet.Rpc.Models.AccountMeta.ReadOnly(rentPubkey, false)
-        };
+            // redeem_user_sol: solver redeems user's lock
+            var userLockPda = SolanaAnchorHelper.DeriveUserLockPDA(request.Id, SolanaHelper.HTLCProgramId);
+
+            instructionData = SolanaAnchorHelper.BuildRedeemUserSolInstructionData(request.Id, request.Secret);
+
+            // Accounts: caller, userLock, recipient (srcReceiver), systemProgram
+            var recipientPubkey = new PublicKey(request.SrcReceiverAddress);
+            keys =
+            [
+                Solnet.Rpc.Models.AccountMeta.Writable(signerPubkey, true),
+                Solnet.Rpc.Models.AccountMeta.Writable(userLockPda!, false),
+                Solnet.Rpc.Models.AccountMeta.Writable(recipientPubkey, false),
+                Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
+            ];
+        }
+        else
+        {
+            // redeem_solver_sol: user redeems solver's lock
+            var solverLockPda = SolanaAnchorHelper.DeriveSolverLockPDA(request.Id, request.Index, SolanaHelper.HTLCProgramId);
+
+            instructionData = SolanaAnchorHelper.BuildRedeemSolverSolInstructionData(request.Id, request.Index, request.Secret);
+
+            // Accounts: caller, solverLock, recipient (srcReceiver), rewardRecipient, systemProgram
+            var recipientPubkey = new PublicKey(request.SrcReceiverAddress);
+            var rewardRecipientPubkey = new PublicKey(request.RewardRecipientAddress ?? request.SenderAddress);
+            keys =
+            [
+                Solnet.Rpc.Models.AccountMeta.Writable(signerPubkey, true),
+                Solnet.Rpc.Models.AccountMeta.Writable(solverLockPda!, false),
+                Solnet.Rpc.Models.AccountMeta.Writable(recipientPubkey, false),
+                Solnet.Rpc.Models.AccountMeta.Writable(rewardRecipientPubkey, false),
+                Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
+            ];
+        }
+
         var htlcInstruction = Solnet.Rpc.Builders.TransactionInstructionFactory.Create(programPubkey, keys, instructionData);
 
         var builder = new TransactionBuilder()
             .SetFeePayer(signerPubkey)
             .SetRecentBlockHash(request.RecentBlockhash);
 
+        builder.AddInstruction(SolanaHelper.RequestHeapFrame());
         builder.AddInstruction(SolanaHelper.SetComputeUnitLimit(request.ComputeUnitLimit));
         if (request.PriorityFeeMicroLamports > 0)
             builder.AddInstruction(SolanaHelper.SetComputeUnitPrice(request.PriorityFeeMicroLamports));
@@ -430,24 +515,29 @@ public virtual Task<string> BuildHTLCRefundTransactionAsync(SolanaBuildHTLCRefun
         var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
         var systemProgramPubkey = new PublicKey(SolanaHelper.SystemProgramId);
 
-        // Derive PDA from Id
-        PublicKey.TryFindProgramAddress(
-            [request.Id],
-            programPubkey,
-            out var htlcPda,
-            out _);
+        byte[] instructionData;
+        PublicKey lockPda;
 
-        var instructionData = SolanaAnchorHelper.BuildRefundInstructionData(request.Id);
+        if (request.IsRefundingSolverLock)
+        {
+            // refund_solver_sol: solver refunds own lock
+            lockPda = SolanaAnchorHelper.DeriveSolverLockPDA(request.Id, request.Index, SolanaHelper.HTLCProgramId)!;
+            instructionData = SolanaAnchorHelper.BuildRefundSolverSolInstructionData(request.Id, request.Index);
+        }
+        else
+        {
+            // refund_user_sol: user refunds own lock
+            lockPda = SolanaAnchorHelper.DeriveUserLockPDA(request.Id, SolanaHelper.HTLCProgramId)!;
+            instructionData = SolanaAnchorHelper.BuildRefundUserSolInstructionData(request.Id);
+        }
 
-        // Account metas: user_signing(signer,mut), htlc(mut,PDA), sender(unchecked,mut), system_program, rent
-        var rentPubkey = new PublicKey("SysvarRent111111111111111111111111111111111");
+        // Accounts: caller, lockPDA, sender, systemProgram
         var keys = new List<Solnet.Rpc.Models.AccountMeta>
         {
             Solnet.Rpc.Models.AccountMeta.Writable(signerPubkey, true),
-            Solnet.Rpc.Models.AccountMeta.Writable(htlcPda, false),
+            Solnet.Rpc.Models.AccountMeta.Writable(lockPda, false),
             Solnet.Rpc.Models.AccountMeta.Writable(senderPubkey, false),
             Solnet.Rpc.Models.AccountMeta.ReadOnly(systemProgramPubkey, false),
-            Solnet.Rpc.Models.AccountMeta.ReadOnly(rentPubkey, false)
         };
         var htlcInstruction = Solnet.Rpc.Builders.TransactionInstructionFactory.Create(programPubkey, keys, instructionData);
 
@@ -455,6 +545,7 @@ public virtual Task<string> BuildHTLCRefundTransactionAsync(SolanaBuildHTLCRefun
             .SetFeePayer(signerPubkey)
             .SetRecentBlockHash(request.RecentBlockhash);
 
+        builder.AddInstruction(SolanaHelper.RequestHeapFrame());
         builder.AddInstruction(SolanaHelper.SetComputeUnitLimit(request.ComputeUnitLimit));
         if (request.PriorityFeeMicroLamports > 0)
             builder.AddInstruction(SolanaHelper.SetComputeUnitPrice(request.PriorityFeeMicroLamports));
@@ -468,26 +559,26 @@ public virtual Task<string> BuildHTLCRefundTransactionAsync(SolanaBuildHTLCRefun
     [Activity]
     public virtual async Task<SolanaHTLCAccount?> GetHTLCAccountDataAsync(SolanaGetHTLCAccountRequest request)
     {
-        var programPubkey = new PublicKey(SolanaHelper.HTLCProgramId);
+        PublicKey? pda;
 
-        PublicKey.TryFindProgramAddress(
-            [request.Id],
-            programPubkey,
-            out var htlcPda,
-            out _);
+        if (request.IsUserLock)
+            pda = SolanaAnchorHelper.DeriveUserLockPDA(request.Hashlock, SolanaHelper.HTLCProgramId);
+        else
+            pda = SolanaAnchorHelper.DeriveSolverLockPDA(request.Hashlock, request.Index, SolanaHelper.HTLCProgramId);
 
-        if (htlcPda == null)
+        if (pda == null)
             return null;
 
-        using var httpClient = new HttpClient();
-        var accountData = await GetAccountData(httpClient, request.NodeUrl, htlcPda.Key);
+        using var httpClient = httpClientFactory.CreateClient();
+        var accountData = await GetAccountData(httpClient, request.NodeUrl, pda.Key);
         if (accountData == null || accountData.Length < 8)
             return null;
 
-        if (!SolanaAnchorHelper.MatchesDiscriminator(accountData, SolanaAnchorHelper.HTLCAccountDiscriminator))
-            return null;
-
-        return SolanaAnchorHelper.ParseHTLCAccount(accountData);
+        // Try parsing as UserLock or SolverLock based on the request
+        if (request.IsUserLock)
+            return SolanaAnchorHelper.ParseUserLockAccount(accountData);
+        else
+            return SolanaAnchorHelper.ParseSolverLockAccount(accountData);
     }
 
     #endregion
@@ -497,7 +588,7 @@ public virtual Task<string> BuildHTLCRefundTransactionAsync(SolanaBuildHTLCRefun
     [Activity]
     public virtual async Task<SolanaHTLCEventResult> GetHTLCEventsAsync(SolanaGetHTLCEventsRequest request)
     {
-        using var httpClient = new HttpClient();
+        using var httpClient = httpClientFactory.CreateClient();
         var result = new SolanaHTLCEventResult();
 
         // 1. Get recent signatures for the HTLC program
@@ -555,6 +646,14 @@ private async Task ProcessTransaction(
         var txResult = await GetTransaction(httpClient, request.NodeUrl, signature);
         if (txResult is not { } tx) return;
 
+        // Extract block time for absolute timelock computation
+        long blockTime = 0;
+        if (tx.TryGetProperty("blockTime", out var blockTimeElement) &&
+            blockTimeElement.ValueKind == JsonValueKind.Number)
+        {
+            blockTime = blockTimeElement.GetInt64();
+        }
+
         // Find the instruction targeting the HTLC program
         if (!tx.TryGetProperty("transaction", out var transaction)) return;
         if (!transaction.TryGetProperty("message", out var message)) return;
@@ -563,9 +662,6 @@ private async Task ProcessTransaction(
         var programIndex = FindProgramIndex(accountKeys, request.ProgramId);
         if (programIndex < 0) return;
 
-        // Check inner instructions and top-level instructions
-        if (!transaction.TryGetProperty("message", out _)) return;
-
         var instructions = message.TryGetProperty("instructions", out var instrs)
             ? instrs : default;
 
@@ -593,87 +689,152 @@ private async Task ProcessTransaction(
             var functionName = SolanaAnchorHelper.IdentifyFunction(instructionData);
             if (functionName == null) continue;
 
-            // Read the HTLC PDA account from the transaction's account list
-            var htlcAccount = await TryGetHTLCAccountFromTx(
-                httpClient, request.NodeUrl, instr, accountKeys, request.ProgramId);
-
-            if (htlcAccount == null)
+            switch (functionName)
             {
-                logger.LogDebug("Could not read HTLC account for {Function} in tx {Sig}", functionName, signature);
-                continue;
-            }
+                case "user_lock_sol":
+                {
+                    var lockArgs = SolanaAnchorHelper.ParseUserLockInstructionData(instructionData);
+                    if (lockArgs == null)
+                    {
+                        logger.LogWarning("Failed to parse user_lock_sol instruction data in tx {Sig}", signature);
+                        continue;
+                    }
 
-            var isSolverWallet = request.SolverWalletAddresses
-                .Any(w => string.Equals(w, htlcAccount.Sender, StringComparison.OrdinalIgnoreCase));
+                    result.LockedEvents.Add(new SolanaHTLCLockedEvent
+                    {
+                        TxSignature = signature,
+                        Slot = slot,
+                        Hashlock = lockArgs.Hashlock,
+                        Sender = lockArgs.Sender,
+                        SrcReceiver = lockArgs.SrcReceiver,
+                        Amount = lockArgs.Amount,
+                        Timelock = blockTime + (long)lockArgs.TimelockDelta,
+                        DstAddress = lockArgs.DstAddress,
+                        DstChain = lockArgs.DstChain,
+                        DstAsset = lockArgs.DstToken,
+                        SrcAsset = SolanaHelper.SystemProgramId,
+                        DstAmount = lockArgs.DstAmount,
+                        SrcChain = lockArgs.SrcChain,
+                        TimelockDelta = lockArgs.TimelockDelta,
+                        QuoteExpiry = lockArgs.QuoteExpiry,
+                        RewardAmount = lockArgs.RewardAmount,
+                        RewardToken = lockArgs.RewardToken,
+                        RewardRecipient = lockArgs.RewardRecipient,
+                        RewardTimelockDelta = lockArgs.RewardTimelockDelta,
+                        SolverData = lockArgs.SolverData is { Length: > 0 }
+                            ? "0x" + Convert.ToHexString(lockArgs.SolverData).ToLowerInvariant()
+                            : null,
+                        IsUserLock = true
+                    });
+                    break;
+                }
+
+                case "solver_lock_sol":
+                {
+                    var lockArgs = SolanaAnchorHelper.ParseSolverLockInstructionData(instructionData);
+                    if (lockArgs == null)
+                    {
+                        logger.LogWarning("Failed to parse solver_lock_sol instruction data in tx {Sig}", signature);
+                        continue;
+                    }
 
-            switch (functionName)
-            {
-                case "lock":
-                    // lock() is always called by solver
                     result.LockedEvents.Add(new SolanaHTLCLockedEvent
                     {
                         TxSignature = signature,
                         Slot = slot,
-                        Hashlock = htlcAccount.Hashlock,
-                        Sender = htlcAccount.Sender,
-                        SrcReceiver = htlcAccount.SrcReceiver,
-                        Amount = htlcAccount.Amount,
-                        Reward = htlcAccount.Reward,
-                        Timelock = htlcAccount.Timelock,
-                        RewardTimelock = htlcAccount.RewardTimelock,
-                        DstAddress = htlcAccount.DstAddress,
-                        DstChain = htlcAccount.DstChain,
-                        DstAsset = htlcAccount.DstAsset,
-                        SrcAsset = htlcAccount.SrcAsset,
+                        Hashlock = lockArgs.Hashlock,
+                        Sender = lockArgs.Sender,
+                        SrcReceiver = lockArgs.SrcReceiver,
+                        Amount = lockArgs.Amount,
+                        Timelock = blockTime + (long)lockArgs.TimelockDelta,
+                        DstAddress = lockArgs.DstAddress,
+                        DstChain = lockArgs.DstChain,
+                        DstAsset = lockArgs.DstToken,
+                        SrcAsset = SolanaHelper.SystemProgramId,
                         IsUserLock = false
                     });
                     break;
+                }
 
-                case "add_lock":
-                case "add_lock_sig":
-                    // add_lock/add_lock_sig adds hashlock to user's commit — this is user lock
-                    result.LockedEvents.Add(new SolanaHTLCLockedEvent
+                case "redeem_user_sol":
+                {
+                    var redeemData = SolanaAnchorHelper.ParseRedeemUserSolInstructionData(instructionData);
+                    if (redeemData == null)
+                    {
+                        logger.LogWarning("Failed to parse redeem_user_sol instruction data in tx {Sig}", signature);
+                        continue;
+                    }
+
+                    result.RedeemedEvents.Add(new SolanaHTLCRedeemedEvent
                     {
                         TxSignature = signature,
                         Slot = slot,
-                        Hashlock = htlcAccount.Hashlock,
-                        Sender = htlcAccount.Sender,
-                        SrcReceiver = htlcAccount.SrcReceiver,
-                        Amount = htlcAccount.Amount,
-                        Reward = htlcAccount.Reward,
-                        Timelock = htlcAccount.Timelock,
-                        RewardTimelock = htlcAccount.RewardTimelock,
-                        DstAddress = htlcAccount.DstAddress,
-                        DstChain = htlcAccount.DstChain,
-                        DstAsset = htlcAccount.DstAsset,
-                        SrcAsset = htlcAccount.SrcAsset,
-                        IsUserLock = true
+                        Hashlock = redeemData.Value.Hashlock,
+                        Secret = redeemData.Value.Secret,
+                        RedeemAddress = GetTransactionSigner(transaction),
+                        IsSolverLock = false
                     });
                     break;
+                }
+
+                case "redeem_solver_sol":
+                {
+                    var redeemData = SolanaAnchorHelper.ParseRedeemSolverSolInstructionData(instructionData);
+                    if (redeemData == null)
+                    {
+                        logger.LogWarning("Failed to parse redeem_solver_sol instruction data in tx {Sig}", signature);
+                        continue;
+                    }
 
-                case "redeem":
                     result.RedeemedEvents.Add(new SolanaHTLCRedeemedEvent
                     {
                         TxSignature = signature,
                         Slot = slot,
-                        Hashlock = htlcAccount.Hashlock,
-                        Secret = htlcAccount.Secret,
+                        Hashlock = redeemData.Value.Hashlock,
+                        Secret = redeemData.Value.Secret,
                         RedeemAddress = GetTransactionSigner(transaction),
-                        IsSolverLock = isSolverWallet
+                        IsSolverLock = true
                     });
                     break;
+                }
+
+                case "refund_user_sol":
+                {
+                    var hashlock = SolanaAnchorHelper.ParseRefundUserSolInstructionData(instructionData);
+                    if (hashlock == null)
+                    {
+                        logger.LogWarning("Failed to parse refund_user_sol instruction data in tx {Sig}", signature);
+                        continue;
+                    }
 
-                case "refund":
                     result.RefundedEvents.Add(new SolanaHTLCRefundedEvent
                     {
                         TxSignature = signature,
                         Slot = slot,
-                        Hashlock = htlcAccount.Hashlock,
-                        IsSolverLock = isSolverWallet
+                        Hashlock = hashlock,
+                        IsSolverLock = false
                     });
                     break;
+                }
+
+                case "refund_solver_sol":
+                {
+                    var refundData = SolanaAnchorHelper.ParseRefundSolverSolInstructionData(instructionData);
+                    if (refundData == null)
+                    {
+                        logger.LogWarning("Failed to parse refund_solver_sol instruction data in tx {Sig}", signature);
+                        continue;
+                    }
 
-                // commit and lock_reward are skipped (no hashlock / supplementary)
+                    result.RefundedEvents.Add(new SolanaHTLCRefundedEvent
+                    {
+                        TxSignature = signature,
+                        Slot = slot,
+                        Hashlock = refundData.Value.Hashlock,
+                        IsSolverLock = true
+                    });
+                    break;
+                }
             }
         }
     }
@@ -740,37 +901,17 @@ private async Task<List<JsonElement>> GetSignaturesForAddress(
         return result;
     }
 
-    private async Task<SolanaHTLCAccount?> TryGetHTLCAccountFromTx(
-        HttpClient httpClient, string nodeUrl,
-        JsonElement instruction, JsonElement accountKeys, string programId)
+    private async Task<SolanaHTLCAccount?> TryGetUserLockAccount(
+        HttpClient httpClient, string nodeUrl, byte[] hashlock)
     {
-        // The HTLC PDA is typically the first account in the instruction's accounts list
-        if (!instruction.TryGetProperty("accounts", out var accounts) ||
-            accounts.GetArrayLength() == 0)
-            return null;
-
-        // Try the first few accounts — the PDA is usually account[0] or account[1]
-        foreach (var accountIndex in accounts.EnumerateArray().Take(3))
-        {
-            var idx = accountIndex.GetInt32();
-            if (idx >= accountKeys.GetArrayLength()) continue;
-
-            var accountAddress = accountKeys[idx].GetString();
-            if (string.IsNullOrEmpty(accountAddress)) continue;
-
-            var accountData = await GetAccountData(httpClient, nodeUrl, accountAddress);
-            if (accountData == null || accountData.Length < 8) continue;
+        var pda = SolanaAnchorHelper.DeriveUserLockPDA(hashlock, SolanaHelper.HTLCProgramId);
+        if (pda == null) return null;
 
-            // Verify Anchor account discriminator
-            if (!SolanaAnchorHelper.MatchesDiscriminator(accountData, SolanaAnchorHelper.HTLCAccountDiscriminator))
-                continue;
-
-            var parsed = SolanaAnchorHelper.ParseHTLCAccount(accountData);
-            if (parsed != null)
-                return parsed;
-        }
+        var accountData = await GetAccountData(httpClient, nodeUrl, pda.Key);
+        if (accountData == null || accountData.Length < 8)
+            return null;
 
-        return null;
+        return SolanaAnchorHelper.ParseUserLockAccount(accountData);
     }
 
     private async Task<byte[]?> GetAccountData(HttpClient httpClient, string nodeUrl, string address)
diff --git a/csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs b/csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs
index 2c6ef3c1..59f0d21d 100644
--- a/csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs
+++ b/csharp/src/Workflow.Solana/Extensions/TrainSolverBuilderExtensions.cs
@@ -27,6 +27,9 @@ public static TrainSolverBuilder WithSolanaWorkflows(this TrainSolverBuilder bui
             .AddTransientActivities<SolanaWorkflowActivities>()
             .AddTransientActivities<WorkflowActivities>();
 
+        // HttpClient factory for Solana RPC calls (avoids socket exhaustion from new HttpClient())
+        builder.Services.AddHttpClient();
+
         // Redis dependencies (IConnectionMultiplexer + IDatabase) — used for TP state persistence
         builder.Services.TryAddSingleton<IConnectionMultiplexer>(
             _ => ConnectionMultiplexer.Connect(builder.Options.RedisConnectionString));
diff --git a/csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs b/csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs
index 8fe04f2e..c01975b8 100644
--- a/csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs
+++ b/csharp/src/Workflow.Solana/Helpers/SolanaAnchorHelper.cs
@@ -6,22 +6,23 @@
 namespace Train.Solver.Workflow.Solana.Helpers;
 
 /// <summary>
-/// Anchor instruction discriminator computation and HTLC account parsing.
+/// Anchor instruction discriminator computation, PDA derivation, and HTLC instruction builders.
 /// Discriminator = sha256("global:{function_name}")[..8]
 /// </summary>
 public static class SolanaAnchorHelper
 {
-    // Anchor account discriminator for HTLC struct: sha256("account:HTLC")[..8]
-    public static readonly byte[] HTLCAccountDiscriminator = ComputeAccountDiscriminator("HTLC");
-
-    // Precomputed instruction discriminators
-    public static readonly byte[] CommitDiscriminator = ComputeDiscriminator("commit");
-    public static readonly byte[] LockDiscriminator = ComputeDiscriminator("lock");
-    public static readonly byte[] LockRewardDiscriminator = ComputeDiscriminator("lock_reward");
-    public static readonly byte[] AddLockDiscriminator = ComputeDiscriminator("add_lock");
-    public static readonly byte[] AddLockSigDiscriminator = ComputeDiscriminator("add_lock_sig");
-    public static readonly byte[] RedeemDiscriminator = ComputeDiscriminator("redeem");
-    public static readonly byte[] RefundDiscriminator = ComputeDiscriminator("refund");
+    // Precomputed instruction discriminators for the native_htlc program
+    public static readonly byte[] UserLockSolDiscriminator = ComputeDiscriminator("user_lock_sol");
+    public static readonly byte[] SolverLockSolDiscriminator = ComputeDiscriminator("solver_lock_sol");
+    public static readonly byte[] RedeemUserSolDiscriminator = ComputeDiscriminator("redeem_user_sol");
+    public static readonly byte[] RedeemSolverSolDiscriminator = ComputeDiscriminator("redeem_solver_sol");
+    public static readonly byte[] RefundUserSolDiscriminator = ComputeDiscriminator("refund_user_sol");
+    public static readonly byte[] RefundSolverSolDiscriminator = ComputeDiscriminator("refund_solver_sol");
+
+    // Anchor account discriminators
+    public static readonly byte[] UserLockAccountDiscriminator = ComputeAccountDiscriminator("UserLock");
+    public static readonly byte[] SolverLockAccountDiscriminator = ComputeAccountDiscriminator("SolverLock");
+    public static readonly byte[] SolverCounterAccountDiscriminator = ComputeAccountDiscriminator("SolverCounter");
 
     public static byte[] ComputeDiscriminator(string functionName)
     {
@@ -35,85 +36,284 @@ public static byte[] ComputeAccountDiscriminator(string accountName)
         return hash[..8];
     }
 
-    public static bool MatchesDiscriminator(byte[] instructionData, byte[] discriminator)
+    public static bool MatchesDiscriminator(byte[] data, byte[] discriminator)
     {
-        if (instructionData.Length < 8) return false;
-        return instructionData.AsSpan(0, 8).SequenceEqual(discriminator);
+        if (data.Length < 8) return false;
+        return data.AsSpan(0, 8).SequenceEqual(discriminator);
     }
 
     /// <summary>
     /// Identifies which HTLC function was called from instruction data.
-    /// Returns null for unknown instructions.
     /// </summary>
     public static string? IdentifyFunction(byte[] instructionData)
     {
         if (instructionData.Length < 8) return null;
 
-        if (MatchesDiscriminator(instructionData, CommitDiscriminator)) return "commit";
-        if (MatchesDiscriminator(instructionData, LockDiscriminator)) return "lock";
-        if (MatchesDiscriminator(instructionData, LockRewardDiscriminator)) return "lock_reward";
-        if (MatchesDiscriminator(instructionData, AddLockDiscriminator)) return "add_lock";
-        if (MatchesDiscriminator(instructionData, AddLockSigDiscriminator)) return "add_lock_sig";
-        if (MatchesDiscriminator(instructionData, RedeemDiscriminator)) return "redeem";
-        if (MatchesDiscriminator(instructionData, RefundDiscriminator)) return "refund";
+        if (MatchesDiscriminator(instructionData, UserLockSolDiscriminator)) return "user_lock_sol";
+        if (MatchesDiscriminator(instructionData, SolverLockSolDiscriminator)) return "solver_lock_sol";
+        if (MatchesDiscriminator(instructionData, RedeemUserSolDiscriminator)) return "redeem_user_sol";
+        if (MatchesDiscriminator(instructionData, RedeemSolverSolDiscriminator)) return "redeem_solver_sol";
+        if (MatchesDiscriminator(instructionData, RefundUserSolDiscriminator)) return "refund_user_sol";
+        if (MatchesDiscriminator(instructionData, RefundSolverSolDiscriminator)) return "refund_solver_sol";
 
         return null;
     }
 
+    #region PDA Derivation
+
+    /// <summary>
+    /// Derives user lock PDA. Seeds: ["user_lock", hashlock].
+    /// </summary>
+    public static PublicKey? DeriveUserLockPDA(byte[] hashlock, string programId)
+    {
+        PublicKey.TryFindProgramAddress(
+            [Encoding.UTF8.GetBytes("user_lock"), hashlock],
+            new PublicKey(programId),
+            out var pda,
+            out _);
+        return pda;
+    }
+
     /// <summary>
-    /// Parses Anchor HTLC account data (after 8-byte account discriminator).
-    /// Layout matches the Rust struct with Borsh encoding:
-    ///   dst_address: String (4-byte len + utf8)
-    ///   dst_chain: String
-    ///   dst_asset: String
-    ///   src_asset: String
-    ///   sender: Pubkey (32 bytes)
-    ///   src_receiver: Pubkey (32 bytes)
-    ///   hashlock: [u8; 32]
-    ///   secret: [u8; 32]
-    ///   amount: u64 (8 bytes LE)
-    ///   reward: u64
-    ///   timelock: u64
-    ///   reward_timelock: u64
-    ///   claimed: u8
+    /// Derives solver lock PDA. Seeds: ["solver_lock", hashlock, index_u64_le].
     /// </summary>
-    public static SolanaHTLCAccount? ParseHTLCAccount(byte[] data)
+    public static PublicKey? DeriveSolverLockPDA(byte[] hashlock, ulong index, string programId)
+    {
+        var indexBytes = new byte[8];
+        BitConverter.TryWriteBytes(indexBytes, index);
+        PublicKey.TryFindProgramAddress(
+            [Encoding.UTF8.GetBytes("solver_lock"), hashlock, indexBytes],
+            new PublicKey(programId),
+            out var pda,
+            out _);
+        return pda;
+    }
+
+    /// <summary>
+    /// Derives solver counter PDA. Seeds: ["solver_count", hashlock].
+    /// </summary>
+    public static PublicKey? DeriveSolverCountPDA(byte[] hashlock, string programId)
+    {
+        PublicKey.TryFindProgramAddress(
+            [Encoding.UTF8.GetBytes("solver_count"), hashlock],
+            new PublicKey(programId),
+            out var pda,
+            out _);
+        return pda;
+    }
+
+    #endregion
+
+    #region Account Parsing
+
+    /// <summary>
+    /// Parses UserLock account data (after 8-byte Anchor discriminator).
+    /// Layout (estimated): sender(32) + srcReceiver(32) + secret(32) + amount(u64) + timelock(u64) + status(u8) + ...
+    /// We extract what we need for redeem/refund account metas.
+    /// </summary>
+    public static SolanaHTLCAccount? ParseUserLockAccount(byte[] data)
     {
         try
         {
-            var offset = 8; // Skip Anchor account discriminator
+            if (data.Length < 8) return null;
 
-            var dstAddress = ReadBorshString(data, ref offset);
-            var dstChain = ReadBorshString(data, ref offset);
-            var dstAsset = ReadBorshString(data, ref offset);
-            var srcAsset = ReadBorshString(data, ref offset);
+            // Verify discriminator
+            if (!MatchesDiscriminator(data, UserLockAccountDiscriminator))
+                return null;
+
+            var offset = 8; // Skip Anchor account discriminator
 
+            // Parse fields — order depends on contract struct definition
+            // We try: secret(32) + amount(u64) + sender(32) + timelock(u64) + status(u8) + src_receiver(32)
+            // This is the same layout as the old HTLC account; if wrong, we'll adjust after testing
+            var secretBytes = ReadBytes(data, ref offset, 32);
+            var amount = BitConverter.ToUInt64(data, offset); offset += 8;
             var senderBytes = ReadBytes(data, ref offset, 32);
+            var timelock = BitConverter.ToUInt64(data, offset); offset += 8;
+            var status = data[offset]; offset += 1;
             var srcReceiverBytes = ReadBytes(data, ref offset, 32);
-            var hashlockBytes = ReadBytes(data, ref offset, 32);
-            var secretBytes = ReadBytes(data, ref offset, 32);
 
+            return new SolanaHTLCAccount
+            {
+                Secret = Convert.ToHexString(secretBytes).ToLowerInvariant(),
+                Amount = amount,
+                Sender = new PublicKey(senderBytes).Key,
+                Timelock = (long)timelock,
+                Status = status,
+                SrcReceiver = new PublicKey(srcReceiverBytes).Key,
+            };
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Parses SolverLock account data (after 8-byte Anchor discriminator).
+    /// Same field extraction as UserLock — we only need sender, srcReceiver, and rewardRecipient.
+    /// </summary>
+    public static SolanaHTLCAccount? ParseSolverLockAccount(byte[] data)
+    {
+        try
+        {
+            if (data.Length < 8) return null;
+
+            if (!MatchesDiscriminator(data, SolverLockAccountDiscriminator))
+                return null;
+
+            var offset = 8;
+
+            // Same layout assumption — extract what we need
+            var secretBytes = ReadBytes(data, ref offset, 32);
             var amount = BitConverter.ToUInt64(data, offset); offset += 8;
-            var reward = BitConverter.ToUInt64(data, offset); offset += 8;
+            var senderBytes = ReadBytes(data, ref offset, 32);
             var timelock = BitConverter.ToUInt64(data, offset); offset += 8;
-            var rewardTimelock = BitConverter.ToUInt64(data, offset); offset += 8;
-            var claimed = data[offset];
+            var status = data[offset]; offset += 1;
+            var srcReceiverBytes = ReadBytes(data, ref offset, 32);
 
             return new SolanaHTLCAccount
             {
-                DstAddress = dstAddress,
-                DstChain = dstChain,
-                DstAsset = dstAsset,
-                SrcAsset = srcAsset,
+                Secret = Convert.ToHexString(secretBytes).ToLowerInvariant(),
+                Amount = amount,
                 Sender = new PublicKey(senderBytes).Key,
+                Timelock = (long)timelock,
+                Status = status,
                 SrcReceiver = new PublicKey(srcReceiverBytes).Key,
+            };
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Parses SolverCounter account to get the current count.
+    /// Layout: discriminator(8) + count(u64)
+    /// </summary>
+    public static ulong? ParseSolverCounterAccount(byte[] data)
+    {
+        try
+        {
+            if (data.Length < 16) return null;
+            if (!MatchesDiscriminator(data, SolverCounterAccountDiscriminator))
+                return null;
+            return BitConverter.ToUInt64(data, 8);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    #endregion
+
+    #region Instruction Data Parsers
+
+    /// <summary>
+    /// Parses user_lock_sol instruction data.
+    /// Layout: disc(8) + hashlock(32) + amount(u64) + timelockDelta(u64) + quoteExpiry(u64)
+    ///   + sender(Pubkey32) + recipient(Pubkey32) + srcChain(String) + dstChain(String)
+    ///   + dstAddress(String) + dstAmount(u64) + dstToken(String) + rewardAmount(u64)
+    ///   + rewardToken(String) + rewardRecipient(String) + rewardTimelockDelta(u64)
+    ///   + userData(Vec&lt;u8&gt;) + solverData(Vec&lt;u8&gt;)
+    /// </summary>
+    public static SolanaUserLockInstructionArgs? ParseUserLockInstructionData(byte[] data)
+    {
+        try
+        {
+            var offset = 8; // Skip discriminator
+
+            var hashlockBytes = ReadBytes(data, ref offset, 32);
+            var amount = BitConverter.ToUInt64(data, offset); offset += 8;
+            var timelockDelta = BitConverter.ToUInt64(data, offset); offset += 8;
+            var quoteExpiry = BitConverter.ToUInt64(data, offset); offset += 8;
+            var senderBytes = ReadBytes(data, ref offset, 32);
+            var recipientBytes = ReadBytes(data, ref offset, 32);
+            var srcChain = ReadBorshString(data, ref offset);
+            var dstChain = ReadBorshString(data, ref offset);
+            var dstAddress = ReadBorshString(data, ref offset);
+            var dstAmount = BitConverter.ToUInt64(data, offset); offset += 8;
+            var dstToken = ReadBorshString(data, ref offset);
+            var rewardAmount = BitConverter.ToUInt64(data, offset); offset += 8;
+            var rewardToken = ReadBorshString(data, ref offset);
+            var rewardRecipient = ReadBorshString(data, ref offset);
+            var rewardTimelockDelta = BitConverter.ToUInt64(data, offset); offset += 8;
+            var userData = ReadBorshVec(data, ref offset);
+            var solverData = ReadBorshVec(data, ref offset);
+
+            return new SolanaUserLockInstructionArgs
+            {
                 Hashlock = Convert.ToHexString(hashlockBytes).ToLowerInvariant(),
-                Secret = Convert.ToHexString(secretBytes).ToLowerInvariant(),
+                Amount = amount,
+                TimelockDelta = timelockDelta,
+                QuoteExpiry = quoteExpiry,
+                Sender = new PublicKey(senderBytes).Key,
+                SrcReceiver = new PublicKey(recipientBytes).Key,
+                SrcChain = srcChain,
+                DstChain = dstChain,
+                DstAddress = dstAddress,
+                DstAmount = dstAmount,
+                DstToken = dstToken,
+                RewardAmount = rewardAmount,
+                RewardToken = rewardToken,
+                RewardRecipient = rewardRecipient,
+                RewardTimelockDelta = rewardTimelockDelta,
+                UserData = userData,
+                SolverData = solverData,
+            };
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Parses solver_lock_sol instruction data.
+    /// Layout: disc(8) + hashlock(32) + index(u64) + amount(u64) + reward(u64) + timelockDelta(u64)
+    ///   + rewardTimelockDelta(u64) + sender(Pubkey32) + recipient(Pubkey32) + rewardRecipient(Pubkey32)
+    ///   + srcChain(String) + dstChain(String) + dstAddress(String) + dstAmount(u64)
+    ///   + dstToken(String) + data(Vec&lt;u8&gt;)
+    /// </summary>
+    public static SolanaSolverLockInstructionArgs? ParseSolverLockInstructionData(byte[] data)
+    {
+        try
+        {
+            var offset = 8;
+
+            var hashlockBytes = ReadBytes(data, ref offset, 32);
+            var index = BitConverter.ToUInt64(data, offset); offset += 8;
+            var amount = BitConverter.ToUInt64(data, offset); offset += 8;
+            var reward = BitConverter.ToUInt64(data, offset); offset += 8;
+            var timelockDelta = BitConverter.ToUInt64(data, offset); offset += 8;
+            var rewardTimelockDelta = BitConverter.ToUInt64(data, offset); offset += 8;
+            var senderBytes = ReadBytes(data, ref offset, 32);
+            var recipientBytes = ReadBytes(data, ref offset, 32);
+            var rewardRecipientBytes = ReadBytes(data, ref offset, 32);
+            var srcChain = ReadBorshString(data, ref offset);
+            var dstChain = ReadBorshString(data, ref offset);
+            var dstAddress = ReadBorshString(data, ref offset);
+            var dstAmount = BitConverter.ToUInt64(data, offset); offset += 8;
+            var dstToken = ReadBorshString(data, ref offset);
+
+            return new SolanaSolverLockInstructionArgs
+            {
+                Hashlock = Convert.ToHexString(hashlockBytes).ToLowerInvariant(),
+                Index = index,
                 Amount = amount,
                 Reward = reward,
-                Timelock = (long)timelock,
-                RewardTimelock = (long)rewardTimelock,
-                Claimed = claimed
+                TimelockDelta = timelockDelta,
+                RewardTimelockDelta = rewardTimelockDelta,
+                Sender = new PublicKey(senderBytes).Key,
+                SrcReceiver = new PublicKey(recipientBytes).Key,
+                RewardRecipient = new PublicKey(rewardRecipientBytes).Key,
+                SrcChain = srcChain,
+                DstChain = dstChain,
+                DstAddress = dstAddress,
+                DstAmount = dstAmount,
+                DstToken = dstToken,
             };
         }
         catch
@@ -123,19 +323,62 @@ public static bool MatchesDiscriminator(byte[] instructionData, byte[] discrimin
     }
 
     /// <summary>
-    /// Derives the PDA address for an HTLC given its Id and program ID.
-    /// PDA = findProgramAddress([Id], programId)
+    /// Parses redeem_user_sol instruction data: disc(8) + hashlock(32) + secret(32)
     /// </summary>
-    public static string? DerivePDA(byte[] id, string programId)
+    public static (string Hashlock, string Secret)? ParseRedeemUserSolInstructionData(byte[] data)
     {
         try
         {
-            PublicKey.TryFindProgramAddress(
-                [id],
-                new PublicKey(programId),
-                out var pda,
-                out _);
-            return pda?.Key;
+            if (data.Length < 72) return null;
+            var offset = 8;
+            var hashlockBytes = ReadBytes(data, ref offset, 32);
+            var secretBytes = ReadBytes(data, ref offset, 32);
+            return (
+                Convert.ToHexString(hashlockBytes).ToLowerInvariant(),
+                Convert.ToHexString(secretBytes).ToLowerInvariant()
+            );
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Parses redeem_solver_sol instruction data: disc(8) + hashlock(32) + index(u64) + secret(32)
+    /// </summary>
+    public static (string Hashlock, ulong Index, string Secret)? ParseRedeemSolverSolInstructionData(byte[] data)
+    {
+        try
+        {
+            if (data.Length < 80) return null;
+            var offset = 8;
+            var hashlockBytes = ReadBytes(data, ref offset, 32);
+            var index = BitConverter.ToUInt64(data, offset); offset += 8;
+            var secretBytes = ReadBytes(data, ref offset, 32);
+            return (
+                Convert.ToHexString(hashlockBytes).ToLowerInvariant(),
+                index,
+                Convert.ToHexString(secretBytes).ToLowerInvariant()
+            );
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Parses refund_user_sol instruction data: disc(8) + hashlock(32)
+    /// </summary>
+    public static string? ParseRefundUserSolInstructionData(byte[] data)
+    {
+        try
+        {
+            if (data.Length < 40) return null;
+            var offset = 8;
+            var hashlockBytes = ReadBytes(data, ref offset, 32);
+            return Convert.ToHexString(hashlockBytes).ToLowerInvariant();
         }
         catch
         {
@@ -143,6 +386,27 @@ public static bool MatchesDiscriminator(byte[] instructionData, byte[] discrimin
         }
     }
 
+    /// <summary>
+    /// Parses refund_solver_sol instruction data: disc(8) + hashlock(32) + index(u64)
+    /// </summary>
+    public static (string Hashlock, ulong Index)? ParseRefundSolverSolInstructionData(byte[] data)
+    {
+        try
+        {
+            if (data.Length < 48) return null;
+            var offset = 8;
+            var hashlockBytes = ReadBytes(data, ref offset, 32);
+            var index = BitConverter.ToUInt64(data, offset);
+            return (Convert.ToHexString(hashlockBytes).ToLowerInvariant(), index);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    #endregion
+
     #region Borsh Write Helpers
 
     public static void WriteBorshU64(List<byte> buf, ulong value)
@@ -173,52 +437,159 @@ public static void WriteBorshBytes32(List<byte> buf, byte[] data)
         buf.AddRange(data);
     }
 
+    /// <summary>
+    /// Writes a Borsh Vec&lt;u8&gt;: 4-byte LE length prefix + raw bytes.
+    /// </summary>
+    public static void WriteBorshVec(List<byte> buf, byte[] data)
+    {
+        Span<byte> lenBytes = stackalloc byte[4];
+        BitConverter.TryWriteBytes(lenBytes, (uint)data.Length);
+        buf.AddRange(lenBytes.ToArray());
+        buf.AddRange(data);
+    }
+
     #endregion
 
     #region Instruction Data Builders
 
     /// <summary>
-    /// Builds instruction data for lock(): discriminator + Id[32] + hashlock[32] + timelock(u64) + amount(u64)
-    /// + dst_chain(String) + dst_address(String) + dst_asset(String) + src_asset(String) + src_receiver(Pubkey)
+    /// Builds instruction data for user_lock_sol:
+    /// disc(8) + hashlock(32) + amount(u64) + timelockDelta(u64) + quoteExpiry(u64)
+    /// + sender(Pubkey) + recipient(Pubkey) + srcChain(String) + dstChain(String)
+    /// + dstAddress(String) + dstAmount(u64) + dstToken(String) + rewardAmount(u64)
+    /// + rewardToken(String) + rewardRecipient(String) + rewardTimelockDelta(u64)
+    /// + userData(Vec&lt;u8&gt;) + solverData(Vec&lt;u8&gt;)
+    /// </summary>
+    public static byte[] BuildUserLockSolInstructionData(
+        byte[] hashlock,
+        ulong amount,
+        ulong timelockDelta,
+        ulong quoteExpiry,
+        string sender,
+        string recipient,
+        string srcChain,
+        string dstChain,
+        string dstAddress,
+        ulong dstAmount,
+        string dstToken,
+        ulong rewardAmount,
+        string rewardToken,
+        string rewardRecipient,
+        ulong rewardTimelockDelta,
+        byte[] userData,
+        byte[] solverData)
+    {
+        var buf = new List<byte>(512);
+        buf.AddRange(UserLockSolDiscriminator);
+        WriteBorshBytes32(buf, hashlock);
+        WriteBorshU64(buf, amount);
+        WriteBorshU64(buf, timelockDelta);
+        WriteBorshU64(buf, quoteExpiry);
+        WriteBorshPubkey(buf, sender);
+        WriteBorshPubkey(buf, recipient);
+        WriteBorshString(buf, srcChain);
+        WriteBorshString(buf, dstChain);
+        WriteBorshString(buf, dstAddress);
+        WriteBorshU64(buf, dstAmount);
+        WriteBorshString(buf, dstToken);
+        WriteBorshU64(buf, rewardAmount);
+        WriteBorshString(buf, rewardToken);
+        WriteBorshString(buf, rewardRecipient); // String, NOT Pubkey
+        WriteBorshU64(buf, rewardTimelockDelta);
+        WriteBorshVec(buf, userData);
+        WriteBorshVec(buf, solverData);
+        return buf.ToArray();
+    }
+
+    /// <summary>
+    /// Builds instruction data for solver_lock_sol:
+    /// disc(8) + hashlock(32) + index(u64) + amount(u64) + reward(u64) + timelockDelta(u64)
+    /// + rewardTimelockDelta(u64) + sender(Pubkey) + recipient(Pubkey) + rewardRecipient(Pubkey)
+    /// + srcChain(String) + dstChain(String) + dstAddress(String) + dstAmount(u64)
+    /// + dstToken(String) + data(Vec&lt;u8&gt;)
     /// </summary>
-    public static byte[] BuildLockInstructionData(
-        byte[] hashlock, ulong timelock, ulong amount,
-        string dstChain, string dstAddress, string dstAsset, string srcAsset, string srcReceiver)
+    public static byte[] BuildSolverLockSolInstructionData(
+        byte[] hashlock,
+        ulong index,
+        ulong amount,
+        ulong reward,
+        ulong timelockDelta,
+        ulong rewardTimelockDelta,
+        string sender,
+        string recipient,
+        string rewardRecipient,
+        string srcChain,
+        string dstChain,
+        string dstAddress,
+        ulong dstAmount,
+        string dstToken,
+        byte[] data)
     {
-        var buf = new List<byte>(256);
-        buf.AddRange(LockDiscriminator);
-        WriteBorshBytes32(buf, hashlock);   // Id = hashlock for lock()
-        WriteBorshBytes32(buf, hashlock);   // hashlock
-        WriteBorshU64(buf, timelock);
+        var buf = new List<byte>(512);
+        buf.AddRange(SolverLockSolDiscriminator);
+        WriteBorshBytes32(buf, hashlock);
+        WriteBorshU64(buf, index);
         WriteBorshU64(buf, amount);
+        WriteBorshU64(buf, reward);
+        WriteBorshU64(buf, timelockDelta);
+        WriteBorshU64(buf, rewardTimelockDelta);
+        WriteBorshPubkey(buf, sender);
+        WriteBorshPubkey(buf, recipient);
+        WriteBorshPubkey(buf, rewardRecipient); // Pubkey for solver lock
+        WriteBorshString(buf, srcChain);
         WriteBorshString(buf, dstChain);
         WriteBorshString(buf, dstAddress);
-        WriteBorshString(buf, dstAsset);
-        WriteBorshString(buf, srcAsset);
-        WriteBorshPubkey(buf, srcReceiver);
+        WriteBorshU64(buf, dstAmount);
+        WriteBorshString(buf, dstToken);
+        WriteBorshVec(buf, data);
         return buf.ToArray();
     }
 
     /// <summary>
-    /// Builds instruction data for redeem(): discriminator + Id[32] + secret[32]
+    /// Builds instruction data for redeem_user_sol: disc(8) + hashlock(32) + secret(32)
     /// </summary>
-    public static byte[] BuildRedeemInstructionData(byte[] id, byte[] secret)
+    public static byte[] BuildRedeemUserSolInstructionData(byte[] hashlock, byte[] secret)
     {
         var buf = new List<byte>(72);
-        buf.AddRange(RedeemDiscriminator);
-        WriteBorshBytes32(buf, id);
+        buf.AddRange(RedeemUserSolDiscriminator);
+        WriteBorshBytes32(buf, hashlock);
+        WriteBorshBytes32(buf, secret);
+        return buf.ToArray();
+    }
+
+    /// <summary>
+    /// Builds instruction data for redeem_solver_sol: disc(8) + hashlock(32) + index(u64) + secret(32)
+    /// </summary>
+    public static byte[] BuildRedeemSolverSolInstructionData(byte[] hashlock, ulong index, byte[] secret)
+    {
+        var buf = new List<byte>(80);
+        buf.AddRange(RedeemSolverSolDiscriminator);
+        WriteBorshBytes32(buf, hashlock);
+        WriteBorshU64(buf, index);
         WriteBorshBytes32(buf, secret);
         return buf.ToArray();
     }
 
     /// <summary>
-    /// Builds instruction data for refund(): discriminator + Id[32]
+    /// Builds instruction data for refund_user_sol: disc(8) + hashlock(32)
     /// </summary>
-    public static byte[] BuildRefundInstructionData(byte[] id)
+    public static byte[] BuildRefundUserSolInstructionData(byte[] hashlock)
     {
         var buf = new List<byte>(40);
-        buf.AddRange(RefundDiscriminator);
-        WriteBorshBytes32(buf, id);
+        buf.AddRange(RefundUserSolDiscriminator);
+        WriteBorshBytes32(buf, hashlock);
+        return buf.ToArray();
+    }
+
+    /// <summary>
+    /// Builds instruction data for refund_solver_sol: disc(8) + hashlock(32) + index(u64)
+    /// </summary>
+    public static byte[] BuildRefundSolverSolInstructionData(byte[] hashlock, ulong index)
+    {
+        var buf = new List<byte>(48);
+        buf.AddRange(RefundSolverSolDiscriminator);
+        WriteBorshBytes32(buf, hashlock);
+        WriteBorshU64(buf, index);
         return buf.ToArray();
     }
 
@@ -235,6 +606,16 @@ private static string ReadBorshString(byte[] data, ref int offset)
         return str;
     }
 
+    private static byte[] ReadBorshVec(byte[] data, ref int offset)
+    {
+        var length = BitConverter.ToInt32(data, offset);
+        offset += 4;
+        var result = new byte[length];
+        Array.Copy(data, offset, result, 0, length);
+        offset += length;
+        return result;
+    }
+
     private static byte[] ReadBytes(byte[] data, ref int offset, int count)
     {
         var result = new byte[count];
diff --git a/csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs b/csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs
index b6d8b491..93700548 100644
--- a/csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs
+++ b/csharp/src/Workflow.Solana/Helpers/SolanaHelper.cs
@@ -19,7 +19,7 @@ public static class SolanaHelper
     /// <summary>
     /// Train HTLC program on Solana devnet.
     /// </summary>
-    public const string HTLCProgramId = "7ZT5gs8CG7BAv34bLYSke31DJeg5RRUa4G7p9GNcbPE";
+    public const string HTLCProgramId = "6zasug6x5AY93zNVjPZPGoqQfdTBd3C1w6CU9NDKtNH8";
 
     /// <summary>
     /// Null address convention (EVM-style) — also treated as native SOL.
@@ -53,6 +53,23 @@ public static bool IsValidSolanaAddress(string address)
         }
     }
 
+    /// <summary>
+    /// Creates a RequestHeapFrame instruction (discriminant 0x01 + 4-byte LE u32).
+    /// Requests a larger heap for the transaction (default 32KB, max 256KB).
+    /// </summary>
+    public static TransactionInstruction RequestHeapFrame(uint bytes = 256 * 1024)
+    {
+        var data = new byte[5];
+        data[0] = 0x01; // RequestHeapFrame discriminant
+        BitConverter.TryWriteBytes(data.AsSpan(1), bytes); // LE u32
+        return new TransactionInstruction
+        {
+            ProgramId = new PublicKey(ComputeBudgetProgramId).KeyBytes,
+            Keys = [],
+            Data = data
+        };
+    }
+
     /// <summary>
     /// Creates a SetComputeUnitLimit instruction (discriminant 0x02 + 4-byte LE u32).
     /// </summary>
diff --git a/csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs b/csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs
index 86b068b6..2796957e 100644
--- a/csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs
+++ b/csharp/src/Workflow.Solana/Models/SolanaHTLCModels.cs
@@ -4,27 +4,67 @@ namespace Train.Solver.Workflow.Solana.Models;
 
 /// <summary>
 /// Parsed HTLC PDA account data (Borsh-decoded after 8-byte Anchor discriminator).
-/// Maps to the Rust HTLC struct in the native_htlc program.
+/// Used for both UserLock and SolverLock accounts — we extract the common fields
+/// needed for redeem/refund account metas.
 /// </summary>
 public record SolanaHTLCAccount
 {
-    public string DstAddress { get; init; } = string.Empty;
-    public string DstChain { get; init; } = string.Empty;
-    public string DstAsset { get; init; } = string.Empty;
-    public string SrcAsset { get; init; } = string.Empty;
-    public string Sender { get; init; } = string.Empty;
-    public string SrcReceiver { get; init; } = string.Empty;
-    public string Hashlock { get; init; } = string.Empty;
     public string Secret { get; init; } = string.Empty;
     public ulong Amount { get; init; }
-    public ulong Reward { get; init; }
+    public string Sender { get; init; } = string.Empty;
     public long Timelock { get; init; }
-    public long RewardTimelock { get; init; }
 
     /// <summary>
-    /// 1 = active, 2 = refunded, 3 = redeemed
+    /// 0 = committed, 1 = locked, 2 = refunded, 3 = redeemed
     /// </summary>
-    public byte Claimed { get; init; }
+    public byte Status { get; init; }
+
+    public string SrcReceiver { get; init; } = string.Empty;
+}
+
+/// <summary>
+/// Parsed user_lock_sol instruction data for event detection.
+/// </summary>
+public record SolanaUserLockInstructionArgs
+{
+    public string Hashlock { get; init; } = string.Empty;
+    public ulong Amount { get; init; }
+    public ulong TimelockDelta { get; init; }
+    public ulong QuoteExpiry { get; init; }
+    public string Sender { get; init; } = string.Empty;
+    public string SrcReceiver { get; init; } = string.Empty;
+    public string SrcChain { get; init; } = string.Empty;
+    public string DstChain { get; init; } = string.Empty;
+    public string DstAddress { get; init; } = string.Empty;
+    public ulong DstAmount { get; init; }
+    public string DstToken { get; init; } = string.Empty;
+    public ulong RewardAmount { get; init; }
+    public string RewardToken { get; init; } = string.Empty;
+    public string RewardRecipient { get; init; } = string.Empty;
+    public ulong RewardTimelockDelta { get; init; }
+    public byte[]? UserData { get; init; }
+    public byte[]? SolverData { get; init; }
+}
+
+/// <summary>
+/// Parsed solver_lock_sol instruction data for event detection.
+/// </summary>
+public record SolanaSolverLockInstructionArgs
+{
+    public string Hashlock { get; init; } = string.Empty;
+    public ulong Index { get; init; }
+    public ulong Amount { get; init; }
+    public ulong Reward { get; init; }
+    public ulong TimelockDelta { get; init; }
+    public ulong RewardTimelockDelta { get; init; }
+    public string Sender { get; init; } = string.Empty;
+    public string SrcReceiver { get; init; } = string.Empty;
+    public string RewardRecipient { get; init; } = string.Empty;
+    public string SrcChain { get; init; } = string.Empty;
+    public string DstChain { get; init; } = string.Empty;
+    public string DstAddress { get; init; } = string.Empty;
+    public ulong DstAmount { get; init; }
+    public string DstToken { get; init; } = string.Empty;
 }
 
 #endregion
@@ -47,7 +87,7 @@ public record SolanaGetHTLCEventsRequest
     public string? LastSignature { get; init; }
 
     /// <summary>
-    /// Solver wallet addresses — used to distinguish user vs solver events for redeem/refund.
+    /// Solver wallet addresses — used to determine sender from PDA account for lock events.
     /// </summary>
     public List<string> SolverWalletAddresses { get; init; } = [];
 }
@@ -81,7 +121,7 @@ public record SolanaHTLCEventResult
 #region Event Models
 
 /// <summary>
-/// Detected HTLC lock event (from lock() or add_lock()/add_lock_sig() instructions).
+/// Detected HTLC lock event (from user_lock_sol or solver_lock_sol instructions).
 /// </summary>
 public record SolanaHTLCLockedEvent
 {
@@ -91,22 +131,30 @@ public record SolanaHTLCLockedEvent
     public required string Sender { get; init; }
     public required string SrcReceiver { get; init; }
     public required ulong Amount { get; init; }
-    public required ulong Reward { get; init; }
     public required long Timelock { get; init; }
-    public required long RewardTimelock { get; init; }
     public required string DstAddress { get; init; }
     public required string DstChain { get; init; }
     public required string DstAsset { get; init; }
     public required string SrcAsset { get; init; }
 
+    public ulong DstAmount { get; init; }
+    public string SrcChain { get; init; } = string.Empty;
+    public ulong TimelockDelta { get; init; }
+    public ulong QuoteExpiry { get; init; }
+    public ulong RewardAmount { get; init; }
+    public string RewardToken { get; init; } = string.Empty;
+    public string RewardRecipient { get; init; } = string.Empty;
+    public ulong RewardTimelockDelta { get; init; }
+    public string? SolverData { get; init; }
+
     /// <summary>
-    /// True if this is a user lock (add_lock/add_lock_sig), false if solver lock (lock).
+    /// True if this is a user lock (user_lock_sol), false if solver lock (solver_lock_sol).
     /// </summary>
     public required bool IsUserLock { get; init; }
 }
 
 /// <summary>
-/// Detected HTLC redeem event (from redeem() instruction).
+/// Detected HTLC redeem event (from redeem_user_sol or redeem_solver_sol instruction).
 /// </summary>
 public record SolanaHTLCRedeemedEvent
 {
@@ -117,13 +165,13 @@ public record SolanaHTLCRedeemedEvent
     public required string RedeemAddress { get; init; }
 
     /// <summary>
-    /// True if the solver's lock was redeemed (HTLC.sender is solver), false if user's lock.
+    /// True if the solver's lock was redeemed (redeem_solver_sol), false if user's lock (redeem_user_sol).
     /// </summary>
     public required bool IsSolverLock { get; init; }
 }
 
 /// <summary>
-/// Detected HTLC refund event (from refund() instruction).
+/// Detected HTLC refund event (from refund_user_sol or refund_solver_sol instruction).
 /// </summary>
 public record SolanaHTLCRefundedEvent
 {
@@ -132,7 +180,7 @@ public record SolanaHTLCRefundedEvent
     public required string Hashlock { get; init; }
 
     /// <summary>
-    /// True if the solver's lock was refunded (HTLC.sender is solver), false if user's lock.
+    /// True if the solver's lock was refunded (refund_solver_sol), false if user's lock (refund_user_sol).
     /// </summary>
     public required bool IsSolverLock { get; init; }
 }
diff --git a/csharp/src/Workflow.Solana/Models/SolanaModels.cs b/csharp/src/Workflow.Solana/Models/SolanaModels.cs
index 62dcc2ca..baee3995 100644
--- a/csharp/src/Workflow.Solana/Models/SolanaModels.cs
+++ b/csharp/src/Workflow.Solana/Models/SolanaModels.cs
@@ -191,6 +191,74 @@ public record SolanaBuildHTLCLockRequest
     public required string RecentBlockhash { get; init; }
     public ulong PriorityFeeMicroLamports { get; init; }
     public uint ComputeUnitLimit { get; init; } = 400_000;
+
+    /// <summary>
+    /// True for solver_lock_sol, false for user_lock_sol.
+    /// </summary>
+    public bool IsSolverLock { get; init; }
+
+    /// <summary>
+    /// Source chain identifier (e.g., "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1").
+    /// </summary>
+    public string SrcChain { get; init; } = string.Empty;
+
+    /// <summary>
+    /// Amount on destination chain.
+    /// </summary>
+    public ulong DstAmount { get; init; }
+
+    /// <summary>
+    /// Reward timelock delta in seconds.
+    /// </summary>
+    public ulong RewardTimelockDelta { get; init; }
+
+    /// <summary>
+    /// Address to receive the reward. Defaults to sender if empty.
+    /// For user_lock_sol: String type (can be any address).
+    /// For solver_lock_sol: Pubkey type (must be valid Solana address).
+    /// </summary>
+    public string RewardRecipient { get; init; } = string.Empty;
+
+    /// <summary>
+    /// Quote expiry timestamp. Only used for user_lock_sol.
+    /// </summary>
+    public ulong QuoteExpiry { get; init; }
+
+    /// <summary>
+    /// Reward amount in lamports. Only used for user_lock_sol.
+    /// For solver_lock_sol, the reward is passed directly.
+    /// </summary>
+    public ulong RewardAmount { get; init; }
+
+    /// <summary>
+    /// Token identifier for the reward (e.g., "SOL"). Only used for user_lock_sol.
+    /// </summary>
+    public string RewardToken { get; init; } = string.Empty;
+
+    /// <summary>
+    /// User data (arbitrary bytes). Only used for user_lock_sol.
+    /// </summary>
+    public byte[] UserData { get; init; } = [];
+
+    /// <summary>
+    /// Solver data (arbitrary bytes). Only used for user_lock_sol.
+    /// </summary>
+    public byte[] SolverData { get; init; } = [];
+
+    /// <summary>
+    /// Solver lock index. Only used for solver_lock_sol.
+    /// </summary>
+    public ulong Index { get; init; }
+
+    /// <summary>
+    /// Reward amount in lamports for solver_lock_sol.
+    /// </summary>
+    public ulong Reward { get; init; }
+
+    /// <summary>
+    /// Data bytes for solver_lock_sol.
+    /// </summary>
+    public byte[] Data { get; init; } = [];
 }
 
 public record SolanaBuildHTLCRedeemRequest
@@ -204,6 +272,21 @@ public record SolanaBuildHTLCRedeemRequest
     public required string RecentBlockhash { get; init; }
     public ulong PriorityFeeMicroLamports { get; init; }
     public uint ComputeUnitLimit { get; init; } = 400_000;
+
+    /// <summary>
+    /// True for redeem_user_sol (solver redeems user's lock), false for redeem_solver_sol (user redeems solver's lock).
+    /// </summary>
+    public bool IsRedeemingUserLock { get; init; }
+
+    /// <summary>
+    /// Solver lock index. Only needed for redeem_solver_sol.
+    /// </summary>
+    public ulong Index { get; init; }
+
+    /// <summary>
+    /// Reward recipient address. Only needed for redeem_solver_sol account metas.
+    /// </summary>
+    public string? RewardRecipientAddress { get; init; }
 }
 
 public record SolanaBuildHTLCRefundRequest
@@ -215,12 +298,33 @@ public record SolanaBuildHTLCRefundRequest
     public required string RecentBlockhash { get; init; }
     public ulong PriorityFeeMicroLamports { get; init; }
     public uint ComputeUnitLimit { get; init; } = 400_000;
+
+    /// <summary>
+    /// True for refund_solver_sol (solver refunds own lock), false for refund_user_sol (user refunds own lock).
+    /// </summary>
+    public bool IsRefundingSolverLock { get; init; }
+
+    /// <summary>
+    /// Solver lock index. Only needed for refund_solver_sol.
+    /// </summary>
+    public ulong Index { get; init; }
 }
 
 public record SolanaGetHTLCAccountRequest
 {
     public required string NodeUrl { get; init; }
-    public required byte[] Id { get; init; }
+    public required byte[] Hashlock { get; init; }
+
+    /// <summary>
+    /// True to derive UserLock PDA (seeds: ["user_lock", hashlock]),
+    /// false to derive SolverLock PDA (seeds: ["solver_lock", hashlock, index]).
+    /// </summary>
+    public bool IsUserLock { get; init; } = true;
+
+    /// <summary>
+    /// Solver lock index. Only used when IsUserLock = false.
+    /// </summary>
+    public ulong Index { get; init; }
 }
 
 #endregion
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs b/csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs
index 9b9fc2b4..f27be0f2 100644
--- a/csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaNetworkRuntime.cs
@@ -260,6 +260,24 @@ private async Task ReconcileListenersAsync()
             .ToHashSet();
         var activeListenerIds = _activeListeners.Select(x => x.ListenerId).ToHashSet();
 
+        // Cancel removed listeners
+        foreach (var listener in _activeListeners)
+        {
+            if (!desiredListenerIds.Contains(listener.ListenerId))
+            {
+                try
+                {
+                    var handle = GetExternalWorkflowHandle(listener.ListenerId);
+                    await handle.CancelAsync();
+                    Logger.LogInformation("Cancelled listener {ListenerId} on {Network}", listener.ListenerId, _networkSlug);
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogWarning(ex, "Failed to cancel listener {ListenerId}", listener.ListenerId);
+                }
+            }
+        }
+
         // Start only NEW listeners
         foreach (var config in enabledConfigs)
         {
@@ -382,6 +400,15 @@ public async Task<PrepareTransactionDto> BuildSolverLockTransactionAsync(HTLCLoc
         var nodeUrl = GetNodeUrl();
         var hashlock = ParseHexBytes32(request.Hashlock);
 
+        var blockhashInfo = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetLatestBlockhashAsync(nodeUrl),
+            DefaultLocalActivityOptions);
+
+        // RewardRecipient must be a Solana pubkey for solver_lock_sol (Pubkey type).
+        var solverLockRewardRecipient = SolanaHelper.IsValidSolanaAddress(request.RewardRecipient ?? "")
+            ? request.RewardRecipient!
+            : request.Receiver;
+
         var unsignedTxBase64 = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.BuildHTLCLockTransactionAsync(new SolanaBuildHTLCLockRequest
             {
@@ -395,16 +422,21 @@ public async Task<PrepareTransactionDto> BuildSolverLockTransactionAsync(HTLCLoc
                 DstAddress = request.DestinationAddress,
                 DstAsset = request.DstToken,
                 SrcAsset = request.TokenContract,
-                RecentBlockhash = string.Empty // placeholder — TP will set the real blockhash
+                RecentBlockhash = blockhashInfo.Blockhash,
+                IsSolverLock = true,
+                SrcChain = request.SrcChain,
+                DstAmount = (ulong)request.DstAmount,
+                RewardTimelockDelta = (ulong)request.RewardTimelock,
+                RewardRecipient = solverLockRewardRecipient,
+                Reward = (ulong)request.Reward,
+                Data = string.IsNullOrEmpty(request.Data) ? Array.Empty<byte>() : Convert.FromHexString(request.Data.TrimStart('0', 'x')),
             }),
             DefaultLocalActivityOptions);
 
-        var pdaAddress = SolanaAnchorHelper.DerivePDA(hashlock, SolanaHelper.HTLCProgramId) ?? string.Empty;
-
         return new PrepareTransactionDto
         {
             Data = unsignedTxBase64,
-            ToAddress = pdaAddress,
+            ToAddress = SolanaAnchorHelper.DeriveSolverCountPDA(hashlock, SolanaHelper.HTLCProgramId)?.Key ?? string.Empty,
             ContractAddress = _network!.Type.NativeTokenAddress,
             Type = TransactionType.HTLCLock,
             Amount = request.Amount
@@ -418,6 +450,13 @@ public async Task<PrepareTransactionDto> BuildUserLockTransactionAsync(HTLCLockT
         var nodeUrl = GetNodeUrl();
         var hashlock = ParseHexBytes32(request.Hashlock);
 
+        var blockhashInfo = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetLatestBlockhashAsync(nodeUrl),
+            DefaultLocalActivityOptions);
+
+        // RewardRecipient for user_lock_sol is a String type (can be any format).
+        var userLockRewardRecipient = request.RewardRecipient ?? "";
+
         var unsignedTxBase64 = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.BuildHTLCLockTransactionAsync(new SolanaBuildHTLCLockRequest
             {
@@ -431,11 +470,21 @@ public async Task<PrepareTransactionDto> BuildUserLockTransactionAsync(HTLCLockT
                 DstAddress = request.DestinationAddress,
                 DstAsset = request.DstToken,
                 SrcAsset = request.TokenContract,
-                RecentBlockhash = string.Empty
+                RecentBlockhash = blockhashInfo.Blockhash,
+                IsSolverLock = false,
+                SrcChain = request.SrcChain,
+                DstAmount = (ulong)request.DstAmount,
+                RewardTimelockDelta = (ulong)request.RewardTimelock,
+                RewardRecipient = userLockRewardRecipient,
+                QuoteExpiry = (ulong)request.QuoteExpiry,
+                RewardAmount = (ulong)request.Reward,
+                RewardToken = request.RewardToken ?? "",
+                UserData = string.IsNullOrEmpty(request.Data) ? Array.Empty<byte>() : Convert.FromHexString(request.Data.TrimStart('0', 'x')),
+                SolverData = string.IsNullOrEmpty(request.SolverData) ? Array.Empty<byte>() : Convert.FromHexString(request.SolverData.TrimStart('0', 'x')),
             }),
             DefaultLocalActivityOptions);
 
-        var pdaAddress = SolanaAnchorHelper.DerivePDA(hashlock, SolanaHelper.HTLCProgramId) ?? string.Empty;
+        var pdaAddress = SolanaAnchorHelper.DeriveUserLockPDA(hashlock, SolanaHelper.HTLCProgramId)?.Key ?? string.Empty;
 
         return new PrepareTransactionDto
         {
@@ -456,18 +505,23 @@ public async Task<PrepareTransactionDto> BuildSolverRedeemTransactionAsync(HTLCR
         var secret = ParseHexBytes32(request.Secret);
         var signerAddress = GetFirstWalletAddress();
 
-        // Read PDA to get sender and src_receiver
+        // Read user lock PDA to get sender and src_receiver for account metas
         var htlcAccount = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
             {
                 NodeUrl = nodeUrl,
-                Id = id
+                Hashlock = id,
+                IsUserLock = true, // solver redeems user's lock
             }),
             DefaultLocalActivityOptions);
 
         if (htlcAccount == null)
             throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
 
+        var blockhashInfo = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetLatestBlockhashAsync(nodeUrl),
+            DefaultLocalActivityOptions);
+
         var unsignedTxBase64 = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.BuildHTLCRedeemTransactionAsync(new SolanaBuildHTLCRedeemRequest
             {
@@ -477,14 +531,15 @@ public async Task<PrepareTransactionDto> BuildSolverRedeemTransactionAsync(HTLCR
                 SrcReceiverAddress = htlcAccount.SrcReceiver,
                 Id = id,
                 Secret = secret,
-                RecentBlockhash = string.Empty
+                RecentBlockhash = blockhashInfo.Blockhash,
+                IsRedeemingUserLock = true, // solver redeems user's lock → redeem_user_sol
             }),
             DefaultLocalActivityOptions);
 
         return new PrepareTransactionDto
         {
             Data = unsignedTxBase64,
-            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ToAddress = SolanaAnchorHelper.DeriveUserLockPDA(id, SolanaHelper.HTLCProgramId)?.Key ?? string.Empty,
             ContractAddress = request.ContractAddress,
             Type = TransactionType.HTLCRedeem,
             Amount = 0
@@ -499,17 +554,25 @@ public async Task<PrepareTransactionDto> BuildUserRedeemTransactionAsync(HTLCRed
         var id = ParseHexBytes32(request.Hashlock);
         var secret = ParseHexBytes32(request.Secret);
         var signerAddress = GetFirstWalletAddress();
+        var index = (ulong)request.Index;
 
+        // Read solver lock PDA to get sender and src_receiver for account metas
         var htlcAccount = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
             {
                 NodeUrl = nodeUrl,
-                Id = id
+                Hashlock = id,
+                IsUserLock = false, // user redeems solver's lock
+                Index = index,
             }),
             DefaultLocalActivityOptions);
 
         if (htlcAccount == null)
-            throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
+            throw new Exception($"HTLC account not found for hashlock {request.Hashlock} index {index}");
+
+        var blockhashInfo = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetLatestBlockhashAsync(nodeUrl),
+            DefaultLocalActivityOptions);
 
         var unsignedTxBase64 = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.BuildHTLCRedeemTransactionAsync(new SolanaBuildHTLCRedeemRequest
@@ -520,14 +583,17 @@ public async Task<PrepareTransactionDto> BuildUserRedeemTransactionAsync(HTLCRed
                 SrcReceiverAddress = htlcAccount.SrcReceiver,
                 Id = id,
                 Secret = secret,
-                RecentBlockhash = string.Empty
+                RecentBlockhash = blockhashInfo.Blockhash,
+                IsRedeemingUserLock = false, // user redeems solver's lock → redeem_solver_sol
+                Index = index,
+                RewardRecipientAddress = signerAddress, // solver wallet is typically the reward recipient
             }),
             DefaultLocalActivityOptions);
 
         return new PrepareTransactionDto
         {
             Data = unsignedTxBase64,
-            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ToAddress = SolanaAnchorHelper.DeriveSolverLockPDA(id, index, SolanaHelper.HTLCProgramId)?.Key ?? string.Empty,
             ContractAddress = request.ContractAddress,
             Type = TransactionType.UserHTLCRedeem,
             Amount = 0
@@ -541,17 +607,25 @@ public async Task<PrepareTransactionDto> BuildSolverRefundTransactionAsync(HTLCR
         var nodeUrl = GetNodeUrl();
         var id = ParseHexBytes32(request.Hashlock);
         var signerAddress = GetFirstWalletAddress();
+        var index = (ulong)request.Index;
 
+        // Read solver lock PDA to get sender for account metas
         var htlcAccount = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
             {
                 NodeUrl = nodeUrl,
-                Id = id
+                Hashlock = id,
+                IsUserLock = false, // solver refunds own lock (solver lock PDA)
+                Index = index,
             }),
             DefaultLocalActivityOptions);
 
         if (htlcAccount == null)
-            throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
+            throw new Exception($"HTLC account not found for hashlock {request.Hashlock} index {index}");
+
+        var blockhashInfo = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetLatestBlockhashAsync(nodeUrl),
+            DefaultLocalActivityOptions);
 
         var unsignedTxBase64 = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.BuildHTLCRefundTransactionAsync(new SolanaBuildHTLCRefundRequest
@@ -560,14 +634,16 @@ public async Task<PrepareTransactionDto> BuildSolverRefundTransactionAsync(HTLCR
                 SignerAddress = signerAddress,
                 SenderAddress = htlcAccount.Sender,
                 Id = id,
-                RecentBlockhash = string.Empty
+                RecentBlockhash = blockhashInfo.Blockhash,
+                IsRefundingSolverLock = true, // solver refunds own lock → refund_solver_sol
+                Index = index,
             }),
             DefaultLocalActivityOptions);
 
         return new PrepareTransactionDto
         {
             Data = unsignedTxBase64,
-            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ToAddress = SolanaAnchorHelper.DeriveSolverLockPDA(id, index, SolanaHelper.HTLCProgramId)?.Key ?? string.Empty,
             ContractAddress = request.ContractAddress,
             Type = TransactionType.HTLCRefund,
             Amount = 0
@@ -582,17 +658,23 @@ public async Task<PrepareTransactionDto> BuildUserRefundTransactionAsync(HTLCRef
         var id = ParseHexBytes32(request.Hashlock);
         var signerAddress = GetFirstWalletAddress();
 
+        // Read user lock PDA to get sender for account metas
         var htlcAccount = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
             {
                 NodeUrl = nodeUrl,
-                Id = id
+                Hashlock = id,
+                IsUserLock = true, // user refunds own lock (user lock PDA)
             }),
             DefaultLocalActivityOptions);
 
         if (htlcAccount == null)
             throw new Exception($"HTLC account not found for hashlock {request.Hashlock}");
 
+        var blockhashInfo = await ExecuteLocalActivityAsync(
+            (ISolanaBlockchainActivities x) => x.GetLatestBlockhashAsync(nodeUrl),
+            DefaultLocalActivityOptions);
+
         var unsignedTxBase64 = await ExecuteLocalActivityAsync(
             (ISolanaBlockchainActivities x) => x.BuildHTLCRefundTransactionAsync(new SolanaBuildHTLCRefundRequest
             {
@@ -600,14 +682,15 @@ public async Task<PrepareTransactionDto> BuildUserRefundTransactionAsync(HTLCRef
                 SignerAddress = signerAddress,
                 SenderAddress = htlcAccount.Sender,
                 Id = id,
-                RecentBlockhash = string.Empty
+                RecentBlockhash = blockhashInfo.Blockhash,
+                IsRefundingSolverLock = false, // user refunds own lock → refund_user_sol
             }),
             DefaultLocalActivityOptions);
 
         return new PrepareTransactionDto
         {
             Data = unsignedTxBase64,
-            ToAddress = SolanaAnchorHelper.DerivePDA(id, SolanaHelper.HTLCProgramId) ?? string.Empty,
+            ToAddress = SolanaAnchorHelper.DeriveUserLockPDA(id, SolanaHelper.HTLCProgramId)?.Key ?? string.Empty,
             ContractAddress = request.ContractAddress,
             Type = TransactionType.UserHTLCRefund,
             Amount = 0
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs b/csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs
index ecb4d955..0dc21a64 100644
--- a/csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaRPCEventListener.cs
@@ -50,8 +50,7 @@ public async Task RunAsync(EventListenerArgs args)
         var waitInterval = listenerConfig?.GetIntSetting("PollingIntervalSeconds", 5) ?? 5;
 
         // Get first HTTP node URL
-        var nodeUrl = network.Nodes?
-            .FirstOrDefault(n => !n.Url.StartsWith("ws", StringComparison.OrdinalIgnoreCase))?.Url;
+        var nodeUrl = network.HttpNodes?.FirstOrDefault()?.Url;
 
         if (string.IsNullOrEmpty(nodeUrl))
         {
@@ -138,15 +137,22 @@ private async Task PollAndProcessEventsAsync(string networkSlug, string nodeUrl,
                 TransactionId = locked.TxSignature,
                 HashLock = locked.Hashlock,
                 TimeLock = locked.Timelock,
+                TimelockDelta = (long)locked.TimelockDelta,
+                QuoteExpiry = (long)locked.QuoteExpiry,
                 Sender = locked.Sender,
                 SrcReceiver = locked.SrcReceiver,
                 Token = locked.SrcAsset,
                 Amount = locked.Amount.ToString(),
-                Reward = locked.Reward.ToString(),
-                RewardTimelock = locked.RewardTimelock,
+                Reward = locked.RewardAmount.ToString(),
+                RewardTimelock = (long)locked.RewardTimelockDelta,
+                RewardToken = locked.RewardToken,
+                RewardRecipient = locked.RewardRecipient,
+                SrcChain = locked.SrcChain,
                 DstChain = locked.DstChain,
                 DstAddress = locked.DstAddress,
+                DstAmount = locked.DstAmount.ToString(),
                 DstToken = locked.DstAsset,
+                SolverData = locked.SolverData,
                 BlockNumber = locked.Slot,
             }, locked.Hashlock);
         }
diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs b/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
index 4b146fd3..2e42ad95 100644
--- a/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
@@ -133,7 +133,7 @@ public async Task RunAsync(SolanaTransactionProcessorArgs args)
                     : $"{_network.Slug} | q={_queuedRequests.Count} | idle | iter={_iteration} | ok={_totalConfirmed} fail={_totalFailed} retry={_totalRetries}";
 
                 await WaitConditionAsync(
-                    () => _queuedRequests.Count > 0 || _pendingTransactions.Count > 0,
+                    () => _queuedRequests.Count > 0 || _pendingTransactions.Count > 0 || _inFlightTransactions.Count > 0,
                     pollingInterval);
             }
             catch (Exception ex) when (ex is not OperationCanceledException)
@@ -480,11 +480,27 @@ await SignalFailureAsync(pending.Callback, pending.CorrelationId,
                 }
                 else if (publishResult.Outcome == SolanaPublishOutcome.DuplicateTransaction)
                 {
-                    RecordEvent($"DUPLICATE {pending.Type} | corr={pending.CorrelationId} | {publishResult.ErrorMessage}");
-                    await SignalFailureAsync(pending.Callback, pending.CorrelationId, publishResult.ErrorMessage ?? "Duplicate transaction");
+                    // Duplicate means a previous publish attempt succeeded — move to in-flight to monitor confirmation
+                    RecordEvent($"DUPLICATE {pending.Type} | corr={pending.CorrelationId} | treating as published, monitoring for confirmation");
+                    _inFlightTransactions.Add(new SolanaInFlightTransaction
+                    {
+                        CorrelationId = pending.CorrelationId,
+                        Callback = pending.Callback,
+                        Type = pending.Type,
+                        SenderAddress = pending.SenderAddress,
+                        TokenContract = pending.TokenContract,
+                        LastValidBlockHeight = pending.LastValidBlockHeight,
+                        PriorityFeeMicroLamports = pending.PriorityFeeMicroLamports,
+                        RetryCount = pending.RetryCount,
+                        TransferRequest = pending.TransferRequest,
+                        LockRequest = pending.LockRequest,
+                        RedeemRequest = pending.RedeemRequest,
+                        RefundRequest = pending.RefundRequest,
+                        TxSignature = publishResult.TxSignature ?? $"dup-{pending.CorrelationId}",
+                        PublishedAt = Temporalio.Workflows.Workflow.UtcNow
+                    });
                     _pendingTransactions.Remove(pending);
-                    TrackCorrelationId(pending.CorrelationId);
-                    _totalFailed++;
+                    _totalPublished++;
                 }
                 else
                 {
@@ -831,7 +847,16 @@ private async Task<string> BuildUnsignedTransactionForQueuedAsync(
                         DstAsset = queued.LockRequest.DestinationToken,
                         SrcAsset = queued.LockRequest.TokenContract,
                         RecentBlockhash = blockhash,
-                        PriorityFeeMicroLamports = priorityFee
+                        PriorityFeeMicroLamports = priorityFee,
+                        IsSolverLock = true, // TP always builds solver locks
+                        SrcChain = queued.LockRequest.SrcChain,
+                        DstAmount = (ulong)queued.LockRequest.DestinationAmount,
+                        RewardTimelockDelta = (ulong)queued.LockRequest.RewardTimelock,
+                        RewardRecipient = queued.LockRequest.RewardRecipient ?? queued.LockRequest.Sender,
+                        Reward = (ulong)queued.LockRequest.Reward,
+                        Data = string.IsNullOrEmpty(queued.LockRequest.Data)
+                            ? Array.Empty<byte>()
+                            : Convert.FromHexString(queued.LockRequest.Data.TrimStart('0', 'x')),
                     }),
                     GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
             }
@@ -844,12 +869,13 @@ private async Task<string> BuildUnsignedTransactionForQueuedAsync(
                 var id = ParseHashlock(queued.RedeemRequest.Hashlock);
                 var secret = ParseHashlock(queued.RedeemRequest.Secret);
 
-                // Read PDA account to get sender and src_receiver for account metas
+                // Read user lock PDA to get sender and src_receiver for account metas
                 var htlcAccount = await ExecuteLocalActivityAsync(
                     (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
                     {
                         NodeUrl = nodeUrl,
-                        Id = id
+                        Hashlock = id,
+                        IsUserLock = true, // TP redeems user's lock
                     }),
                     GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
 
@@ -866,7 +892,8 @@ private async Task<string> BuildUnsignedTransactionForQueuedAsync(
                         Id = id,
                         Secret = secret,
                         RecentBlockhash = blockhash,
-                        PriorityFeeMicroLamports = priorityFee
+                        PriorityFeeMicroLamports = priorityFee,
+                        IsRedeemingUserLock = true, // TP always redeems user's lock → redeem_user_sol
                     }),
                     GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
             }
@@ -878,13 +905,17 @@ private async Task<string> BuildUnsignedTransactionForQueuedAsync(
                     throw new Exception("RefundRequest is null for refund type");
 
                 var id = ParseHashlock(queued.RefundRequest.Hashlock);
+                var isSolverRefund = queued.Type == TransactionType.HTLCRefund;
+                var index = (ulong)queued.RefundRequest.Index;
 
-                // Read PDA account to get sender for account metas
+                // Read the correct PDA account to get sender for account metas
                 var htlcAccount = await ExecuteLocalActivityAsync(
                     (ISolanaBlockchainActivities x) => x.GetHTLCAccountDataAsync(new SolanaGetHTLCAccountRequest
                     {
                         NodeUrl = nodeUrl,
-                        Id = id
+                        Hashlock = id,
+                        IsUserLock = !isSolverRefund, // solver refund reads solver lock PDA, user refund reads user lock PDA
+                        Index = isSolverRefund ? index : 0,
                     }),
                     GetLocalActivityOptions(TimeSpan.FromSeconds(15), 3));
 
@@ -899,7 +930,9 @@ private async Task<string> BuildUnsignedTransactionForQueuedAsync(
                         SenderAddress = htlcAccount.Sender,
                         Id = id,
                         RecentBlockhash = blockhash,
-                        PriorityFeeMicroLamports = priorityFee
+                        PriorityFeeMicroLamports = priorityFee,
+                        IsRefundingSolverLock = isSolverRefund,
+                        Index = isSolverRefund ? index : 0,
                     }),
                     GetLocalActivityOptions(TimeSpan.FromSeconds(30), 3));
             }

From 9023d88783405c76c903e8a9293eae26e9cfb6eb Mon Sep 17 00:00:00 2001
From: erkostandyan <erik.kostandyan2003@gmail.com>
Date: Tue, 10 Mar 2026 13:50:28 +0400
Subject: [PATCH 4/5] fix hashlock type in solana.

---
 csharp/src/AppHost/appsettings.Development.json    |  5 +++++
 .../Extensions/TrainSolverBuilderExtensions.cs     |  2 ++
 .../Extensions/TrainSolverBuilderExtensions.cs     |  2 ++
 .../Extensions/TrainSolverBuilderExtensions.cs     |  2 ++
 treasury/src/kv/infisical.service.ts               | 14 ++++++++++++++
 treasury/src/main.ts                               |  2 +-
 6 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/csharp/src/AppHost/appsettings.Development.json b/csharp/src/AppHost/appsettings.Development.json
index 0c208ae9..0baf6c96 100644
--- a/csharp/src/AppHost/appsettings.Development.json
+++ b/csharp/src/AppHost/appsettings.Development.json
@@ -4,5 +4,10 @@
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
     }
+  },
+  "Parameters": {
+    "infisical-client-id": "fe6f6b34-16d3-44da-8d78-6fad178fceff",
+    "infisical-client-secret": "eca125c7ddec754459c9e40d1cad24c8a80b9942a22e7e516e738ce351315b47",
+    "infisical-project-id": "b2856518-0246-4d80-a19e-64afb46882d3"
   }
 }
diff --git a/csharp/src/Workflow.EVM/Extensions/TrainSolverBuilderExtensions.cs b/csharp/src/Workflow.EVM/Extensions/TrainSolverBuilderExtensions.cs
index 2131f893..78f655d8 100644
--- a/csharp/src/Workflow.EVM/Extensions/TrainSolverBuilderExtensions.cs
+++ b/csharp/src/Workflow.EVM/Extensions/TrainSolverBuilderExtensions.cs
@@ -24,6 +24,8 @@ public static TrainSolverBuilder WithEVMWorkflows(
             .ConfigureOptions(opts =>
             {
                 opts.WorkflowStackTrace = WorkflowStackTrace.Normal;
+                opts.BuildId = builder.Options.NetworkType;
+                opts.UseWorkerVersioning = false;
             })
             .AddWorkflow<NetworkRuntime>()
             .AddWorkflow<AddressGenerator>()
diff --git a/csharp/src/Workflow.Swap/Extensions/TrainSolverBuilderExtensions.cs b/csharp/src/Workflow.Swap/Extensions/TrainSolverBuilderExtensions.cs
index 9c8ea42c..cb15ff4f 100644
--- a/csharp/src/Workflow.Swap/Extensions/TrainSolverBuilderExtensions.cs
+++ b/csharp/src/Workflow.Swap/Extensions/TrainSolverBuilderExtensions.cs
@@ -29,6 +29,8 @@ public static TrainSolverBuilder WithCoreWorkflows(
             .ConfigureOptions(opts =>
             {
                 opts.WorkflowStackTrace = WorkflowStackTrace.Normal;
+                opts.BuildId = Constants.CoreTaskQueue;
+                opts.UseWorkerVersioning = false;
             })
             .AddTransientActivities<RouteActivities>()
             .AddTransientActivities<WalletActivities>()
diff --git a/csharp/src/Workflow.Tron/Extensions/TrainSolverBuilderExtensions.cs b/csharp/src/Workflow.Tron/Extensions/TrainSolverBuilderExtensions.cs
index 2d1850ff..cf9f0574 100644
--- a/csharp/src/Workflow.Tron/Extensions/TrainSolverBuilderExtensions.cs
+++ b/csharp/src/Workflow.Tron/Extensions/TrainSolverBuilderExtensions.cs
@@ -18,6 +18,8 @@ public static TrainSolverBuilder WithTronWorkflows(
             .ConfigureOptions(opts =>
             {
                 opts.WorkflowStackTrace = WorkflowStackTrace.Normal;
+                opts.BuildId = builder.Options.NetworkType;
+                opts.UseWorkerVersioning = false;
             })
             .AddWorkflow<TronNetworkRuntime>()
             .AddWorkflow<AddressGenerator>()
diff --git a/treasury/src/kv/infisical.service.ts b/treasury/src/kv/infisical.service.ts
index a86d1ca7..e7c3a856 100644
--- a/treasury/src/kv/infisical.service.ts
+++ b/treasury/src/kv/infisical.service.ts
@@ -70,7 +70,21 @@ export class PrivateKeyService {
         this.isAuthenticated = true;
     }
 
+    private async ensureFolder(address: string): Promise<void> {
+        try {
+            await this.client.folders().create({
+                name: address,
+                projectId: this.config.projectId,
+                environment: this.config.environment,
+                path: '/',
+            });
+        } catch {
+            // Folder already exists — ignore
+        }
+    }
+
     private async upsertSecret(address: string, key: string, value: string): Promise<void> {
+        await this.ensureFolder(address);
         const common = {
             secretValue: value,
             projectId: this.config.projectId,
diff --git a/treasury/src/main.ts b/treasury/src/main.ts
index 4a11e6a5..12740b4c 100644
--- a/treasury/src/main.ts
+++ b/treasury/src/main.ts
@@ -5,7 +5,7 @@ async function bootstrap() {
   const app = await NestFactory.create(AppModule);
 
   const port = process.env.PORT || 8080;
-  await app.listen(port);
+  await app.listen(port, '0.0.0.0');
 
   console.log(`Application is running on: ${await app.getUrl()}`);
 }

From 29c19dec80849fc0c1c33a7f8c2cbcc6c1e5618f Mon Sep 17 00:00:00 2001
From: erkostandyan <erik.kostandyan2003@gmail.com>
Date: Tue, 10 Mar 2026 13:50:41 +0400
Subject: [PATCH 5/5] .

---
 .../Workflows/SolanaTransactionProcessor.cs   |  27 +++-
 js/package-lock.json                          | 152 +++++++++++-------
 2 files changed, 123 insertions(+), 56 deletions(-)

diff --git a/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs b/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
index 2e42ad95..a53ed1b0 100644
--- a/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
+++ b/csharp/src/Workflow.Solana/Workflows/SolanaTransactionProcessor.cs
@@ -867,7 +867,7 @@ private async Task<string> BuildUnsignedTransactionForQueuedAsync(
                     throw new Exception("RedeemRequest is null for HTLCRedeem type");
 
                 var id = ParseHashlock(queued.RedeemRequest.Hashlock);
-                var secret = ParseHashlock(queued.RedeemRequest.Secret);
+                var secret = ParseSecret(queued.RedeemRequest.Secret);
 
                 // Read user lock PDA to get sender and src_receiver for account metas
                 var htlcAccount = await ExecuteLocalActivityAsync(
@@ -950,6 +950,31 @@ private static byte[] ParseHashlock(string hexString)
         return Convert.FromHexString(trimmed);
     }
 
+    /// <summary>
+    /// Parses a secret string (decimal BigInteger or hex) into 32 bytes big-endian.
+    /// The secret from OrderWorkflow is a decimal uint256 string, not hex.
+    /// </summary>
+    private static byte[] ParseSecret(string secret)
+    {
+        // If it looks like hex (starts with 0x or contains a-f), parse as hex
+        var trimmed = secret.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? secret[2..] : secret;
+        if (trimmed.Length == 64 && trimmed.All(c => "0123456789abcdefABCDEF".Contains(c)))
+            return Convert.FromHexString(trimmed);
+
+        // Otherwise parse as decimal BigInteger and convert to 32-byte big-endian
+        var bigInt = System.Numerics.BigInteger.Parse(secret);
+        var bytes = bigInt.ToByteArray(isUnsigned: true, isBigEndian: true);
+        if (bytes.Length > 32)
+            throw new ArgumentException($"Secret too large: {bytes.Length} bytes");
+        if (bytes.Length < 32)
+        {
+            var padded = new byte[32];
+            Array.Copy(bytes, 0, padded, 32 - bytes.Length, bytes.Length);
+            return padded;
+        }
+        return bytes;
+    }
+
     private static bool HasRetryableRequest(SolanaPendingTransaction pending) =>
         pending.TransferRequest != null || pending.LockRequest != null ||
         pending.RedeemRequest != null || pending.RefundRequest != null;
diff --git a/js/package-lock.json b/js/package-lock.json
index 1c0ae297..1e323be4 100644
--- a/js/package-lock.json
+++ b/js/package-lock.json
@@ -1507,7 +1507,6 @@
       "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@babel/generator": "^7.29.0",
@@ -6091,7 +6090,6 @@
       "resolved": "https://registry.npmjs.org/@nestjs/common/-/common-11.1.2.tgz",
       "integrity": "sha512-cHh4OPH44PjaHM93D1jgE1HO/B7XTZVRDxy/cPuGgyMEA4p2zXO+qqcOgTMC5FYcp7dX9jLeCjXAU0ToFAnODw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "file-type": "21.0.0",
         "iterare": "1.2.1",
@@ -6201,7 +6199,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
       "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
       "license": "Apache-2.0",
-      "peer": true,
       "engines": {
         "node": ">=8.0.0"
       }
@@ -6953,7 +6950,8 @@
       "optional": true,
       "os": [
         "android"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-android-arm64": {
       "version": "4.57.1",
@@ -6966,7 +6964,8 @@
       "optional": true,
       "os": [
         "android"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-darwin-arm64": {
       "version": "4.57.1",
@@ -6979,7 +6978,8 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-darwin-x64": {
       "version": "4.57.1",
@@ -6992,7 +6992,8 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-freebsd-arm64": {
       "version": "4.57.1",
@@ -7005,7 +7006,8 @@
       "optional": true,
       "os": [
         "freebsd"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-freebsd-x64": {
       "version": "4.57.1",
@@ -7018,7 +7020,8 @@
       "optional": true,
       "os": [
         "freebsd"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
       "version": "4.57.1",
@@ -7031,7 +7034,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-arm-musleabihf": {
       "version": "4.57.1",
@@ -7044,7 +7048,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-arm64-gnu": {
       "version": "4.57.1",
@@ -7057,7 +7062,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-arm64-musl": {
       "version": "4.57.1",
@@ -7070,7 +7076,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-loong64-gnu": {
       "version": "4.57.1",
@@ -7083,7 +7090,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-loong64-musl": {
       "version": "4.57.1",
@@ -7096,7 +7104,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-ppc64-gnu": {
       "version": "4.57.1",
@@ -7109,7 +7118,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-ppc64-musl": {
       "version": "4.57.1",
@@ -7122,7 +7132,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-riscv64-gnu": {
       "version": "4.57.1",
@@ -7135,7 +7146,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-riscv64-musl": {
       "version": "4.57.1",
@@ -7148,7 +7160,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-s390x-gnu": {
       "version": "4.57.1",
@@ -7161,7 +7174,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
       "version": "4.57.1",
@@ -7174,7 +7188,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-linux-x64-musl": {
       "version": "4.57.1",
@@ -7187,7 +7202,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-openbsd-x64": {
       "version": "4.57.1",
@@ -7200,7 +7216,8 @@
       "optional": true,
       "os": [
         "openbsd"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-openharmony-arm64": {
       "version": "4.57.1",
@@ -7213,7 +7230,8 @@
       "optional": true,
       "os": [
         "openharmony"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-win32-arm64-msvc": {
       "version": "4.57.1",
@@ -7226,7 +7244,8 @@
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-win32-ia32-msvc": {
       "version": "4.57.1",
@@ -7239,7 +7258,8 @@
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-win32-x64-gnu": {
       "version": "4.57.1",
@@ -7252,7 +7272,8 @@
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@rollup/rollup-win32-x64-msvc": {
       "version": "4.57.1",
@@ -7265,7 +7286,8 @@
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@scure/base": {
       "version": "2.0.0",
@@ -8143,7 +8165,6 @@
       "integrity": "sha512-iLmLTodbYxU39HhMPaMUooPwO/zqJWvsqkrXv1ZI38rMb048p6N7qtAtTp37sw9NzSrvH6oli8EdDygo09IZ/w==",
       "hasInstallScript": true,
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@swc/counter": "^0.1.3",
         "@swc/types": "^0.1.25"
@@ -8633,7 +8654,6 @@
       "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
       "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/ms": "*"
       }
@@ -8729,7 +8749,6 @@
       "resolved": "https://registry.npmjs.org/@types/node/-/node-25.3.0.tgz",
       "integrity": "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "undici-types": "~7.18.0"
       }
@@ -8833,6 +8852,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.0.9.tgz",
       "integrity": "sha512-5eCqRItYgIML7NNVgJj6TVCmdzE7ZVgJhruW0ziSQV4V7PvLkDL1bBkBdcTs/VuIz0IxPb5da1IDSqc1TR9eig==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vitest/spy": "3.0.9",
         "@vitest/utils": "3.0.9",
@@ -8848,6 +8868,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.0.9.tgz",
       "integrity": "sha512-ryERPIBOnvevAkTq+L1lD+DTFBRcjueL9lOUfXsLfwP92h4e+Heb+PjiqS3/OURWPtywfafK0kj++yDFjWUmrA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vitest/spy": "3.0.9",
         "estree-walker": "^3.0.3",
@@ -8874,6 +8895,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz",
       "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "tinyrainbow": "^2.0.0"
       },
@@ -8886,6 +8908,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.0.9.tgz",
       "integrity": "sha512-NX9oUXgF9HPfJSwl8tUZCMP1oGx2+Sf+ru6d05QjzQz4OwWg0psEzwY6VexP2tTHWdOkhKHUIZH+fS6nA7jfOw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vitest/utils": "3.0.9",
         "pathe": "^2.0.3"
@@ -8899,6 +8922,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.0.9.tgz",
       "integrity": "sha512-AiLUiuZ0FuA+/8i19mTYd+re5jqjEc2jZbgJ2up0VY0Ddyyxg/uUtBDpIFAy4uzKaQxOW8gMgBdAJJ2ydhu39A==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vitest/pretty-format": "3.0.9",
         "magic-string": "^0.30.17",
@@ -8913,6 +8937,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.0.9.tgz",
       "integrity": "sha512-OW9F8t2J3AwFEwENg3yMyKWweF7oRJlMyHOMIhO5F3n0+cgQAJZBjNgrF8dLwFTEXl5jUqBLXd9QyyKv8zEcmA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "tinyrainbow": "^2.0.0"
       },
@@ -8925,6 +8950,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.0.9.tgz",
       "integrity": "sha512-/CcK2UDl0aQ2wtkp3YVWldrpLRNCfVcIOFGlVGKO4R5eajsH393Z1yiXLVQ7vWsj26JOEjeZI0x5sm5P4OGUNQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "tinyspy": "^3.0.2"
       },
@@ -8937,6 +8963,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.0.9.tgz",
       "integrity": "sha512-ilHM5fHhZ89MCp5aAaM9uhfl1c2JdxVxl3McqsdVyVNN6JffnEen8UMCdRTzOhGXNQGo5GNL9QugHrz727Wnng==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vitest/pretty-format": "3.0.9",
         "loupe": "^3.1.3",
@@ -8951,6 +8978,7 @@
       "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.0.9.tgz",
       "integrity": "sha512-OW9F8t2J3AwFEwENg3yMyKWweF7oRJlMyHOMIhO5F3n0+cgQAJZBjNgrF8dLwFTEXl5jUqBLXd9QyyKv8zEcmA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "tinyrainbow": "^2.0.0"
       },
@@ -9227,7 +9255,6 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
       "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -9280,7 +9307,6 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
       "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -9451,6 +9477,7 @@
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
       "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -9805,7 +9832,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -9908,6 +9934,7 @@
       "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
       "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=8"
       }
@@ -10045,6 +10072,7 @@
       "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
       "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "assertion-error": "^2.0.1",
         "check-error": "^2.1.1",
@@ -10105,6 +10133,7 @@
       "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
       "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">= 16"
       }
@@ -10623,6 +10652,7 @@
       "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
       "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=6"
       }
@@ -10955,7 +10985,8 @@
       "version": "1.7.0",
       "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
       "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
@@ -10990,7 +11021,6 @@
       "integrity": "sha512-qKA6Pvai73+M2FtftpNKRxJ78GIjmFXFxd/1DVBqGo/qNhLSfv+G12n9pNoWdytJC8U00TrViOwpjT0zgqQS8Q==",
       "hasInstallScript": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "esbuild": "bin/esbuild"
       },
@@ -11111,6 +11141,7 @@
       "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
       "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/estree": "^1.0.0"
       }
@@ -11329,6 +11360,7 @@
       "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
       "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
       "license": "Apache-2.0",
+      "peer": true,
       "engines": {
         "node": ">=12.0.0"
       }
@@ -12024,7 +12056,6 @@
       "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.10.0.tgz",
       "integrity": "sha512-AjqGKbDGUFRKIRCP9tCKiIGHyriz2oHEbPIbEtcSLSs4YjReZOIPQQWek4+6hjw62H9QShXHyaGivGiYVLeYFQ==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0"
       }
@@ -12820,7 +12851,6 @@
       "integrity": "sha512-N4GT5on8UkZgH0O5LUavMRV1EDEhNTL0KEfRmDIeZHSV7p2XgLoY9t9VDUgL6o+yfdgYHVxuz81G8oB9VG5uyA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "^28.1.3",
         "@jest/types": "^28.1.3",
@@ -15143,7 +15173,8 @@
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
       "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/lru-cache": {
       "version": "5.1.1",
@@ -15159,6 +15190,7 @@
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
       "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
@@ -15484,6 +15516,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "bin": {
         "nanoid": "bin/nanoid.cjs"
       },
@@ -16058,13 +16091,15 @@
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
       "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/pathval": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
       "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">= 14.16"
       }
@@ -16080,7 +16115,6 @@
       "resolved": "https://registry.npmjs.org/pg/-/pg-8.18.0.tgz",
       "integrity": "sha512-xqrUDL1b9MbkydY/s+VZ6v+xiMUmOUk7SS9d/1kpyQxoJ6U9AO1oIJyUWVZojbfe5Cc/oluutcgFG4L9RDP1iQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "pg-connection-string": "^2.11.0",
         "pg-pool": "^3.11.0",
@@ -16369,6 +16403,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -16870,8 +16905,7 @@
       "version": "0.2.2",
       "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
       "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
-      "license": "Apache-2.0",
-      "peer": true
+      "license": "Apache-2.0"
     },
     "node_modules/require-directory": {
       "version": "2.1.1",
@@ -17067,6 +17101,7 @@
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.57.1.tgz",
       "integrity": "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/estree": "1.0.8"
       },
@@ -17140,7 +17175,6 @@
       "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
       "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "tslib": "^2.1.0"
       }
@@ -17414,7 +17448,8 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
       "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
-      "license": "ISC"
+      "license": "ISC",
+      "peer": true
     },
     "node_modules/signal-exit": {
       "version": "3.0.7",
@@ -17613,7 +17648,8 @@
       "version": "0.0.2",
       "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
       "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/standard-as-callback": {
       "version": "2.1.0",
@@ -17676,7 +17712,8 @@
       "version": "3.10.0",
       "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
       "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/stream-events": {
       "version": "1.0.5",
@@ -18249,19 +18286,22 @@
       "version": "2.9.0",
       "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
       "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/tinyexec": {
       "version": "0.3.2",
       "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
       "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/tinyglobby": {
       "version": "0.2.15",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
       "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fdir": "^6.5.0",
         "picomatch": "^4.0.3"
@@ -18278,6 +18318,7 @@
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
       "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12.0.0"
       },
@@ -18308,6 +18349,7 @@
       "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
       "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": "^18.0.0 || >=20.0.0"
       }
@@ -18317,6 +18359,7 @@
       "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
       "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=14.0.0"
       }
@@ -18326,6 +18369,7 @@
       "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
       "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=14.0.0"
       }
@@ -18529,7 +18573,6 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -18572,8 +18615,7 @@
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "license": "0BSD",
-      "peer": true
+      "license": "0BSD"
     },
     "node_modules/tsscmp": {
       "version": "1.0.6",
@@ -18679,7 +18721,6 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "devOptional": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -19053,6 +19094,7 @@
       "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.0.9.tgz",
       "integrity": "sha512-w3Gdx7jDcuT9cNn9jExXgOyKmf5UOTb6WMHz8LGAm54eS1Elf5OuBhCxl6zJxGhEeIkgsE1WbHuoL0mj/UXqXg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cac": "^6.7.14",
         "debug": "^4.4.0",
@@ -19075,6 +19117,7 @@
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
       "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12.0.0"
       },
@@ -19264,7 +19307,6 @@
       "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.105.2.tgz",
       "integrity": "sha512-dRXm0a2qcHPUBEzVk8uph0xWSjV/xZxenQQbLwnwP7caQCYpqG1qddwlyEkIDkYn0K8tvmcrZ+bOrzoQ3HxCDw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.8",
@@ -19353,6 +19395,7 @@
       "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
       "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "siginfo": "^2.0.0",
         "stackback": "0.0.2"
@@ -19452,7 +19495,6 @@
       "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
       "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=10.0.0"
       },