What changed in Go, Rust and Solidity this week.

// This program demonstrates that a tls.Config with MinVersion set to TLS1.2
// can be used without error. In a real QUIC implementation the library
// would internally clamp the effective minimum to TLS1.3, but that logic
// is not exercised here because we cannot create a QUIC connection in
// this sandbox.

package main

import (
	"crypto/tls"
	"fmt"
)

func main() {
	// Create a configuration that allows TLS1.2 as the minimum.
	cfg := &tls.Config{
		MinVersion: tls.VersionTLS12,
	}

	// Normally we would use cfg with a QUIC listener here.
	// For demonstration, we simply print the effective MinVersion.
	fmt.Printf("Configured MinVersion: %v\n", cfg.MinVersion)

	// The configuration is valid; no panic or error occurs.
}

// This program demonstrates the current state of the x/crypto/ssh package
// before the AuthCallback feature is available. It constructs a
// ClientAuthContext manually and prints its fields. The AuthCallback
// field does not exist in Go 1.27.1, so we cannot use it here.
// The program compiles and runs with the standard library only.

package main

import (
	"fmt"
)

type ConnMetadata struct{ Host string }
type NegotiatedAlgorithms struct{ KeyAlgo string }

type ClientAuthContext struct {
	Metadata              ConnMetadata
	Algorithms            NegotiatedAlgorithms
	AllowedMethods        []string
	PartialSuccessMethods []string
	TriedMethods          []string
}

func main() {
	// Create a sample context that might be passed to a future AuthCallback.
	ctx := ClientAuthContext{
		Metadata: ConnMetadata{Host: "example.com"},
		Algorithms: NegotiatedAlgorithms{
			KeyAlgo: "curve25519-sha256",
		},
		AllowedMethods:        []string{"publickey", "password"},
		PartialSuccessMethods: []string{"publickey"},
		TriedMethods:          []string{"none"},
	}

	// Print the context to show what information would be available.
	fmt.Printf("Metadata: %+v\n", ctx.Metadata)
	fmt.Printf("Algorithms: %+v\n", ctx.Algorithms)
	fmt.Printf("AllowedMethods: %v\n", ctx.AllowedMethods)
	fmt.Printf("PartialSuccessMethods: %v\n", ctx.PartialSuccessMethods)
	fmt.Printf("TriedMethods: %v\n", ctx.TriedMethods)
}

// This program simply demonstrates the updated RFC header style.
// It prints a message that the RFC title is now plain text,
// and the first Markdown header starts with `##`.
// No network or external input is required.

fn main() {
    // The title of an RFC is plain text, not a level‑1 header.
    println!("RFC title is plain text, not a level‑1 header.");

    // The first header in the body should be level‑2 (`##`).
    println!("First header in the body should start with `##`.");
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates that delete on a memory bytes array element
// clears only the targeted byte, not the whole 32‑byte word.
contract Main {
    function clearByte(uint index) external pure returns (bytes memory) {
        bytes memory data = new bytes(5);
        // set all bytes to 0xFF for visibility
        for (uint i = 0; i < data.length; i++) {
            data[i] = 0xFF;
        }
        // delete the element at `index`
        delete data[index];
        return data;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_singleByteCleared() public {
        bytes memory result = main.clearByte(2);
        // bytes[2] should be 0x00, others remain 0xFF
        require(result[2] == 0x00, "byte not cleared");
        require(result[0] == 0xFF, "other byte altered");
        require(result[1] == 0xFF, "other byte altered");
        require(result[3] == 0xFF, "other byte altered");
        require(result[4] == 0xFF, "other byte altered");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates the 0.8.37 delete‑byte‑array‑element fix.
// It creates a memory bytes array, sets each element to 0x01,
// deletes the middle element, and returns the array.
contract Demo {
    function deleteMiddle() external pure returns (bytes memory) {
        bytes memory b = new bytes(3);
        b[0] = 0x01;
        b[1] = 0x01;
        b[2] = 0x01;
        delete b[1]; // only b[1] should become 0x00
        return b;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract DemoTest {
    Demo demo;

    constructor() {
        demo = new Demo();
    }

    function test_deleteLeavesOtherBytes() external {
        bytes memory result = demo.deleteMiddle();
        require(result.length == 3, "wrong length");
        require(result[0] == 0x01, "b[0] altered");
        require(result[1] == 0x00, "b[1] not zeroed");
        require(result[2] == 0x01, "b[2] altered");
    }
}