Create Mobile Wallet Test Host

[StuartFerguson]

This needs some extra stuff added to it

1. You DO NOT have transaction safety yet

Right now:

await wallet.Debit(...)
await wallet.Credit(...)

This is not atomic

Real fix:

Use DB transaction:

using var tx = await db.Database.BeginTransactionAsync();

2. No concurrency control

Two requests could:

read same balance
both debit
→ double spend
Real fix:
RowVersion (optimistic concurrency)
OR SQL locking (FOR UPDATE equivalent)

3. Webhooks are not retry-persistent anymore

You lost:

retry queue persistence

Right now:

fire-and-forget again

4. No indexes on hot paths

You should add:

b.Entity()
.HasIndex(t => t.Created);

b.Entity()
.HasIndex(i => new { i.Type, i.Value });

[StuartFerguson]

1. Add DB transactions (HIGH PRIORITY)

Wrap debit/credit:

using var tx = await db.Database.BeginTransactionAsync();

[StuartFerguson]

2. Add concurrency control
   [Timestamp]
   public byte[] RowVersion { get; set; }

[StuartFerguson]

3. Persist webhook delivery attempts

Create:

WebhookEvents table
WebhookDeliveries table

[StuartFerguson]

[StuartFerguson]

// =====================================================
// PRODUCTION UPGRADE: SQL SERVER + EF CORE PERSISTENCE
// =====================================================

using Microsoft.EntityFrameworkCore;
using System.Threading.Channels;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// -----------------------
// DATABASE (SQL SERVER)
// -----------------------
builder.Services.AddDbContext(opt =>
opt.UseSqlServer(builder.Configuration.GetConnectionString("Default")
?? "Server=localhost;Database=MobileMoney;Trusted_Connection=True;TrustServerCertificate=True"));

builder.Services.AddScoped();
builder.Services.AddScoped();
builder.Services.AddScoped();

builder.Services.AddSingleton(Channel.CreateUnbounded());
builder.Services.AddHostedService();

builder.Services.AddHttpClient();
builder.Services.AddSingleton();

var app = builder.Build();

app.UseSwagger();
app.UseSwaggerUI();

// -----------------------
// MIGRATE DB ON START
// -----------------------
using (var scope = app.Services.CreateScope())
{
var db = scope.ServiceProvider.GetRequiredService();
db.Database.Migrate();
}

// -----------------------
// ENDPOINT SAMPLE
// -----------------------
app.MapPost("/accounts", async (WalletService svc, AccountCreateRequest req)
=> Results.Created("/accounts", await svc.CreateAsync(req)));

app.MapPost("/transactions", async (TransactionService svc, TransactionRequest req)
=> Results.Accepted("/transactions", await svc.CreateAsync(req)));

app.Run();

// =====================================================
// DB CONTEXT
// =====================================================

class AppDbContext : DbContext
{
public AppDbContext(DbContextOptions options) : base(options) { }

public DbSet<Account> Accounts => Set<Account>();
public DbSet<Transaction> Transactions => Set<Transaction>();
public DbSet<AccountIdentifier> Identifiers => Set<AccountIdentifier>();
public DbSet<WebhookSubscription> Webhooks => Set<WebhookSubscription>();

protected override void OnModelCreating(ModelBuilder b)
{
    b.Entity<Account>().HasKey(x => x.Id);

    b.Entity<AccountIdentifier>()
        .HasIndex(x => new { x.Type, x.Value })
        .IsUnique();

    b.Entity<Transaction>().HasKey(x => x.Id);
}

}

// =====================================================
// DOMAIN (PERSISTED)
// =====================================================

class Account
{
public string Id { get; set; } = Guid.NewGuid().ToString();
public string Currency { get; set; } = "GBP";
public decimal CurrentBalance { get; set; }
public decimal AvailableBalance { get; set; }

public List<AccountIdentifier> Identifiers { get; set; } = new();

}

class AccountIdentifier
{
public int Id { get; set; }
public string Type { get; set; } = default!;
public string Value { get; set; } = default!;

public string AccountId { get; set; } = default!;
public Account Account { get; set; } = default!;

}

class Transaction
{
public string Id { get; set; } = Guid.NewGuid().ToString();
public decimal Amount { get; set; }
public string Currency { get; set; } = "GBP";
public string? DebitAccountId { get; set; }
public string? CreditAccountId { get; set; }
public string Status { get; set; } = "pending";
public string Type { get; set; } = "transfer";
public DateTime Created { get; set; } = DateTime.UtcNow;
}

