github.com/mavryk-network/mvgo@v1.19.9/rpc/run.go

// Copyright (c) 2020-2022 Blockwatch Data Inc.
// Author: alex@blockwatch.cc

package rpc

import (
	"bytes"
	"context"
	"encoding/hex"
	"fmt"

	"github.com/mavryk-network/mvgo/codec"
	"github.com/mavryk-network/mvgo/mavryk"
	"github.com/mavryk-network/mvgo/micheline"
	"github.com/mavryk-network/mvgo/signer"
)

const ExtraSafetyMargin int64 = 100 // used to adjust gas and storage estimations

var (
	// for reveal
	DefaultRevealLimits = mavryk.Limits{
		Fee:      1000,
		GasLimit: 1000,
	}
	// for transfers to mv1/2/3
	DefaultTransferLimitsEOA = mavryk.Limits{
		Fee:      1000,
		GasLimit: 1420, // 1820 when source is emptied
	}
	// for transfers to manager.tz
	DefaultTransferLimitsKT1 = mavryk.Limits{
		Fee:      1000,
		GasLimit: 2078,
	}
	// for delegation
	DefaultDelegationLimitsEOA = mavryk.Limits{
		Fee:      1000,
		GasLimit: 1000,
	}
	// for baker registration
	DefaultBakerRegistrationLimits = mavryk.Limits{
		Fee:      1000,
		GasLimit: 1000,
	}
	// for simulating contract calls and other operations
	// used when no explicit costs are set
	DefaultSimulationLimits = mavryk.Limits{
		GasLimit:     mavryk.DefaultParams.HardGasLimitPerOperation,
		StorageLimit: mavryk.DefaultParams.HardStorageLimitPerOperation,
	}
)

type CallOptions struct {
	Confirmations     int64          // number of confirmations to wait after broadcast
	MaxFee            int64          // max acceptable fee, optional (default = 0)
	TTL               int64          // max lifetime for operations in blocks
	IgnoreLimits      bool           // ignore simulated limits and use user-defined limits from op
	ExtraGasMargin    int64          // safety margin in case simulation underestimates future usage
	SimulationBlockID BlockID        // custom block id to simulate operation (default is head, use to select a past block)
	SimulationOffset  int64          // custom block offset for future block simulations
	Signer            signer.Signer  // optional signer interface to use for signing the transaction
	Sender            mavryk.Address // optional address to sign for (use when signer manages multiple addresses)
	Observer          *Observer      // optional custom block observer for waiting on confirmations
}

var DefaultOptions = CallOptions{
	Confirmations:    2,
	TTL:              mavryk.DefaultParams.MaxOperationsTTL - 2,
	MaxFee:           1_000_000,
	ExtraGasMargin:   ExtraSafetyMargin,
	SimulationOffset: 5, // use pessimistic value to prevent gas exhausted errors (node's default is 3)
}

func NewCallOptions() *CallOptions {
	o := DefaultOptions
	return &o
}

type RunOperationRequest struct {
	Operation *codec.Op          `json:"operation"`
	ChainId   mavryk.ChainIdHash `json:"chain_id"`
	Latency   int64              `json:"latency,omitempty"`
}

type RunViewRequest struct {
	Contract     mavryk.Address     `json:"contract"`
	Entrypoint   string             `json:"entrypoint,omitempty"`
	View         string             `json:"view,omitempty"`
	Input        micheline.Prim     `json:"input"`
	ChainId      mavryk.ChainIdHash `json:"chain_id"`
	Source       mavryk.Address     `json:"source"`
	Payer        mavryk.Address     `json:"payer"`
	Gas          mavryk.N           `json:"gas"`
	Mode         string             `json:"unparsing_mode"`          // "Readable" | "Optimized"
	UnlimitedGas bool               `json:"unlimited_gas,omitempty"` // view
	Now          string             `json:"now,omitempty"`           // view
}

type RunViewResponse struct {
	Data micheline.Prim `json:"data"`
}

