Round 1: Commitment
+--------+     commitment_i     +--------+
|Party 1 | ------------------> |        |
+--------+                     |        |
+--------+     commitment_j    |Bulletin|
|Party 2 | ------------------> | Board  |
+--------+                     |        |
    ...                        |        |
+--------+     commitment_n    |        |
|Party n | ------------------> |        |
+--------+                     +--------+

Round 2: Share Distribution
+--------+     share_1j        +--------+
|Party 1 | ------------------> |Party 2 |
+--------+                     +--------+
          \    share_1n        +--------+
           `-----------------> |Party n |
                               +--------+

Round 3: Verification
+--------+   verify_shares     +--------+
|Party i | <-----------------> |Party j |
+--------+                     +--------+
              All verify: PK = g^x

Presign Phase (offline, can be batched):
+--------+                     +--------+
|Party 1 |  k_1, gamma_1       |Party 2 |
|        | ------------------> |        |
|        | <------------------ |        |
|        |  k_2, gamma_2       |        |
+--------+                     +--------+
         Delta = sum(k_i * gamma_i)
         R = g^(1/Delta)
         Store (R, k_i, chi_i) as presignature

Online Phase (with message):
+--------+                     +--------+
|Party 1 |  sigma_1            |Party 2 |
|        | ------------------> |        |
|        | <------------------ |        |
|        |  sigma_2            |        |
+--------+                     +--------+
         s = sum(sigma_i)
         Signature: (r, s)

// Source: github.com/luxfi/threshold/protocols/lss/config

// Config represents an LSS party configuration
type Config struct {
    // Party identification
    PartyID   party.ID
    PartyIDs  []party.ID
    Threshold int

    // Key material (never leaves secure enclave)
    SecretShare *big.Int
    PublicKey   *ecdsa.PublicKey

    // Presignature pool
    PresignPool []*Presignature

    // Protocol state
    Generation  uint64
    RefreshTime time.Time
}

// Initiate DKG for a new bridge key
session, err := thresholdVM.StartKeygen(
    "bridge-key-001",     // Key ID
    "secp256k1",          // Key type
    "B-Chain",            // Requesting chain
)

// Wait for DKG to complete
for session.Status != "completed" {
    time.Sleep(time.Second)
    session, _ = thresholdVM.GetKeygenSession(session.SessionID)
}

// Get the resulting public key
pubKey, err := thresholdVM.GetPublicKey("bridge-key-001")
// pubKey can now be used in bridge contracts

// Request signature from T-Chain
session, err := thresholdVM.RequestSignature(
    "B-Chain",                  // Requesting chain
    "bridge-key-001",           // Key ID
    messageHash,                // 32-byte hash to sign
    "eth_sign",                 // Signature type
)

// Poll for completion
for session.Status == "signing" {
    time.Sleep(100 * time.Millisecond)
    session, _ = thresholdVM.GetSignature(session.SessionID)
}

// Extract signature components
sig := session.Signature
r := sig.R
s := sig.S
v := sig.V

// Signature is now ready for submission to external chain

// Triggered when signer is replaced (LP-333)
newPartyIDs := append(currentPartyIDs[:removedIndex],
    append([]party.ID{newPartyID}, currentPartyIDs[removedIndex+1:]...)...)

session, err := thresholdVM.ReshareKey(
    "bridge-key-001",
    newPartyIDs,
    "B-Chain",
)

// After reshare:
// - Public key UNCHANGED (same addresses work)
// - All parties have new shares
// - Removed party's old share is useless

// Periodic refresh for proactive security
session, err := thresholdVM.RefreshKey(
    "bridge-key-001",
    "B-Chain",
)

// After refresh:
// - Public key UNCHANGED
// - All parties have new shares
// - Old shares become invalid
// - Prevents long-term compromise

// During signing, if party cheats:
result, cheaters, err := protocol.Sign(ctx, message)
if err == protocol.ErrAbort {
    for _, cheaterID := range cheaters {
        // Report cheater for slashing
        bridgeVM.SlashSigner(&SlashSignerInput{
            NodeID:       cheaterID,
            Reason:       "protocol_abort",
            SlashPercent: 100,
            Evidence:     cheaters.Evidence(),
        })
    }
}

Time ------>
[Refresh]----[Safe]----[Refresh]----[Safe]----[Refresh]
    |                      |                      |
    v                      v                      v
Old shares invalid    Old shares invalid    Current shares

// Source: github.com/luxfi/threshold/pkg/party

// ID uniquely identifies a party in the MPC protocol
type ID string

// FromNodeID converts a Lux NodeID to Party ID
func FromNodeID(nodeID ids.NodeID) ID {
    return ID(nodeID.String())
}

// Source: github.com/luxfi/threshold/pkg/pool

// Pool manages concurrent MPC operations
type Pool struct {
    workers    int
    taskQueue  chan task
    resultChan chan result
}

// NewPool creates a worker pool with n workers
func NewPool(n int) *Pool {
    p := &Pool{
        workers:   n,
        taskQueue: make(chan task, n*2),
    }
    for i := 0; i < n; i++ {
        go p.worker()
    }
    return p
}

// All MPC messages are:
// 1. Authenticated with sender's party key
// 2. Encrypted to recipient's party key
// 3. Delivered via consensus (no direct P2P)

type MPCMessage struct {
    SessionID   string
    FromParty   party.ID
    ToParty     party.ID
    Round       int
    Payload     []byte  // Encrypted
    Signature   []byte  // Authentication
}

// B-Chain sends MPC request via CrossChainAppRequest
func (vm *BridgeVM) requestSignature(hash []byte) error {
    req := &CrossChainMPCRequest{
        Type:            "sign",
        RequestingChain: "B-Chain",
        KeyID:           vm.activeKeyID,
        MessageHash:     hash,
    }

    reqBytes, _ := Codec.Marshal(CodecVersion, req)

    return vm.appSender.SendCrossChainAppRequest(
        ctx,
        vm.thresholdVMChainID,
        vm.nextRequestID(),
        reqBytes,
    )
}

// T-Chain processes request and returns signature
func (vm *ThresholdVM) CrossChainAppRequest(
    ctx context.Context,
    chainID ids.ID,
    requestID uint32,
    deadline time.Time,
    request []byte,
) error {
    var req CrossChainMPCRequest
    Codec.Unmarshal(request, &req)

    switch req.Type {
    case "sign":
        session, err := vm.RequestSignature(
            req.RequestingChain,
            req.KeyID,
            req.MessageHash,
            req.MessageType,
        )
        // Response sent when signing completes
    }
    return nil
}