如何使用Go-Ethereum使用AWS区块链服务？

Question

AWS区块链服务为 http 和 websocket 协议提供了端点，但需要使用IAM签名验证来使用它们。

To use the HTTP endpoint, I just need to sign it in the http.RoundTripper 通过AWS SDK接口。但是，如果我需要使用WebSocket端点，我只能通过 websocket.dialer 通过 rpc.dialwebsocketwithdialer 由于go-ethereum的局限性，这意味着我无法通过实现接口来解决此问题。

如何使用Go-Ethereum使用AWS区块链服务的Websocket端点？

Answer 1

通过阅读 github.com/gorilla/websocket/websocket 源代码，我发现在（*Dialer）DialContext函数将http.request指针传递到可自定义的代理函数中，这意味着我可以编写一个功能，该函数与> http.RoundTripper用于注入标头。

Websocket

package transport

import (
    "context"
    "crypto/sha256"
    "encoding/hex"
    "net/http"
    "net/url"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
    "github.com/gorilla/websocket"
)

func NewWebSocketDialer(config aws.Config) (*websocket.Dialer, error) {
    return &websocket.Dialer{
        HandshakeTimeout: 45 * time.Second,
        Proxy: func(request *http.Request) (*url.URL, error) {
            credentials, err := config.Credentials.Retrieve(request.Context())
            if err != nil {
                return nil, err
            }

            // Because AWS may sign some unrelated headers and cause authentication failure, you need to create a blank request.
            internalRequest, err := http.NewRequest(http.MethodGet, request.URL.String(), nil)
            if err != nil {
                return nil, err
            }

            header := request.Header.Clone()

            hash := sha256.New()

            signer := v4.NewSigner()

            if err := signer.SignHTTP(context.Background(), credentials, internalRequest, hex.EncodeToString(hash.Sum(nil)), "managedblockchain", config.Region, time.Now()); err != nil {
                return nil, err
            }

            request.Header = internalRequest.Header

            request.Header.Set("Connection", header["Connection"][0])
            request.Header.Set("Sec-WebSocket-Key", header["Sec-WebSocket-Key"][0])
            request.Header.Set("Sec-WebSocket-Version", header["Sec-WebSocket-Version"][0])
            request.Header.Set("Upgrade", header["Upgrade"][0])

            return http.ProxyFromEnvironment(request)
        },
    }, nil
}

HTTP

package transport

import (
    "compress/gzip"
    "context"
    "crypto/sha256"
    "encoding/base64"
    "encoding/hex"
    "io"
    "net/http"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
)

var _ http.RoundTripper = &httpRoundTripper{}

type httpRoundTripper struct {
    config aws.Config
}

func (h httpRoundTripper) RoundTrip(request *http.Request) (*http.Response, error) {
    credentials, err := h.config.Credentials.Retrieve(request.Context())
    if err != nil {
        return nil, err
    }

    internalRequest := request.Clone(request.Context())

    bodyReader, err := request.GetBody()
    if err != nil {
        return nil, err
    }

    hash := sha256.New()

    if _, err := io.Copy(hash, bodyReader); err != nil {
        return nil, err
    }

    signer := v4.NewSigner()
    if err := signer.SignHTTP(context.Background(), credentials, internalRequest, hex.EncodeToString(hash.Sum(nil)), "managedblockchain", h.config.Region, time.Now()); err != nil {
        return nil, err
    }

    response, err := h.config.HTTPClient.Do(internalRequest)
    if err != nil {
        return nil, err
    }

    if response.Header.Get("Content-Type") == "gzip" {
        gzipReader, err := gzip.NewReader(base64.NewDecoder(base64.StdEncoding, response.Body))
        if err != nil {
            return nil, err
        }

        request.Header.Set("Content-Type", "application/json")

        response.Body = gzipReader
    }

    return response, nil
}

func NewHttpRoundTripper(cfg aws.Config) http.RoundTripper {
    return httpRoundTripper{
        config: cfg,
    }
}