type RunCodeRequest struct {
	ChainId    mavryk.ChainIdHash `json:"chain_id"`
	Script     micheline.Code     `json:"script"`
	Storage    micheline.Prim     `json:"storage"`
	Input      micheline.Prim     `json:"input"`
	Amount     mavryk.N           `json:"amount"`
	Balance    mavryk.N           `json:"balance"`
	Source     *mavryk.Address    `json:"source,omitempty"`
	Payer      *mavryk.Address    `json:"payer,omitempty"`
	Gas        *mavryk.N          `json:"gas,omitempty"`
	Entrypoint string             `json:"entrypoint,omitempty"`
}

// RunCodeResponse -
type RunCodeResponse struct {
	Operations      []Operation            `json:"operations"`
	Storage         micheline.Prim         `json:"storage"`
	BigmapDiff      micheline.BigmapEvents `json:"big_map_diff,omitempty"`
	LazyStorageDiff micheline.LazyEvents   `json:"lazy_storage_diff,omitempty"`
}

// Complete ensures an operation is compatible with the current source account's
// on-chain state. Sets branch for TTL control, replay counters, and reveals
// the sender's pubkey if not published yet.
func (c *Client) Complete(ctx context.Context, o *codec.Op, key mavryk.Key) error {
	needBranch := !o.Branch.IsValid()
	needCounter := o.NeedCounter()
	mayNeedReveal := len(o.Contents) > 0 && o.Contents[0].Kind() != mavryk.OpTypeReveal

	if !needBranch && !mayNeedReveal && !needCounter {
		return nil
	}

	// add branch for TTL control
	if needBranch {
		ofs := o.Params.MaxOperationsTTL - o.TTL
		hash, err := c.GetBlockHash(ctx, NewBlockOffset(Head, -ofs))
		if err != nil {
			return err
		}
		o.WithBranch(hash)
	}

	if needCounter || mayNeedReveal {
		// fetch current state
		state, err := c.GetContractExt(ctx, key.Address(), Head)
		if err != nil {
			return err
		}

		// add reveal if necessary
		if mayNeedReveal && !state.IsRevealed() {
			reveal := &codec.Reveal{
				Manager: codec.Manager{
					Source: key.Address(),
				},
				PublicKey: key,
			}
			reveal.WithLimits(DefaultRevealLimits)
			o.WithContentsFront(reveal)
			needCounter = true
		}

		// add counters
		if needCounter {
			nextCounter := state.Counter + 1
			for _, op := range o.Contents {
				// skip non-manager ops
				if op.GetCounter() < 0 {
					continue
				}
				op.WithCounter(nextCounter)
				nextCounter++
			}
		}
	}
	return nil
}

// Simulate dry-runs the execution of the operation against the current state
// of a Tezos node in order to estimate execution costs and fees (fee/burn/gas/storage).
func (c *Client) Simulate(ctx context.Context, o *codec.Op, opts *CallOptions) (*Receipt, error) {
	sim := &codec.Op{
		Branch:    o.Branch,
		Contents:  o.Contents,
		Signature: mavryk.ZeroSignature,
		TTL:       o.TTL,
		Params:    c.Params,
	}

	if opts == nil {
		opts = &DefaultOptions
	}

	if sim.TTL == 0 && opts != nil {
		sim.TTL = opts.TTL
	}

	if !sim.Branch.IsValid() {
		ofs := o.Params.MaxOperationsTTL - sim.TTL
		hash, err := c.GetBlockHash(ctx, NewBlockOffset(Head, -ofs))
		if err != nil {
			return nil, err
		}
		sim.Branch = hash
	}

	if !opts.IgnoreLimits {
		// use default gas/storage limits, set min fee
		for _, op := range o.Contents {
			l := op.Limits()
			if l.GasLimit == 0 {
				l.GasLimit = DefaultSimulationLimits.GasLimit / int64(len(o.Contents))
			}
			if l.StorageLimit == 0 {
				l.StorageLimit = DefaultSimulationLimits.StorageLimit / int64(len(o.Contents))
			}
			op.WithLimits(l)
		}
	}

	req := RunOperationRequest{
		Operation: sim,
		ChainId:   c.ChainId,
	}
	var err error
	resp := &Operation{}

	// select simulation method based on requested block
	if opts.SimulationBlockID != nil {
		// simulate in the past
		err = c.RunOperation(ctx, opts.SimulationBlockID, req, resp)
	} else {
		// simulate in the future
		req.Latency = opts.SimulationOffset
		err = c.SimulateOperation(ctx, Head, req, resp)
	}
	if err != nil {
		return nil, err
	}

	// TODO: adjust min fee using known gas units before return so that res.Cost()
	// reflects the entire cost that Send() will pay
	rcpt := &Receipt{
		Op: resp,
	}

	// fail with Tezos error when simulation failed
	if !rcpt.IsSuccess() {
		return rcpt, rcpt.Error()
	}
	return rcpt, nil
}

