From 5ca0d508b63a9ac20b5cf38025b4a03dfe46941b Mon Sep 17 00:00:00 2001 From: Anna Shaleva Date: Thu, 20 Jul 2023 23:30:26 +0300 Subject: [PATCH] *: add wokshop file --- test.go | 407 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 407 insertions(+) create mode 100644 test.go diff --git a/test.go b/test.go new file mode 100644 index 000000000..3f7d7cc51 --- /dev/null +++ b/test.go @@ -0,0 +1,407 @@ +package main + +import ( + "context" + "encoding/base64" + "encoding/json" + "fmt" + "math/big" + "strings" + "time" + + "github.com/nspcc-dev/neo-go/internal/random" + "github.com/nspcc-dev/neo-go/pkg/config" + "github.com/nspcc-dev/neo-go/pkg/core/block" + "github.com/nspcc-dev/neo-go/pkg/core/native/nativenames" + "github.com/nspcc-dev/neo-go/pkg/core/state" + "github.com/nspcc-dev/neo-go/pkg/core/transaction" + "github.com/nspcc-dev/neo-go/pkg/neorpc" + "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/actor" + "github.com/nspcc-dev/neo-go/pkg/rpcclient/gas" + "github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker" + "github.com/nspcc-dev/neo-go/pkg/rpcclient/nep17" + "github.com/nspcc-dev/neo-go/pkg/rpcclient/policy" + "github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap" + "github.com/nspcc-dev/neo-go/pkg/smartcontract" + "github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger" + "github.com/nspcc-dev/neo-go/pkg/util" + "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" + "github.com/nspcc-dev/neo-go/pkg/vm/vmstate" + "github.com/nspcc-dev/neo-go/pkg/wallet" + "github.com/pkg/errors" +) + +const ( + rpcEndpoint = "http://localhost:30333" + wsEndpoint = "ws://localhost:30333/ws" + walletPath = "./w.json" + accPass = "" +) + +var ( + isNeoGoServer bool + + transferTxH, _ = util.Uint256DecodeStringLE("f359d99a16a93f4c5d838ae9669bc0b6406f783cd71e917c65af6774e9035fd9") +) + +func main() { + // Simple RPC client: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient + c, err := rpcclient.New(context.Background(), rpcEndpoint, rpcclient.Options{ + Cert: "", + Key: "", + CACert: "", + DialTimeout: 0, + RequestTimeout: 0, + MaxConnsPerHost: 0, + }) + check(err, "create RPC client") + defer c.Close() + + err = c.Init() + check(err, "init RPC client") + fmt.Printf("Work with simple RPC client:\n\n") + + // Simple RPC methods: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient#hdr-Client + v, err := c.GetVersion() + check(err, "retrieve version") + fmt.Printf("RPC node version: %s\n", v.UserAgent) + isNeoGoServer = strings.Contains(v.UserAgent, config.UserAgentPrefix) // NeoGo node offers several useful extensions. + + p, err := v.Protocol.MarshalJSON() + check(err, "marshal protocol config") + fmt.Printf("RPC node protocol config: %s\n", p) + + bCount, err := c.GetBlockCount() + check(err, "retrieve block height") + fmt.Printf("Block count: %d\n", bCount) + + currentB, err := c.GetBlockByIndex(bCount - 1) // Be careful with block count/block index conversions. + check(err, "retrieve currentB block") + + transferTx, err := c.GetRawTransactionVerbose(transferTxH) + check(err, "retrieve transfer tx") + fmt.Printf("Transfer tx script: %s\n", base64.StdEncoding.EncodeToString(transferTx.Script)) + + transferB, err := c.GetBlockByHash(transferTx.TransactionMetadata.Blockhash) + check(err, "retrieve transferB block") + + tr := trigger.Application + applog, err := c.GetApplicationLog(transferTxH, &tr) // Various triggers are supported. + check(err, "retrieve applog") + if len(applog.Executions) != 1 { + panic("unexpected executions number") + } + stack, err := json.MarshalIndent(applog.Executions[0].Stack, "", "\t") + check(err, "marshal stack") + fmt.Printf("Transfer applog invocation state: %s\nTransfer applog stack: %s\n", applog.Executions[0].VMState, stack) + + // ... + + // Work with wallets: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/wallet + w, err := wallet.NewWalletFromFile(walletPath) + check(err, "open wallet") + + acc := w.Accounts[0] + err = acc.Decrypt(accPass, w.Scrypt) + check(err, "decrypt account") + + // Some of the extensions offered by NeoGo RPC server: https://github.com/nspcc-dev/neo-go/blob/master/docs/rpc.md#extensions + if isNeoGoServer { + // NEP17/NEP11 transfers paging: https://github.com/nspcc-dev/neo-go/blob/master/docs/rpc.md#limits-and-paging-for-getnep11transfers-and-getnep17transfers + var ( + start = uint64(0) + stop = currentB.Timestamp + limit = 10 + page = 0 + ) + nep17T, err := c.GetNEP17Transfers(acc.ScriptHash(), &start, &stop, &limit, &page) + check(err, "retrieve NEP17 transfers") + tBytes, err := json.MarshalIndent(nep17T, "", "\t") + check(err, "marshal NEP17 transfers") + fmt.Printf("NEP17 transfers of %s:\n%s\n", acc.Address, tBytes) + + // `getblocksysfee` RPC call: https://github.com/nspcc-dev/neo-go/blob/master/docs/rpc.md#getblocksysfee-call + sysfee, err := c.GetBlockSysFee(nep17T.Received[0].Index) + check(err, "getblocksysfee") + fmt.Printf("Block #%d system fee: %d\n", nep17T.Received[0].Index, sysfee) + + // ... + } + + // Web-socket client and server: https://github.com/nspcc-dev/neo-go/blob/master/docs/rpc.md#websocket-server + ctx, cancel := context.WithCancel(context.Background()) + wsC, err := rpcclient.NewWS(ctx, wsEndpoint, rpcclient.WSOptions{ + Options: rpcclient.Options{}, + CloseNotificationChannelIfFull: false, + }) + // Do not use `defer wsC.Close()`, we'll close the client manually later. + + err = wsC.Init() + check(err, "init WS RPC client") + fmt.Printf("\nWork with WS RPC client:\n\n") + + // Same simple RPC methods over web-socket: + gasState, err := wsC.GetContractStateByAddressOrName(nativenames.Gas) + check(err, "getcontractstate") + fmt.Printf("GAS contract ID: %d\n", gasState.ID) + + // Unwrap helper package: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap + dec, err := unwrap.BigInt(wsC.InvokeFunction(gasState.Hash, "decimals", []smartcontract.Parameter{}, nil)) + check(err, "invokefunction") + fmt.Printf("GAS contract decimals: %s\n", dec) + + // ... + + // Notifications subsystem: https://github.com/nspcc-dev/neo-go/blob/master/docs/notifications.md + bCh := make(chan *block.Block, 5) // Add some buffer to prevent WSC from blocking even regular requests. + ntfCh := make(chan *state.ContainedNotificationEvent, 5) + aerCh := make(chan *state.AppExecResult, 5) + dispatcherToMainCh := make(chan struct{}) + go func(ctx context.Context, bCh chan *block.Block, ntfCh chan *state.ContainedNotificationEvent, exCh chan *state.AppExecResult, exitCh chan struct{}) { // TODO: move to a separate function + dispatcherLoop: + for { + select { + case b := <-bCh: + fmt.Printf("Block was received:\n\tIndex: %d\n\tPrimary: %d\n\tTransactions: %d\n", + b.Index, b.PrimaryIndex, len(b.Transactions)) + case ntf := <-ntfCh: + params, _ := ntf.Item.MarshalJSON() + fmt.Printf("Notification from execution was received:\n\tContainer: %s\n\tContract: %s\n\tName: %s\n\tParams: %s\n", + ntf.Container.StringLE(), ntf.ScriptHash.StringLE(), ntf.Name, params) + case aer := <-aerCh: + st, _ := json.Marshal(aer.Stack) + fmt.Printf("Application execution result was received:\n\tContainer: %s\n\tTrigger: %s\n\tVM state: %s\n\tStack:%s\n\tFault exception: %s\n", aer.Container.StringLE(), aer.Trigger, aer.VMState, st, aer.FaultException) + case <-ctx.Done(): + break dispatcherLoop + } + } + drainLoop: + for { + select { + case <-bCh: + case <-ntfCh: + case <-aerCh: + default: + break drainLoop + } + } + close(bCh) + close(ntfCh) + close(aerCh) + + // Send notification to the main routine. + close(dispatcherToMainCh) + }(ctx, bCh, ntfCh, aerCh, dispatcherToMainCh) + + primary := 0 + till := bCount + 5 + fltB := &neorpc.BlockFilter{ + Primary: &primary, + Since: nil, + Till: &till, + } + bSubID, err := wsC.ReceiveBlocks(fltB, bCh) + check(err, "subscribe for blocks notifications") + + ctr := gasState.Hash + name := "Transfer" + fltNtf := &neorpc.NotificationFilter{ + Contract: &ctr, + Name: &name, + } + ntfSubID, err := wsC.ReceiveExecutionNotifications(fltNtf, ntfCh) + check(err, "subscribe for execution notifications") + + st := vmstate.Halt.String() + fltEx := &neorpc.ExecutionFilter{ + State: &st, + } + aerSubId, err := wsC.ReceiveExecutions(fltEx, aerCh) + check(err, "subscribe for AppExecResults") + + // Pretend our app is running and performing some useful work. + t := time.NewTimer(10 * time.Second) + var exitErr error +mainLoop: + for { + select { + case <-t.C: + break mainLoop + case <-ctx.Done(): + exitErr = wsC.GetError() + break mainLoop + } + } + + // End of the app work. + if exitErr != nil { + fmt.Printf("WS RPC client closing error: %s\n", exitErr) + } else { + // We can use wsC.UnsubscribeAll(), but let us show the ID-based unsubscriptions: + err = wsC.Unsubscribe(bSubID) + check(err, "unsubscribe from blocks") + err = wsC.Unsubscribe(ntfSubID) + check(err, "unsubscribe from execution notifications") + wsC.Unsubscribe(aerSubId) + check(err, "unsubscribe from application execution results") + } + cancel() + <-dispatcherToMainCh // Wait for the dispatcher routine to properly finish. + + wsC.Close() + err = wsC.GetError() // Any error if the closing process wasn't initiated by user via wsC.Close(). + if err != nil { + fmt.Printf("WS RPC client closing error: %s\n", err) + } + + // Invoker functionality: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker + ctx, cancel = context.WithCancel(context.Background()) + wsC, err = rpcclient.NewWS(ctx, wsEndpoint, rpcclient.WSOptions{}) + check(err, "create WS client") + + signers := []transaction.Signer{ + { + Account: acc.ScriptHash(), + Scopes: transaction.CalledByEntry, + }, + } + inv := invoker.New(wsC, signers) + + // Test invocation of method "transfer" of the GAS contract. + var ( + from = acc.ScriptHash() + to = random.Uint160() + amount = 5 + data = smartcontract.Parameter{Type: smartcontract.AnyType} + ) + res, err := inv.Call(gasState.Hash, "transfer", from, to, amount, data) + ok, err := unwrap.Bool(res, err) + check(err, "perform `transfer` testinvoke") + fmt.Printf("`transfer` result: %t\n", ok) + + // Historic invocation functionality: https://github.com/nspcc-dev/neo-go/blob/master/docs/rpc.md#invokecontractverifyhistoric-invokefunctionhistoric-and-invokescripthistoric-calls + invH := invoker.NewHistoricAtHeight(transferB.Index-1, wsC, signers) + resH, err := invH.Call(gasState.Hash, "transfer", from, to, amount, data) + ok, err = unwrap.Bool(resH, err) + check(err, "invoke historic `transfer`") + fmt.Printf("`transfer` historic result: %t\n", ok) + + // Painful manual events unwrapping... + var tEvent nep17.TransferEvent + arr := res.Notifications[0].Item.Value().([]stackitem.Item) + fromB, _ := arr[0].TryBytes() + tEvent.From, _ = util.Uint160DecodeBytesBE(fromB) + toB, _ := arr[1].TryBytes() + tEvent.To, _ = util.Uint160DecodeBytesBE(toB) + tEvent.Amount, _ = arr[2].TryInteger() + + // A set of other invoker methods: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker + + // Actor functionality: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient/actor + actSigners := []actor.SignerAccount{ + { + Signer: signers[0], + Account: acc, // Provide the decrypted account if possible. It can be signture/multisignature/contract/dummy. + }, + } + act, err := actor.New(wsC, actSigners) + check(err, "create actor") + + aer, err := act.Wait(act.SendCall(gasState.Hash, "transfer", from, to, amount, data)) + check(err, "send `transfer` call via actor") + if aer.VMState != vmstate.Halt { + panic("unexpected `transfer` result") + } + + aer, err = act.Wait(act.SendTunedCall(gasState.Hash, "transfer", []transaction.Attribute{}, func(r *result.Invoke, t *transaction.Transaction) error { + err := actor.DefaultCheckerModifier(r, t) + if err != nil { + return err + } + + // Perform some additional checks... + if len(r.Stack) != 1 { + return fmt.Errorf("unexpected result stack len: %d", len(r.Stack)) + } + ok, err := r.Stack[0].TryBool() + if err != nil { + return fmt.Errorf("unexpected result stack content: %s", r.Stack[0].Type()) + } + if !ok { + return errors.New("false `transfer` result") + } + + // Change the transaction... + t.NetworkFee = r.GasConsumed + 1 + + return nil + }, from, to, amount, data)) + check(err, "send `transfer` tuned call via actor") + if aer.VMState != vmstate.Halt { + panic("unexpected `transfer` tuned result") + } + + // A set of other Actor methods: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient/actor + + // Customizable Actor. + + // NEP17 package: https://pkg.go.dev/github.com/nspcc-dev/neo-go/pkg/rpcclient/nep17 + nep17Act := nep17.New(act, gasState.Hash) + + d, err := nep17Act.Decimals() + check(err, "retrieve GAS decimals via NEP17 actor") + fmt.Printf("GAS decimals: %d\n", d) + + aer, err = act.Wait(nep17Act.MultiTransfer([]nep17.TransferParameters{ + { + From: from, + To: from, + Amount: big.NewInt(5), + Data: nil, + }, + { + From: from, + To: to, + Amount: big.NewInt(5), + Data: nil, + }, + })) + check(err, "GAS multitransfer") + applogTr, err := wsC.GetApplicationLog(aer.Container, nil) + check(err, "retrieve applog for multitransfer") + transferEvents, err := nep17.TransferEventsFromApplicationLog(applogTr) + check(err, "retrieve events from multitransfer applog") + transferEventsBytes, _ := json.MarshalIndent(transferEvents, "", "\t") + fmt.Printf("GAS multitransfer events:\n%s\n", transferEventsBytes) + + // Native-specific actor packages: + gasAct := gas.New(act) + fromBalance, err := gasAct.BalanceOf(from) + check(err, "retrieve `acc` balance") + fmt.Printf("`acc` balance: %d\n", fromBalance) + + policyAct := policy.New(act) + feePerByte, err := policyAct.GetFeePerByte() + check(err, "retrieve FeePerByte") + fmt.Printf("FeePerByte value: %d", feePerByte) + + // ... + + // Contract deployment example: + + // TODO: deploy storage contract with iterator inside, put some values, show how iterator sessions work. + + // Iterator sessions: + + // Usage of RPC autogenerated wrappers: + + // TODO: generate wrappers for the same storage contract. +} + +func check(err error, msg string) { + if err != nil { + panic(fmt.Errorf("failed to %s: %w", msg, err)) + } +}