// =====================================================
// SERVICES (EF CORE)
// =====================================================

record AccountCreateRequest(string Currency, string IdentifierType, string Identifier);
record TransactionRequest(decimal Amount, string Currency, string? DebitAccount, string? CreditAccount);

class WalletService
{
private readonly AppDbContext _db;

public WalletService(AppDbContext db) => _db = db;

public async Task<Account> CreateAsync(AccountCreateRequest req)
{
    var acc = new Account { Currency = req.Currency };

    acc.Identifiers.Add(new AccountIdentifier
    {
        Type = req.IdentifierType,
        Value = req.Identifier
    });

    _db.Accounts.Add(acc);
    await _db.SaveChangesAsync();

    return acc;
}

public async Task<Account?> ResolveAsync(string type, string value)
{
    return await _db.Accounts
        .Include(a => a.Identifiers)
        .FirstOrDefaultAsync(a => a.Identifiers.Any(i => i.Type == type && i.Value == value));
}

public async Task Credit(string accountId, decimal amount)
{
    var acc = await _db.Accounts.FindAsync(accountId);
    acc!.CurrentBalance += amount;
    acc.AvailableBalance += amount;
    await _db.SaveChangesAsync();
}

public async Task<bool> Debit(string accountId, decimal amount)
{
    var acc = await _db.Accounts.FindAsync(accountId);
    if (acc!.AvailableBalance < amount) return false;

    acc.CurrentBalance -= amount;
    acc.AvailableBalance -= amount;
    await _db.SaveChangesAsync();

    return true;
}

}

class TransactionService
{
private readonly AppDbContext _db;
private readonly Channel _queue;

public TransactionService(AppDbContext db, Channel<Transaction> queue)
{
    _db = db;
    _queue = queue;
}

public async Task<Transaction> CreateAsync(TransactionRequest req)
{
    var tx = new Transaction
    {
        Amount = req.Amount,
        Currency = req.Currency,
        DebitAccountId = req.DebitAccount,
        CreditAccountId = req.CreditAccount
    };

    _db.Transactions.Add(tx);
    await _db.SaveChangesAsync();

    await _queue.Writer.WriteAsync(tx);
    return tx;
}

}

// =====================================================
// BACKGROUND PROCESSOR (DB SAFE)
// =====================================================

class TransactionProcessor : BackgroundService
{
private readonly IServiceScopeFactory _scopeFactory;
private readonly Channel _queue;

public TransactionProcessor(IServiceScopeFactory scopeFactory, Channel<Transaction> queue)
{
    _scopeFactory = scopeFactory;
    _queue = queue;
}

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    await foreach (var tx in _queue.Reader.ReadAllAsync(stoppingToken))
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        var wallet = scope.ServiceProvider.GetRequiredService<WalletService>();

        var entity = await db.Transactions.FindAsync(tx.Id);

        var success = true;

        if (entity!.DebitAccountId != null)
            success &= await wallet.Debit(entity.DebitAccountId, entity.Amount);

        if (entity.CreditAccountId != null && success)
            await wallet.Credit(entity.CreditAccountId, entity.Amount);

        entity.Status = success ? "completed" : "failed";

        await db.SaveChangesAsync();
    }
}

}

// =====================================================
// WEBHOOK STORE (DB BACKED)
// =====================================================

class WebhookSubscription
{
public int Id { get; set; }
public string Url { get; set; } = default!;
public string Secret { get; set; } = "dev-secret";
}

class WebhookStore
{
private readonly AppDbContext _db;

public WebhookStore(AppDbContext db) => _db = db;

public async Task<List<WebhookSubscription>> GetAll()
    => await _db.Webhooks.ToListAsync();

}

class WebhookDispatcher
{
private readonly HttpClient _http;
private readonly WebhookStore _store;

public WebhookDispatcher(HttpClient http, WebhookStore store)
{
    _http = http;
    _store = store;
}

public async Task DispatchAsync(object payload)
{
    var subs = await _store.GetAll();

    foreach (var sub in subs)
    {
        var json = System.Text.Json.JsonSerializer.Serialize(payload);
        var sig = Compute(sub.Secret, json);

        var req = new HttpRequestMessage(HttpMethod.Post, sub.Url)
        {
            Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json")
        };

        req.Headers.Add("X-Signature", sig);

        await _http.SendAsync(req);
    }
}

private static string Compute(string secret, string payload)
{
    using var hmac = new System.Security.Cryptography.HMACSHA256(System.Text.Encoding.UTF8.GetBytes(secret));
    return Convert.ToBase64String(hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(payload)));
}

}