// Validate compares local serializiation against remote RPC serialization of the
// operation and returns an error on mismatch.
func (c *Client) Validate(ctx context.Context, o *codec.Op) error {
	op := &codec.Op{
		Branch:   o.Branch,
		Contents: o.Contents,
	}
	local := op.Bytes()
	var remote mavryk.HexBytes
	if err := c.ForgeOperation(ctx, Head, op, &remote); err != nil {
		return err
	}
	if !bytes.Equal(local, remote.Bytes()) {
		return fmt.Errorf("tezos: mismatch between local and remote serialized operations:\n local=%s\n remote=%s",
			hex.EncodeToString(local), hex.EncodeToString(remote))
	}
	return nil
}

// Broadcast sends the signed operation to network and returns the operation hash
// on successful pre-validation.
func (c *Client) Broadcast(ctx context.Context, o *codec.Op) (mavryk.OpHash, error) {
	return c.BroadcastOperation(ctx, o.Bytes())
}

// Send is a convenience wrapper for sending operations. It auto-completes gas and storage limit,
// ensures minimum fees are set, protects against fee overpayment, signs and broadcasts the final
// operation and waits for a defined number of confirmations.
func (c *Client) Send(ctx context.Context, op *codec.Op, opts *CallOptions) (*Receipt, error) {
	if opts == nil {
		opts = &DefaultOptions
	}

	signer := c.Signer
	if opts.Signer != nil {
		signer = opts.Signer
	}

	// identify the sender address for signing the message
	addr := opts.Sender
	if !addr.IsValid() {
		addrs, err := signer.ListAddresses(ctx)
		if err != nil {
			return nil, err
		}
		addr = addrs[0]
	}

	key, err := signer.GetKey(ctx, addr)
	if err != nil {
		return nil, err
	}

	// use custom observer when provided
	mon := c.BlockObserver
	if opts.Observer != nil {
		mon = opts.Observer
	}

	// ensure block observer is running
	mon.Listen(c)

	// set source and params on all ops
	op.WithSource(key.Address()).WithParams(c.Params)

	// auto-complete op with branch/ttl, source counter, reveal
	err = c.Complete(ctx, op, key)
	if err != nil {
		return nil, err
	}

	// simulate to check tx validity and estimate cost
	sim, err := c.Simulate(ctx, op, opts)
	if err != nil {
		return nil, err
	}

	// fail with Tezos error when simulation failed
	if !sim.IsSuccess() {
		return nil, sim.Error()
	}

	// apply simulated cost as limits to tx list
	if !opts.IgnoreLimits {
		op.WithLimits(sim.MinLimits(), opts.ExtraGasMargin)
	}

	// log info about tx costs
	c.logDebug(func() {
		costs := sim.Costs()
		for i, v := range op.Contents {
			verb := "used"
			if opts.IgnoreLimits {
				verb = "forced"
			}
			limits := v.Limits()
			c.Log.Debugf("OP#%03d: %s gas_used(sim)=%d storage_used(sim)=%d storage_burn(sim)=%d alloc_burn(sim)=%d fee(%s)=%d gas_limit(%s)=%d storage_limit(%s)=%d ",
				i, v.Kind(), costs[i].GasUsed, costs[i].StorageUsed, costs[i].StorageBurn, costs[i].AllocationBurn,
				verb, limits.Fee, verb, limits.GasLimit, verb, limits.StorageLimit,
			)
		}
	})

	// check minFee calc against maxFee if set
	if opts.MaxFee > 0 {
		if l := op.Limits(); l.Fee > opts.MaxFee {
			return nil, fmt.Errorf("estimated cost %d > max %d", l.Fee, opts.MaxFee)
		}
	}

	// sign digest
	sig, err := signer.SignOperation(ctx, addr, op)
	if err != nil {
		return nil, err
	}
	op.WithSignature(sig)

	// trace what we'll broadcast
	c.logTrace(func() {
		buf, _ := op.MarshalJSON()
		c.Log.Tracef("Broadcast: %s", string(buf))
	})

	// broadcast
	hash, err := c.Broadcast(ctx, op)
	if err != nil {
		return nil, err
	}

	// wait for confirmations
	res := NewResult(hash).WithTTL(op.TTL).WithConfirmations(opts.Confirmations)

	// wait for confirmations
	res.Listen(mon)
	res.WaitContext(ctx)
	if err := res.Err(); err != nil {
		return nil, err
	}

	// return receipt
	return res.GetReceipt(ctx)
}

