Private Negotiation

  const maxPrice = buyerMaxPrice();
  const limitRandomness = buyerLimitRandomness();
  const price = agreedPrice();
  const priceRandomnessValue = priceRandomness();

  assert(
    limitCommitment(pad(32, "negotiation:buyer:"), buyerKey, maxPrice, limitRandomness) == buyerCommitment,
    "buyer limit commitment mismatch"
  );
  assert(price <= maxPrice, "price exceeds buyer maximum");

  priceCommitment = disclose(priceCommitmentFor(price, priceRandomnessValue));
  status = DealStatus.AUTHORIZED;
}

      const providerContext: PublicNegotiationContext = {
        role: context.role,
        productCode: context.productCode,
        round: context.round,
        ...(context.publicReferencePrice === undefined
          ? {}
          : { publicReferencePrice: context.publicReferencePrice }),
        ...(context.currentOffer === undefined
          ? {}
          : {
              currentOffer: {
                maker: context.currentOffer.maker,
                price: context.currentOffer.price,
              },
            }),
      };
      const candidates = validateCandidates(
        await input.provider.generateCandidates(providerContext),
      );

    const bytes = Buffer.from(
      hkdfSync(
        "sha256",
        input.sharedKey,
        Buffer.from("midnight-private-price-offset-v1", "utf8"),
        Buffer.from(
          JSON.stringify([
            input.sessionId,
            input.productCode,
            input.publicReferencePrice,
            attempt,
          ]),
          "utf8",
        ),
        32,
      ),
    );
    const sample = BigInt(`0x${bytes.toString("hex")}`);
    bytes.fill(0);
    if (sample < ceiling) {

export const encryptRelayPayload = (input: {
  sharedKey: Buffer;
  metadata: RelayMetadata;
  payload: unknown;
}): RelayPacket => {
  if (input.sharedKey.length !== 32) {
    throw new Error("relay shared key must contain 32 bytes");
  }
  const nonce = randomBytes(12);
  const cipher = createCipheriv("aes-256-gcm", input.sharedKey, nonce);
  cipher.setAAD(relayAssociatedData(input.metadata));
  const ciphertext = Buffer.concat([
    cipher.update(JSON.stringify(input.payload), "utf8"),
    cipher.final(),
  ]);

  if (record.phase === "CLEANED") return { kind: "ALREADY_CLEANED" };
  if (record.contractAddress === undefined) return { kind: "KEPT", reason: "NO_CONTRACT" };
  const contractAddress = record.contractAddress;
  // Nothing is erased for a session that cannot prove which deal it is.
  if (record.dealId === undefined || record.network !== input.network) {
    return { kind: "KEPT", reason: "IDENTITY_MISMATCH" };
  }
  const dealId = record.dealId;

  // The chain decides the outcome. A caller's claim is never enough to treat
  // an open or authorized deal as final.
  let state: PublicDealState;
  try {
    state = await input.readDealState(contractAddress);
  } catch {
    return { kind: "KEPT", reason: "CHAIN_UNAVAILABLE" };
  }