package ns import ( "context" "errors" "fmt" "net/url" "github.com/nspcc-dev/neo-go/pkg/core/state" "github.com/nspcc-dev/neo-go/pkg/neorpc/result" "github.com/nspcc-dev/neo-go/pkg/rpcclient" "github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker" "github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap" "github.com/nspcc-dev/neo-go/pkg/util" "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" "github.com/nspcc-dev/neofs-contract/nns" "github.com/nspcc-dev/neofs-sdk-go/container" cid "github.com/nspcc-dev/neofs-sdk-go/container/id" ) // NNS looks up NeoFS names using Neo Name Service. // // Instances are created with a variable declaration. Before work, the connection // to the NNS server MUST be established using Dial method. type NNS struct { nnsContract util.Uint160 invoker interface { Call(contract util.Uint160, operation string, params ...any) (*result.Invoke, error) } } // Dial connects to the address of the NNS server. If fails, the instance // MUST NOT be used. // // If URL address scheme is 'ws' or 'wss', then WebSocket protocol is used, // otherwise HTTP. func (n *NNS) Dial(address string) error { // multiSchemeClient unites invoker.RPCInvoke and common interface of // rpcclient.Client and rpcclient.WSClient. Interface is anonymous // according to assumption that common interface of these client types // is not required by design and may diverge with changes. var multiSchemeClient interface { invoker.RPCInvoke // Init turns client to "ready-to-work" state. Init() error // GetContractStateByID returns state of the NNS contract on 1 input. GetContractStateByID(int32) (*state.Contract, error) } var err error uri, err := url.Parse(address) if err == nil && (uri.Scheme == "ws" || uri.Scheme == "wss") { multiSchemeClient, err = rpcclient.NewWS(context.Background(), address, rpcclient.Options{}) if err != nil { return fmt.Errorf("create Neo WebSocket client: %w", err) } } else { multiSchemeClient, err = rpcclient.New(context.Background(), address, rpcclient.Options{}) if err != nil { return fmt.Errorf("create Neo HTTP client: %w", err) } } if err = multiSchemeClient.Init(); err != nil { return fmt.Errorf("initialize Neo client: %w", err) } nnsContract, err := multiSchemeClient.GetContractStateByID(1) if err != nil { return fmt.Errorf("get NNS contract state: %w", err) } n.invoker = invoker.New(multiSchemeClient, nil) n.nnsContract = nnsContract.Hash return nil } // ResolveContainerDomain looks up for NNS TXT records for the given container domain // by calling `resolve` method of NNS contract. Returns the first record which represents // valid container ID in a string format. Otherwise, returns an error. // // ResolveContainerDomain MUST NOT be called before successful Dial. // // See also https://docs.neo.org/docs/en-us/reference/nns.html. func (n *NNS) ResolveContainerDomain(domain container.Domain) (cid.ID, error) { item, err := unwrap.Item(n.invoker.Call(n.nnsContract, "resolve", domain.Name()+"."+domain.Zone(), int64(nns.TXT), )) if err != nil { return cid.ID{}, fmt.Errorf("contract invocation: %w", err) } if _, ok := item.(stackitem.Null); !ok { arr, ok := item.Value().([]stackitem.Item) if !ok { // unexpected for types from stackitem package return cid.ID{}, errors.New("invalid cast to stack item slice") } var id cid.ID for i := range arr { bs, err := arr[i].TryBytes() if err != nil { return cid.ID{}, fmt.Errorf("convert array item to byte slice: %w", err) } err = id.DecodeString(string(bs)) if err == nil { return id, nil } } } return cid.ID{}, errNotFound }