// RunOperation simulates executing an operation without requiring a valid signature.
// The call returns the execution result as regular operation receipt.
func (c *Client) RunOperation(ctx context.Context, id BlockID, body, resp interface{}) error {
	u := fmt.Sprintf("chains/main/blocks/%s/helpers/scripts/run_operation", id)
	return c.Post(ctx, u, body, resp)
}

// RunCode simulates executing of provided code on the context of a contract at selected block.
func (c *Client) RunCode(ctx context.Context, id BlockID, body, resp interface{}) error {
	u := fmt.Sprintf("chains/main/blocks/%s/helpers/scripts/run_code", id)
	return c.Post(ctx, u, body, resp)
}

// RunCallback simulates executing of TZip4 view on the context of a contract at selected block.
func (c *Client) RunCallback(ctx context.Context, id BlockID, body, resp interface{}) error {
	u := fmt.Sprintf("chains/main/blocks/%s/helpers/scripts/run_view", id)
	return c.Post(ctx, u, body, resp)
}

// RunView simulates executing of on on-chain view on the context of a contract at selected block.
func (c *Client) RunView(ctx context.Context, id BlockID, body, resp interface{}) error {
	u := fmt.Sprintf("chains/main/blocks/%s/helpers/scripts/run_script_view", id)
	return c.Post(ctx, u, body, resp)
}

// TraceCode simulates executing of code on the context of a contract at selected block and
// returns a full execution trace.
func (c *Client) TraceCode(ctx context.Context, id BlockID, body, resp interface{}) error {
	u := fmt.Sprintf("chains/main/blocks/%s/helpers/scripts/trace_code", id)
	return c.Post(ctx, u, body, resp)
}

// BroadcastOperation sends a signed operation to the network (injection).
// The call returns the operation hash on success. If theoperation was rejected
// by the node error is of type RPCError.
func (c *Client) BroadcastOperation(ctx context.Context, body []byte) (hash mavryk.OpHash, err error) {
	err = c.Post(ctx, "injection/operation", hex.EncodeToString(body), &hash)
	return
}

// ForgeOperation uses a remote node to serialize an operation to its binary format.
// The result of this call SHOULD NEVER be used for signing the operation, it is only
// meant for validating the locally generated serialized output.
func (c *Client) ForgeOperation(ctx context.Context, id BlockID, body, resp interface{}) error {
	u := fmt.Sprintf("chains/main/blocks/%s/helpers/forge/operations", id)
	return c.Post(ctx, u, body, resp)
}

// SimulateOperation simulates executing an operation without requiring a valid signature.
// The call returns the execution result as regular operation receipt with estimated
// future gas usage.
//
// Note gas consumption may differ based on whether a contract is cached inside a node
// at the time of operation inclusion in a block. The contract cache is dynamic
// so under rare circumstances the simulation can underestimates real gas cost
// and a contract call may fail. In such cases attempt to resend the transaction with a
// higher gas margin (CallOptions.ExtraGasMargin > ExtraSafetyMargin).
//
// For simulation purposes a future cache state is predicted. You can control the
// future simulation point via RunOperationRequest.Latency (in blocks).
func (c *Client) SimulateOperation(ctx context.Context, id BlockID, body, resp interface{}) error {
	u := fmt.Sprintf("chains/main/blocks/%s/helpers/scripts/simulate_operation", id)
	return c.Post(ctx, u, body, resp)
}