QUIC Submission

use lunar_lander_quic_client::{ClientOptions, LunarLanderQuicClient};

let client = LunarLanderQuicClient::connect_with_options(
    "fra.lunar-lander.hellomoon.io:16888",
    std::env::var("LUNAR_LANDER_API_KEY")?,
    ClientOptions {
        mev_protect: true,
        ..ClientOptions::default()
    },
)
.await?;

use rcgen::CustomExtension;

// Inside your cert generation, before calling params.self_signed():
let mev_ext = CustomExtension::from_oid_content(
    &[2, 999, 1, 1],
    vec![0x01, 0x01, 0xFF], // DER BOOLEAN TRUE
);
params.custom_extensions.push(mev_ext);

import (
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/asn1"
)

// Inside your certificate template, before calling x509.CreateCertificate():
template.ExtraExtensions = []pkix.Extension{
    {
        Id:       asn1.ObjectIdentifier{2, 999, 1, 1},
        Critical: false,
        Value:    []byte{0x01, 0x01, 0xFF}, // DER BOOLEAN TRUE
    },
}

use lunar_lander_quic_client::LunarLanderQuicClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("LUNAR_LANDER_API_KEY")?;
    let client = LunarLanderQuicClient::connect(
        "fra.lunar-lander.hellomoon.io:16888",
        api_key,
    )
    .await?;

    let tx_bytes: Vec<u8> = load_signed_transaction_bytes()?;
    client.send_transaction(&tx_bytes).await?;

    Ok(())
}

[dependencies]
lunar-lander-quic-client = "0.1.0"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

use quinn::{ClientConfig, Endpoint};
use rcgen::{CertificateParams, DistinguishedName, DnType, KeyPair};
use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer};
use std::{net::SocketAddr, sync::Arc};

const LUNAR_LANDER_TPU_PROTOCOL_ID: &[u8] = b"lunar-lander-tpu";
const SERVER_ADDR: &str = "fra.lunar-lander.hellomoon.io:16888";
const SERVER_NAME: &str = "fra.lunar-lander.hellomoon.io";

fn build_client_config(api_key: &str) -> anyhow::Result<ClientConfig> {
    let key_pair = KeyPair::generate()?;
    let mut params = CertificateParams::new(Vec::new())?;
    let mut distinguished_name = DistinguishedName::new();
    distinguished_name.push(DnType::CommonName, api_key);
    params.distinguished_name = distinguished_name;

    let certificate = params.self_signed(&key_pair)?;
    let private_key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(key_pair.serialize_der()));

    let mut rustls = rustls::ClientConfig::builder()
        .with_root_certificates(load_server_roots()?)
        .with_client_auth_cert(
            vec![CertificateDer::from(certificate.der().to_vec())],
            private_key,
        )?;

    rustls.alpn_protocols = vec![LUNAR_LANDER_TPU_PROTOCOL_ID.to_vec()];

    Ok(ClientConfig::new(Arc::new(
        quinn::crypto::rustls::QuicClientConfig::try_from(rustls)?
    )))
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let api_key = std::env::var("LUNAR_LANDER_API_KEY")?;
    let server_addr: SocketAddr = SERVER_ADDR.parse()?;

    let client_config = build_client_config(&api_key)?;

    let mut endpoint = Endpoint::client("0.0.0.0:0".parse()?)?;
    endpoint.set_default_client_config(client_config);

    let connection = endpoint.connect(server_addr, SERVER_NAME)?.await?;

    let tx_bytes: Vec<u8> = load_signed_transaction_bytes()?;

    let mut send = connection.open_uni().await?;
    send.write_all(&tx_bytes).await?;
    send.finish()?;

    Ok(())
}

package main

import (
	"context"
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/tls"
	"crypto/x509"
	"crypto/x509/pkix"
	"math/big"
	"os"
	"time"

	quic "github.com/quic-go/quic-go"
)

const (
	ServerAddr = "fra.lunar-lander.hellomoon.io:16888"
	ServerName = "fra.lunar-lander.hellomoon.io"
	ALPN       = "lunar-lander-tpu"
)

func buildClientCertificate(apiKey string) (tls.Certificate, error) {
	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		return tls.Certificate{}, err
	}

	template := &x509.Certificate{
		SerialNumber: big.NewInt(time.Now().UnixNano()),
		Subject: pkix.Name{
			CommonName: apiKey,
		},
		NotBefore:             time.Now().Add(-time.Minute),
		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
		KeyUsage:              x509.KeyUsageDigitalSignature,
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
		BasicConstraintsValid: true,
	}

	certDER, err := x509.CreateCertificate(rand.Reader, template, template, &privateKey.PublicKey, privateKey)
	if err != nil {
		return tls.Certificate{}, err
	}

	return tls.Certificate{
		Certificate: [][]byte{certDER},
		PrivateKey:  privateKey,
	}, nil
}

func main() {
	apiKey := os.Getenv("LUNAR_LANDER_API_KEY")
	if apiKey == "" {
		panic("LUNAR_LANDER_API_KEY is required")
	}

	clientCert, err := buildClientCertificate(apiKey)
	if err != nil {
		panic(err)
	}

	tlsConfig := &tls.Config{
		Certificates: []tls.Certificate{clientCert},
		ServerName:   ServerName,
		NextProtos:   []string{ALPN},
		InsecureSkipVerify: true,
	}

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := quic.DialAddr(ctx, ServerAddr, tlsConfig, &quic.Config{
		// quic-go defaults to 1280-byte Initial packets; Lunar Lander expects 1200 here.
		InitialPacketSize: 1200,
	})
	if err != nil {
		panic(err)
	}
	defer conn.CloseWithError(0, "")

	txBytes, err := os.ReadFile("signed-tx.bin")
	if err != nil {
		panic(err)
	}

	stream, err := conn.OpenUniStreamSync(ctx)
	if err != nil {
		panic(err)
	}

	if _, err := stream.Write(txBytes); err != nil {
		panic(err)
	}

	if err := stream.Close(); err != nil {
		panic(err)
	}
}