overflow

package module
v1.26.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 3, 2024 License: MIT Imports: 56 Imported by: 5

README

Coverage Status ci

Overflow

This is the v1 branch of overflow to be used with v0.x versions of cadence. Go go main branch for latest version

A DSL written in golang to be used in tests or to run a story of interactions against either an local emulator, testnet, mainnet or an in memory instance of the flow-emulator.

Use case scenarios include:

  • demo purposes
  • integration testing of combinations of scripts/transactions
  • batch jobs.

For a standalone example on how overflow can be used look at https://github.com/bjartek/flow-nft-overflow it has both an interactive demo and unit tests for an example NFT contract.

Main features

  • Uses a shared golang builder pattern for almost all interactions.
  • Well documented source code
  • supports all variants of multi-sign, Two authorizers, proposer and payer can be different.
  • when refering to an account/address you can use the logical name for that stakeholder defined in flow json. the same stakeholder IE admin can have different addresses on each network
  • can be run in embedded in memory mode that will start emulator, deploy contracts, create stakeholders and run interactions (scripts/transactions) against this embedded system and then stop it when it ends.
  • has a DSL to fetch Events and optionally store progress in a file. This can be chained into indexers/crawlers/notification services.
  • all interactions can be specified inline as well as from files
  • transform all interactions into a NPM module that can be published for the frontend to use. this json file that is generate has the option to filter out certain interactions and to strip away network suffixes if you have multiple local interactions that should map to the same logical name in the client for each network
  • the interaction (script/tx) dsl has a rich set of assertions
  • arguments to interactions are all named that is the same name in that is in the argument must be used with the Arg("name", "value") builder. The value in this example can be either a primitive go value or a cadence.Value.
  • supports shared instance in test to collect coverage report and rollback after/before each test. See example folder.

Gotchas

  • When specifying extra accounts that are created on emulator they are created in alphabetical order, the addresses the emulator assign is always fixed.
  • tldr; Name your stakeholder accounts in alphabetical order, we suggest admin, bob, charlie, demi, eddie
  • When writing integration tests, tests must be in the same folder as flow.json with contracts and transactions/scripts in subdirectories in order for the path resolver to work correctly

Resources

Usage

First create a project directory, initialize the go module and install overflow:

mkdir test-overflow && cd test-overflow
flow init
go mod init example.com/test-overflow
go get github.com/bjartek/overflow

Then create a task file:

touch tasks/main.go

In that task file, you can then import overflow and use it to your convenience, for example:

package main

import (
    "fmt"

    //if you imports this with .  you do not have to repeat overflow everywhere 
    . "github.com/bjartek/overflow"
)

func main() {

	//start an in memory emulator by default
  // there are two interfaces published for Overflow, `OverflowClient` and `OverrflowBetaClient` that has unstable api, I urge you to store this as the client and not the impl. Currenly the Overflow method returns the impl so you can choose.
	o := Overflow()
	
	//the Tx DSL runs an transaction
	o.Tx("name_of_transaction", SignProposeAndPayAs("bob"), Arg("name", "bob")).Print()
	
	//Run a script/get interaction against the same in memory chain
	o.Script("name_of_script", Arg("name", "bob")).Print()
}

Then you can run

go run ./tasks/main.go

This is a minimal example that run a transction and a script, but from there you can branch out.

The following env vars are supported

  • OVERFLOW_ENV : set the environment to run against "emulator|embedded|testnet|mainnet|testing" (embedded is standard)
  • OVEFFLOW_CONTINUE: if you do not want overflow to deploy contracts and accounts on emulator you can set this to true
  • OVERFLOW_LOGGING: Set this to 0-4 to get increasing log

Migrating from v0 api

Please note the following if you migrate from an earlier version of overflow that was not tagged

  • "github.com/bjartek/overflow/overflow" -> "github.com/bjartek/overflow"
  • overflow.Overflow -> overflow.OverflowState
  • on OverflowState Script -> InlineScript
  • FlowTransationBuilder -> OverflowInteractionBuilder
  • FlowArgumentsBuilder -> OverflowArgumentsBuilder
  • Discord dependency is gone, if you need the code ask
  • almost all of the v0 is deprecated in favor of the functional builders Overflow to set up the client and , Tx, Script, FetchEvents to interact with it

Credits

This project is the successor of https://github.com/bjartek/go-with-the-flow The v0 version of the code with a set of apis that is now deprecated is in https://github.com/bjartek/overflow/tree/v0

Documentation

Overview

Overflow is a DSL to help interact with the flow blockchain using go

By bjartek aka Bjarte Karlsen

Example 
// in order to start overflow use the Overflow function
// it can be customized with lots of OverflowOption
Overflow()

Output:

🧑 Created account: emulator-first with address: 01cf0e2f2f715450 with flow: 10.00
🧑 Created account: emulator-second with address: 179b6b1cb6755e31 with flow: 10.00
📜 deploy contracts NonFungibleToken, Debug, MetadataViews

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func CadenceValueToInterface 

func CadenceValueToInterface(field cadence.Value) interface{}

CadenceValueToInterface convert a candence.Value into interface{}

func CadenceValueToJsonString 

func CadenceValueToJsonString(value cadence.Value) (string, error)

CadenceValueToJsonString converts a cadence.Value into a json pretty printed string

func ExtractAddresses 

func ExtractAddresses(field cadence.Value) []string

func InputToCadence 

func InputToCadence(v interface{}, resolver InputResolver) (cadence.Value, error)

func ReflectToCadence 

func ReflectToCadence(value reflect.Value, resolver InputResolver) (cadence.Value, error)

Types

type Argument 

type Argument struct {
	Key   string
	Value interface{}
}

type BlockResult 

type BlockResult struct {
	Transactions      []OverflowTransaction
	SystemChunkEvents OverflowEvents
	Block             flow.Block
	Error             error
	Logger            *zap.Logger
	// until we have view in flow.Block we add this here
	View      uint64
	StartTime time.Time
}

type CadenceArguments 

type CadenceArguments map[string]cadence.Value

type EmbedWrapper 

type EmbedWrapper struct {
	Embed embed.FS
}

func (*EmbedWrapper) MkdirAll added in v1.16.0 

func (ew *EmbedWrapper) MkdirAll(path string, perm os.FileMode) error

func (*EmbedWrapper) ReadFile 

func (ew *EmbedWrapper) ReadFile(source string) ([]byte, error)

func (*EmbedWrapper) Stat added in v1.20.0 

func (ew *EmbedWrapper) Stat(string) (fs.FileInfo, error)

func (*EmbedWrapper) WriteFile 

func (ew *EmbedWrapper) WriteFile(filename string, data []byte, perm os.FileMode) error

type EventFetcherResult 

type EventFetcherResult struct {
	Events                []OverflowPastEvent
	Error                 error
	State                 *OverflowEventFetcherBuilder
	From                  int64
	To                    uint64
	ProgressWriteFunction ProgressWriterFunction
}

func (EventFetcherResult) String 

func (efr EventFetcherResult) String() string

type FilterFunction 

type FilterFunction func(OverflowTransaction) bool

type Import 

type Import struct {
	Address string
	Name    string
}

func GetAddressImports 

func GetAddressImports(code []byte) ([]Import, error)

func (Import) Identifier 

func (i Import) Identifier() string

type InMemoryProgressKeeper 

type InMemoryProgressKeeper struct {
	Progress int64
}

func (*InMemoryProgressKeeper) ReadProgress 

func (self *InMemoryProgressKeeper) ReadProgress() (int64, error)

func (*InMemoryProgressKeeper) WriteProgress 

func (self *InMemoryProgressKeeper) WriteProgress(progress int64) error

type InputResolver 

type InputResolver func(string) (string, error)

a resolver to resolve a input type into a name, can be used to resolve struct names for instance

type MetadataViews_Display_Http 

type MetadataViews_Display_Http struct {
	Name        string
	Description string
	Thumbnail   MetadataViews_HTTPFile
}

type MetadataViews_Display_IPFS 

type MetadataViews_Display_IPFS struct {
	Name        string
	Description string
	Thumbnail   MetadataViews_IPFSFile
}

type MetadataViews_Edition 

type MetadataViews_Edition struct {
	Name   *string
	Number uint64
	Max    *uint64
}

type MetadataViews_Editions 

type MetadataViews_Editions struct {
	Editions []MetadataViews_Edition `cadence:"infoList"`
}

type MetadataViews_ExternalURL 

type MetadataViews_ExternalURL struct {
	Url string
}

type MetadataViews_HTTPFile 

type MetadataViews_HTTPFile struct {
	Url string
}

type MetadataViews_IPFSFile 

type MetadataViews_IPFSFile struct {
	Cid  string
	Path *string
}

type MetadataViews_Media_HTTP 

type MetadataViews_Media_HTTP struct {
	File      MetadataViews_HTTPFile
	MediaType string `cadence:"mediaType"`
}

type MetadataViews_Media_IPFS 

type MetadataViews_Media_IPFS struct {
	File      MetadataViews_IPFSFile
	MediaType string `cadence:"mediaType"`
}

type MetadataViews_Rarity 

type MetadataViews_Rarity struct {
	Score       *string
	Max         *uint64
	Description *string
}

type MetadataViews_Serial 

type MetadataViews_Serial struct {
	Number uint64
}

type MetadataViews_Trait 

type MetadataViews_Trait struct {
	Name        string
	Value       interface{}
	DisplayType string `cadence:"displayType"`
	Rarity      *MetadataViews_Rarity
}

type MetadataViews_Traits 

type MetadataViews_Traits struct {
	Traits []MetadataViews_Trait
}

type MetadtaViews_Licensce 

type MetadtaViews_Licensce struct {
	Spdx string `cadence:"spdxIdentifier"`
}

type OverflowArgument 

type OverflowArgument struct {
	Name  string
	Value interface{}
	Type  ast.Type
}

type OverflowArgumentList 

type OverflowArgumentList []OverflowArgument

type OverflowArguments 

type OverflowArguments map[string]OverflowArgument

type OverflowBetaClient 

type OverflowBetaClient interface {
	OverflowClient
	GetTransactionById(ctx context.Context, id flow.Identifier) (*flow.Transaction, error)
	GetOverflowTransactionById(ctx context.Context, id flow.Identifier) (*OverflowTransaction, error)
	GetTransactions(ctx context.Context, id flow.Identifier, logg *zap.Logger) ([]OverflowTransaction, OverflowEvents, error)
	StreamTransactions(ctx context.Context, poll time.Duration, height uint64, logger *zap.Logger, channel chan<- BlockResult) error
	GetBlockResult(ctx context.Context, height uint64, logger *zap.Logger) (*BlockResult, error)
}

beta client with unstable features

type OverflowBuilder 

type OverflowBuilder struct {
	Ctx                                 context.Context
	TransactionFees                     bool
	Network                             string
	InMemory                            bool
	DeployContracts                     bool
	GasLimit                            int
	Path                                string
	NetworkHost                         string
	LogLevel                            int
	InitializeAccounts                  bool
	PrependNetworkName                  bool
	ServiceSuffix                       string
	ConfigFiles                         []string
	TransactionFolderName               string
	ScriptFolderName                    string
	FilterOutFeeEvents                  bool
	FilterOutEmptyWithDrawDepositEvents bool
	GlobalEventFilter                   OverflowEventFilter
	StopOnError                         bool
	PrintOptions                        *[]OverflowPrinterOption
	NewAccountFlowAmount                float64
	ReaderWriter                        flowkit.ReaderWriter
	InputResolver                       *InputResolver
	ArchiveNodeUrl                      string
	Coverage                            *runtime.CoverageReport
	GrpcDialOptions                     []grpc.DialOption
	EmulatorOptions                     []emulator.Option
}

OverflowBuilder is the struct used to gather up configuration when building an overflow instance

func (*OverflowBuilder) StartE 

func (o *OverflowBuilder) StartE() (*OverflowState, error)

func (*OverflowBuilder) StartResult 

func (o *OverflowBuilder) StartResult() *OverflowState

StartE will start Overflow and return State and error if any

type OverflowClient 

type OverflowClient interface {
	ScriptFN(outerOpts ...OverflowInteractionOption) OverflowScriptFunction
	ScriptFileNameFN(filename string, outerOpts ...OverflowInteractionOption) OverflowScriptOptsFunction
	Script(filename string, opts ...OverflowInteractionOption) *OverflowScriptResult

	QualifiedIdentifierFromSnakeCase(typeName string) (string, error)
	QualifiedIdentifier(contract string, name string) (string, error)

	AddContract(ctx context.Context, name string, code []byte, args []cadence.Value, filename string, update bool) error

	GetNetwork() string
	AccountE(key string) (*accounts.Account, error)
	Address(key string) string
	Account(key string) *accounts.Account

	AccountPublicKey(name string) (string, error)

	// Note that this returns a flow account and not a flowkit account like the others, is this needed?
	GetAccount(ctx context.Context, key string) (*flow.Account, error)

	Tx(filename string, opts ...OverflowInteractionOption) *OverflowResult
	TxFN(outerOpts ...OverflowInteractionOption) OverflowTransactionFunction
	TxFileNameFN(filename string, outerOpts ...OverflowInteractionOption) OverflowTransactionOptsFunction

	GetLatestBlock(ctx context.Context) (*flow.Block, error)
	GetBlockAtHeight(ctx context.Context, height uint64) (*flow.Block, error)
	GetBlockById(ctx context.Context, blockId string) (*flow.Block, error)
	FetchEventsWithResult(opts ...OverflowEventFetcherOption) EventFetcherResult

	UploadFile(filename string, accountName string) error
	DownloadAndUploadFile(url string, accountName string) error
	DownloadImageAndUploadAsDataUrl(url, accountName string) error
	UploadImageAsDataUrl(filename string, accountName string) error
	UploadString(content string, accountName string) error
	GetFreeCapacity(accountName string) int
	MintFlowTokens(accountName string, amount float64) *OverflowState
	FillUpStorage(accountName string) *OverflowState

	SignUserMessage(account string, message string) (string, error)
}

Overflow client is an interface with the most used v1 api methods for overflow

type OverflowCodeWithSpec 

type OverflowCodeWithSpec struct {
	Code string                   `json:"code"`
	Spec *OverflowDeclarationInfo `json:"spec"`
}

representing code with specification if parameters

type OverflowDeclarationInfo 

type OverflowDeclarationInfo struct {
	ParameterOrder []string          `json:"order"`
	Parameters     map[string]string `json:"parameters"`
}

a type containing information about parameter types and orders

type OverflowEmulatorLogMessage 

type OverflowEmulatorLogMessage struct {
	ComputationUsed int
	Level           string
	Msg             string
	Fields          map[string]interface{}
}

OverflowEmulatorLogMessage a log message from the logrus implementation used in the flow emulator

func (OverflowEmulatorLogMessage) String 

func (me OverflowEmulatorLogMessage) String() string

type OverflowEvent 

type OverflowEvent struct {
	Id            string                 `json:"id"`
	Fields        map[string]interface{} `json:"fields"`
	TransactionId string                 `json:"transactionID"`
	EventIndex    uint32                 `json:"eventIndex"`
	Name          string                 `json:"name"`
	Addresses     map[string][]string    `json:"addresses"`
}

func (OverflowEvent) ExistIn 

func (o OverflowEvent) ExistIn(events []OverflowEvent) bool

Check if an event exist in the other events

func (OverflowEvent) GetStakeholders 

func (me OverflowEvent) GetStakeholders() map[string][]string

list of address to a list of roles for that address

func (OverflowEvent) MarshalAs 

func (e OverflowEvent) MarshalAs(marshalTo interface{}) error

type OverflowEventFetcherBuilder 

type OverflowEventFetcherBuilder struct {
	Ctx                   context.Context
	OverflowState         *OverflowState
	EventsAndIgnoreFields OverflowEventFilter
	FromIndex             int64
	EndAtCurrentHeight    bool
	EndIndex              uint64
	ProgressFile          string
	ProgressRW            ProgressReaderWriter
	NumberOfWorkers       int
	EventBatchSize        uint64
	ReturnWriterFunction  bool
}

OverflowEventFetcherBuilder builder to hold info about eventhook context.

type OverflowEventFetcherOption 

type OverflowEventFetcherOption func(*OverflowEventFetcherBuilder)

Event fetching

A function to customize the transaction builder

func WithBatchSize 

func WithBatchSize(size uint64) OverflowEventFetcherOption

Set the batch size for FetchEvents

func WithEndIndex 

func WithEndIndex(blockHeight uint64) OverflowEventFetcherOption

set the end index to use

func WithEvent 

func WithEvent(eventName string) OverflowEventFetcherOption

set that we want to fetch an event and all its fields

func WithEventFetcherContext 

func WithEventFetcherContext(ctx context.Context) OverflowEventFetcherOption

Set the Workers size for FetchEvents

func WithEventIgnoringField 

func WithEventIgnoringField(eventName string, ignoreFields []string) OverflowEventFetcherOption

set that we want the following events and ignoring the fields mentioned

func WithFromIndex 

func WithFromIndex(blockHeight int64) OverflowEventFetcherOption

set the from index to use alias to WithStartHeight

func WithLastBlocks 

func WithLastBlocks(number uint64) OverflowEventFetcherOption

set the relative list of blocks to fetch events from

func WithReturnProgressWriter 

func WithReturnProgressWriter() OverflowEventFetcherOption

track what block we have read since last run in a file

func WithStartHeight 

func WithStartHeight(blockHeight int64) OverflowEventFetcherOption

set the start height to use

func WithTrackProgress 

func WithTrackProgress(progressReaderWriter ProgressReaderWriter) OverflowEventFetcherOption

track what block we have read since last run in a file

func WithTrackProgressIn 

func WithTrackProgressIn(fileName string) OverflowEventFetcherOption

track what block we have read since last run in a file

func WithUntilBlock 

func WithUntilBlock(blockHeight uint64) OverflowEventFetcherOption

fetch events until theg given height alias to WithEndHeight

func WithUntilCurrentBlock 

func WithUntilCurrentBlock() OverflowEventFetcherOption

set the end index to the current height

func WithWorkers 

func WithWorkers(workers int) OverflowEventFetcherOption

Set the Workers size for FetchEvents

type OverflowEventFilter 

type OverflowEventFilter map[string][]string

Event parsing

a type alias to an OverflowEventFilter to filter out all events with a given suffix and the fields with given suffixes

type OverflowEventList 

type OverflowEventList []OverflowEvent

func (OverflowEventList) MarshalAs 

func (e OverflowEventList) MarshalAs(marshalTo interface{}) error

type OverflowEvents 

type OverflowEvents map[string]OverflowEventList

a type holding all events that are emitted from a Transaction

func (OverflowEvents) FilterEvents 

func (overflowEvents OverflowEvents) FilterEvents(ignoreFields OverflowEventFilter) OverflowEvents

Filter out events given the sent in filter

func (OverflowEvents) FilterFees 

func (overflowEvents OverflowEvents) FilterFees(fee float64, payer string) OverflowEvents

Filtter out fee events

func (OverflowEvents) FilterTempWithdrawDeposit 

func (overflowEvents OverflowEvents) FilterTempWithdrawDeposit() OverflowEvents

Filter out temp withdraw deposit events

func (OverflowEvents) GetStakeholders 

func (me OverflowEvents) GetStakeholders(stakeholders map[string][]string) map[string][]string

func (OverflowEvents) Print 

func (overflowEvents OverflowEvents) Print(t *testing.T)

type OverflowGraffleEvent 

type OverflowGraffleEvent struct {
	EventDate         time.Time              `json:"eventDate"`
	FlowEventID       string                 `json:"flowEventId"`
	FlowTransactionID string                 `json:"flowTransactionId"`
	ID                string                 `json:"id"`
	BlockEventData    map[string]interface{} `json:"blockEventData"`
}

func (OverflowGraffleEvent) MarshalAs 

func (e OverflowGraffleEvent) MarshalAs(marshalTo interface{}) error

type OverflowInteractionBuilder 

type OverflowInteractionBuilder struct {
	Ctx context.Context
	//the name of the integration, for inline variants
	Name string

	//force that this interaction will not print log, even if overflow state has specified it
	NoLog bool

	//The underlying state of overflow used to fetch some global settings
	Overflow *OverflowState

	//The file name of the interaction
	FileName string

	//The content of the interaction
	Content string

	//The list of raw arguments
	Arguments []cadence.Value

	NamedCadenceArguments CadenceArguments

	//The main signer used to sign the transaction
	// Payer: the account paying for the transaction fees.
	Payer *accounts.Account

	//The propser account
	//    Proposer: the account that specifies a proposal key.
	Proposer *accounts.Account

	//The payload signers that will sign the payload
	//Authorizers: zero or more accounts authorizing the transaction to mutate their state.
	PayloadSigners []*accounts.Account

	//The gas limit to set for this given interaction
	GasLimit uint64

	//The basepath on where to look for interactions
	BasePath string

	//An error object to store errors that arrive as you configure an interaction
	Error error

	//The code of the tranasction in bytes
	TransactionCode []byte

	//The named arguments
	NamedArgs map[string]interface{}

	//Event filters to apply to the interaction
	EventFilter OverflowEventFilter

	//Wheter to ignore global event filters from OverflowState or not
	IgnoreGlobalEventFilters bool

	//Options to use when printing results
	PrintOptions *[]OverflowPrinterOption

	//Query to use for running scripts
	ScriptQuery *flowkit.ScriptQuery

	//
	StopOnError *bool
}

OverflowInteractionBuilder used to create a builder pattern for an interaction

func (OverflowInteractionBuilder) Send 

func (oib OverflowInteractionBuilder) Send() *OverflowResult

Send a interaction builder as a Transaction returning an overflow result

type OverflowInteractionOption 

type OverflowInteractionOption func(*OverflowInteractionBuilder)

A function to customize the transaction builder

func WithAddresses 

func WithAddresses(name string, value ...string) OverflowInteractionOption

Send in an array of addresses as an argument

func WithArg 

func WithArg(name string, value interface{}) OverflowInteractionOption

Send an argument into a transaction

The value is treated in the given way depending on type - cadence.Value is sent as straight argument - string argument are resolved into cadence.Value using flowkit - ofther values are converted to string with %v and resolved into cadence.Value using flowkit - if the type of the parameter is Address and the string you send in is a valid account in flow.json it will resolve

func WithArgDateTime 

func WithArgDateTime(name string, dateString string, timezone string) OverflowInteractionOption

sending in a timestamp as an arg is quite complicated, use this method with the name of the arg, the datestring and the given timezone to parse it at

func WithArgs 

func WithArgs(args ...interface{}) OverflowInteractionOption

set a list of args as key, value in an interaction, see Arg for options you can pass in

func WithArgsMap 

func WithArgsMap(args map[string]interface{}) OverflowInteractionOption

set arguments to the interaction from a map. See Arg for options on what you can pass in

func WithAuthorizer added in v1.14.0 

func WithAuthorizer(signer ...string) OverflowInteractionOption

func WithContext 

func WithContext(ctx context.Context) OverflowInteractionOption

func WithEventsFilter 

func WithEventsFilter(filter OverflowEventFilter) OverflowInteractionOption

set a filter for events

func WithExecuteScriptAtBlockHeight 

func WithExecuteScriptAtBlockHeight(height uint64) OverflowInteractionOption

set what block height to execute a script at! NB! if very old will not work on normal AN

func WithExecuteScriptAtBlockIdHex 

func WithExecuteScriptAtBlockIdHex(blockId string) OverflowInteractionOption

set what block height to execute a script at! NB! if very old will not work on normal AN

func WithExecuteScriptAtBlockIdentifier 

func WithExecuteScriptAtBlockIdentifier(blockId flow.Identifier) OverflowInteractionOption

set what block height to execute a script at! NB! if very old will not work on normal AN

func WithManualAuthorizer added in v1.14.0 

func WithManualAuthorizer(signer ...*accounts.Account) OverflowInteractionOption

alias for adding manual payload signers

func WithManualPayloadSigner added in v1.14.0 

func WithManualPayloadSigner(signer ...*accounts.Account) OverflowInteractionOption

set an aditional authorizer that will sign the payload

func WithManualProposer added in v1.14.0 

func WithManualProposer(account *accounts.Account) OverflowInteractionOption

set payer, proposer authorizer as the signer

func WithManualSigner added in v1.14.0 

func WithManualSigner(account *accounts.Account) OverflowInteractionOption

set payer, proposer authorizer as the signer

func WithMaxGas 

func WithMaxGas(gas uint64) OverflowInteractionOption

set the gas limit

func WithName 

func WithName(name string) OverflowInteractionOption

set the name of this interaction, for inline interactions this will be the entire name for file interactions they will be combined

func WithPanicInteractionOnError 

func WithPanicInteractionOnError(stop bool) OverflowInteractionOption

func WithPayloadSigner 

func WithPayloadSigner(signer ...string) OverflowInteractionOption

set an aditional authorizer that will sign the payload

func WithPrintOptions 

func WithPrintOptions(opts ...OverflowPrinterOption) OverflowInteractionOption

print interactions using the following options

func WithProposer 

func WithProposer(proposer string) OverflowInteractionOption

set the proposer

func WithProposerServiceAccount 

func WithProposerServiceAccount() OverflowInteractionOption

set the propser to be the service account

func WithSigner 

func WithSigner(signer string) OverflowInteractionOption

set payer, proposer authorizer as the signer

func WithSignerServiceAccount 

func WithSignerServiceAccount() OverflowInteractionOption

set service account as payer, proposer, authorizer

func WithStructArgCustomResolver 

func WithStructArgCustomResolver(name string, resolver InputResolver, value interface{}) OverflowInteractionOption

use the `cadence` struct tag to name a field or it will be given the lowercase name of the field

func WithStructArgsCustomQualifier 

func WithStructArgsCustomQualifier(name string, resolver InputResolver, values ...interface{}) OverflowInteractionOption

use the `cadence` struct tag to name a field or it will be given the lowercase name of the field

func WithoutGlobalEventFilter 

func WithoutGlobalEventFilter() OverflowInteractionOption

ignore global events filters defined on OverflowState

func WithoutLog 

func WithoutLog() OverflowInteractionOption

force no printing for this interaction

type OverflowMeter 

type OverflowMeter struct {
	LedgerInteractionUsed  int                                   `json:"ledgerInteractionUsed"`
	ComputationUsed        int                                   `json:"computationUsed"`
	MemoryUsed             int                                   `json:"memoryUsed"`
	ComputationIntensities OverflowMeteredComputationIntensities `json:"computationIntensities"`
	MemoryIntensities      OverflowMeteredMemoryIntensities      `json:"memoryIntensities"`
}

a type representing a meter that contains information about the inner workings of an interaction, only available on local emulator

func (OverflowMeter) FunctionInvocations 

func (m OverflowMeter) FunctionInvocations() int

get the number of functions invocations

func (OverflowMeter) Loops 

func (m OverflowMeter) Loops() int

get the number of loops

func (OverflowMeter) Statements 

func (m OverflowMeter) Statements() int

get the number of statements

type OverflowMeteredComputationIntensities 

type OverflowMeteredComputationIntensities map[common.ComputationKind]uint

type collecting computatationIntensities

type OverflowMeteredMemoryIntensities 

type OverflowMeteredMemoryIntensities map[common.MemoryKind]uint

type collecting memoryIntensities

type OverflowOption 

type OverflowOption func(*OverflowBuilder)

OverflowOption and option function that you can send in to configure Overflow

func WithArchiveNodeUrl 

func WithArchiveNodeUrl(url string) OverflowOption

func WithBasePath 

func WithBasePath(path string) OverflowOption

WithBasePath will change the standard basepath `.` to another folder

func WithCoverageReport 

func WithCoverageReport() OverflowOption

func WithEmbedFS 

func WithEmbedFS(fs embed.FS) OverflowOption

func WithEmptyDepositWithdrawEvents 

func WithEmptyDepositWithdrawEvents() OverflowOption

filter out empty deposit and withdraw events

func WithEmulatorOption added in v1.22.0 

func WithEmulatorOption(opt ...emulator.Option) OverflowOption

func WithExistingEmulator 

func WithExistingEmulator() OverflowOption

WithExistingEmulator will attach to an existing emulator, not deploying contracts and creating accounts

func WithFeesEvents 

func WithFeesEvents() OverflowOption

WithTransactionFolderName will overwite the default script subdir for transactions `transactions`

func WithFlowConfig 

func WithFlowConfig(files ...string) OverflowOption

WithFlowConfig will set the path to one or more flow.json config files The default is ~/flow.json and ./flow.json.

func WithFlowForNewUsers 

func WithFlowForNewUsers(amount float64) OverflowOption

Set the amount of flow for new account, default is 0.001

func WithGas 

func WithGas(gas int) OverflowOption

WithGas set the default gas limit, standard is 9999 (max)

func WithGlobalEventFilter 

func WithGlobalEventFilter(filter OverflowEventFilter) OverflowOption

set global filters to events

func WithGlobalPrintOptions 

func WithGlobalPrintOptions(opts ...OverflowPrinterOption) OverflowOption

automatically print interactions using the following options

func WithGrpcDialOption added in v1.22.0 

func WithGrpcDialOption(opt ...grpc.DialOption) OverflowOption

func WithInputResolver 

func WithInputResolver(ir InputResolver) OverflowOption

func WithLogFull 

func WithLogFull() OverflowOption

func WithLogInfo 

func WithLogInfo() OverflowOption

func WithLogNone 

func WithLogNone() OverflowOption

WithNoLog will not log anything from results or flowkit logger

func WithNetwork 

func WithNetwork(network string) OverflowOption

WithNetwork will start overflow with the given network. This function will also set up other options that are common for a given Network. embedded: starts in memory, will deploy contracts and create accounts, will panic on errors and show terse output testing: as embedeed, but will not stop on errors and turn off all logs emulator: will connect to running local emulator, deploy contracts and create account testnet|mainnet: will only set network, not deploy contracts or create accounts

func WithNetworkNost added in v1.24.2 

func WithNetworkNost(host string) OverflowOption

Set custom network host if different from the one in flow.json since we cannot env substs there

func WithNoPrefixToAccountNames 

func WithNoPrefixToAccountNames() OverflowOption

DoNotPrependNetworkToAccountNames will not prepend the name of the network to account names

func WithPanicOnError 

func WithPanicOnError() OverflowOption

If this option is used a panic will be called if an error occurs after an interaction is run

func WithPrintResults 

func WithPrintResults(opts ...OverflowPrinterOption) OverflowOption

alias for WithGLobalPrintOptions

func WithReturnErrors 

func WithReturnErrors() OverflowOption

If this option is used a panic will be called if an error occurs after an interaction is run

func WithScriptFolderName 

func WithScriptFolderName(name string) OverflowOption

WithScriptFolderName will overwite the default script subdir for scripts `scripts`

func WithServiceAccountSuffix 

func WithServiceAccountSuffix(suffix string) OverflowOption

WithServiceAccountSuffix will set the suffix of the service account

func WithTransactionFolderName 

func WithTransactionFolderName(name string) OverflowOption

WithTransactionFolderName will overwite the default script subdir for transactions `transactions`

func WithoutTransactionFees 

func WithoutTransactionFees() OverflowOption

Turn off storage fees

type OverflowPastEvent 

type OverflowPastEvent struct {
	Name        string        `json:"name"`
	BlockHeight uint64        `json:"blockHeight,omitempty"`
	BlockID     string        `json:"blockID,omnitEmpty"`
	Time        time.Time     `json:"time,omitempty"`
	Event       OverflowEvent `json:"event"`
}

a type to represent an event that we get from FetchEvents

func (OverflowPastEvent) GetFieldAsUInt64 

func (e OverflowPastEvent) GetFieldAsUInt64(field string) uint64

get the given field as an uint64

func (OverflowPastEvent) MarshalAs 

func (e OverflowPastEvent) MarshalAs(marshalTo interface{}) error

func (OverflowPastEvent) String 

func (e OverflowPastEvent) String() string

String pretty print an event as a String

func (OverflowPastEvent) ToGraffleEvent 

func (e OverflowPastEvent) ToGraffleEvent() OverflowGraffleEvent

type OverflowPrinterBuilder 

type OverflowPrinterBuilder struct {

	//set to false to disable all events
	Events bool

	//filter out some events
	EventFilter OverflowEventFilter

	//0 to print no meter, 1 to print some, 2 to pritn all NB verbose
	Meter int

	//print the emulator log, NB! Verbose
	EmulatorLog bool

	//print transaction id, useful to disable in tests
	Id bool

	Arguments      bool
	TransactionUrl bool
}

a type representing the accuumlated state in the builder

the default setting is to print one line for each transaction with meter and all events

type OverflowPrinterOption 

type OverflowPrinterOption func(*OverflowPrinterBuilder)

a type represneting seting an obtion in the printer builder

func WithArguments 

func WithArguments() OverflowPrinterOption

func WithEmulatorLog 

func WithEmulatorLog() OverflowPrinterOption

print the emulator log. NB! Verbose

func WithEventFilter 

func WithEventFilter(filter OverflowEventFilter) OverflowPrinterOption

filter out events that are printed

func WithFullMeter 

func WithFullMeter() OverflowPrinterOption

print full meter verbose mode

func WithMeter 

func WithMeter() OverflowPrinterOption

print meters as part of the transaction output line

func WithTransactionUrl 

func WithTransactionUrl() OverflowPrinterOption

func WithoutEvents 

func WithoutEvents() OverflowPrinterOption

do not print events

func WithoutId 

func WithoutId() OverflowPrinterOption

func WithoutMeter 

func WithoutMeter(value int) OverflowPrinterOption

do not print meter

type OverflowResult 

type OverflowResult struct {
	StopOnError bool
	// The error if any
	Err error

	// The id of the transaction
	Id flow.Identifier

	// If running on an emulator
	// the meter that contains useful debug information on memory and interactions
	Meter *OverflowMeter
	// The Raw log from the emulator
	RawLog []OverflowEmulatorLogMessage
	// The log from the emulator
	EmulatorLog []string

	// The computation used
	ComputationUsed int

	// The raw unfiltered events
	RawEvents []flow.Event

	// Events that are filtered and parsed into a terse format
	Events OverflowEvents

	// The underlying transaction if we need to look into that
	Transaction *flow.Transaction

	// The transaction result if we need to look into that
	TransactionResult *flow.TransactionResult

	// TODO: consider marshalling this as a struct for convenience
	// The fee event if any
	Fee    map[string]interface{}
	FeeGas int

	// The name of the Transaction
	Name string

	Arguments CadenceArguments
}

OverflowResult represents the state after running an transaction

func (OverflowResult) AssertComputationLessThenOrEqual 

func (o OverflowResult) AssertComputationLessThenOrEqual(t *testing.T, computation int) OverflowResult

Assert that this transaction did not use more then the given amount of computation

func (OverflowResult) AssertComputationUsed 

func (o OverflowResult) AssertComputationUsed(t *testing.T, computation int) OverflowResult

Assert that the transaction uses exactly the given computation amount

func (OverflowResult) AssertDebugLog 

func (o OverflowResult) AssertDebugLog(t *testing.T, message ...string) OverflowResult

Assert that a Debug.Log event was emitted that contains the given messages

func (OverflowResult) AssertEmitEventName 

func (o OverflowResult) AssertEmitEventName(t *testing.T, event ...string) OverflowResult

Assert that events with the given suffixes are present

func (OverflowResult) AssertEmulatorLog 

func (o OverflowResult) AssertEmulatorLog(t *testing.T, message string) OverflowResult

Assert that the internal log of the emulator contains the given message

func (OverflowResult) AssertEvent 

func (o OverflowResult) AssertEvent(t *testing.T, name string, fields map[string]interface{}) OverflowResult

Assert that the event with the given name suffix and fields are present

func (OverflowResult) AssertEventCount 

func (o OverflowResult) AssertEventCount(t *testing.T, number int) OverflowResult

Assert that the transaction result contains the amount of events

func (OverflowResult) AssertFailure 

func (o OverflowResult) AssertFailure(t *testing.T, msg string) OverflowResult

Assert that this particular transaction was a failure that has a message that contains the sendt in assertion

func (OverflowResult) AssertNoEvents 

func (o OverflowResult) AssertNoEvents(t *testing.T) OverflowResult

Assert that this transaction emitted no events

func (OverflowResult) AssertSuccess 

func (o OverflowResult) AssertSuccess(t *testing.T) OverflowResult

Assert that this transaction was an success

func (OverflowResult) GetEventsWithName 

func (o OverflowResult) GetEventsWithName(eventName string) []OverflowEvent

Get all events that end with the given suffix

func (OverflowResult) GetIdFromEvent 

func (o OverflowResult) GetIdFromEvent(eventName string, fieldName string) (uint64, error)

Get a uint64 field with the given fieldname(most often an id) from an event with a given suffix

func (OverflowResult) GetIdsFromEvent 

func (o OverflowResult) GetIdsFromEvent(eventName string, fieldName string) []uint64

func (OverflowResult) MarshalEventsWithName 

func (o OverflowResult) MarshalEventsWithName(eventName string, result interface{}) error

Get all events that end with the given suffix

func (OverflowResult) Print 

func (o OverflowResult) Print(opbs ...OverflowPrinterOption) OverflowResult

print out an result

func (OverflowResult) PrintArguments 

func (o OverflowResult) PrintArguments(t *testing.T)

type OverflowScriptFunction 

type OverflowScriptFunction func(filename string, opts ...OverflowInteractionOption) *OverflowScriptResult

a type used for composing scripts

type OverflowScriptOptsFunction 

type OverflowScriptOptsFunction func(opts ...OverflowInteractionOption) *OverflowScriptResult

a type used for composing scripts

type OverflowScriptResult 

type OverflowScriptResult struct {
	Err    error
	Result cadence.Value
	Input  *OverflowInteractionBuilder
	Log    []OverflowEmulatorLogMessage
	Output interface{}
}

result after running a script

func (*OverflowScriptResult) AssertLengthWithPointer 

func (osr *OverflowScriptResult) AssertLengthWithPointer(t *testing.T, pointer string, length int) *OverflowScriptResult

Assert that the length of a jsonPointer is equal to length

func (*OverflowScriptResult) AssertWant 

func (osr *OverflowScriptResult) AssertWant(t *testing.T, want autogold.Value) *OverflowScriptResult

Assert that the result is equal to the given autogold.Want

func (*OverflowScriptResult) AssertWithPointer 

func (osr *OverflowScriptResult) AssertWithPointer(t *testing.T, pointer string, value interface{}) *OverflowScriptResult

Assert that a jsonPointer into the result is equal to the given value

func (*OverflowScriptResult) AssertWithPointerError 

func (osr *OverflowScriptResult) AssertWithPointerError(t *testing.T, pointer string, message string) *OverflowScriptResult

Assert that a jsonPointer into the result is an error

func (*OverflowScriptResult) AssertWithPointerWant 

func (osr *OverflowScriptResult) AssertWithPointerWant(t *testing.T, pointer string, want autogold.Value) *OverflowScriptResult

Assert that a jsonPointer into the result is equal to the given autogold Want

func (*OverflowScriptResult) GetAsInterface 

func (osr *OverflowScriptResult) GetAsInterface() (interface{}, error)

get the script as interface{}

func (*OverflowScriptResult) GetAsJson 

func (osr *OverflowScriptResult) GetAsJson() (string, error)

get the script as json

func (*OverflowScriptResult) GetWithPointer 

func (osr *OverflowScriptResult) GetWithPointer(pointer string) (interface{}, error)

get the given jsonPointer as interface{}

func (*OverflowScriptResult) MarshalAs 

func (osr *OverflowScriptResult) MarshalAs(marshalTo interface{}) error

Marshal the script output as the given sent in type

func (*OverflowScriptResult) MarshalPointerAs 

func (osr *OverflowScriptResult) MarshalPointerAs(pointer string, marshalTo interface{}) error

Marshal the given jsonPointer as the given type

func (*OverflowScriptResult) Print 

func (osr *OverflowScriptResult) Print() *OverflowScriptResult

Print the result

func (*OverflowScriptResult) PrintArguments 

func (osr *OverflowScriptResult) PrintArguments(t *testing.T)

type OverflowSolution 

type OverflowSolution struct {

	//all transactions with name and what paremters they have
	Transactions map[string]*OverflowDeclarationInfo `json:"transactions"`

	//all scripts with name and parameter they have
	Scripts map[string]*OverflowDeclarationInfo `json:"scripts"`

	//all networks with associated scripts/tranasctions/contracts preresolved
	Networks map[string]*OverflowSolutionNetwork `json:"networks"`

	//warnings accumulated during parsing
	Warnings []string `json:"warnings"`
}

a type representing the raw solutions that contains all transactions, scripts, networks and warnings of any

func (*OverflowSolution) MergeSpecAndCode 

func (s *OverflowSolution) MergeSpecAndCode() *OverflowSolutionMerged

merge the given Solution into a MergedSolution that is suited for exposing as an NPM module

type OverflowSolutionMerged 

type OverflowSolutionMerged struct {
	Networks map[string]OverflowSolutionMergedNetwork `json:"networks"`
}

a type representing a merged solution that will be serialized as the json file for the npm module

type OverflowSolutionMergedNetwork 

type OverflowSolutionMergedNetwork struct {
	Scripts      map[string]OverflowCodeWithSpec `json:"scripts"`
	Transactions map[string]OverflowCodeWithSpec `json:"transactions,omitempty"`
	Contracts    *map[string]string              `json:"contracts,omitempty"`
}

a network in the merged solution

type OverflowSolutionNetwork 

type OverflowSolutionNetwork struct {
	Scripts      map[string]string  `json:"scripts"`
	Transactions map[string]string  `json:"transactions,omitempty"`
	Contracts    *map[string]string `json:"contracts,omitempty"`
}

a type representing one network in a solution, so mainnet/testnet/emulator

type OverflowState 

type OverflowState struct {
	State *flowkit.State
	// the services from flowkit to performed operations on
	Flowkit *flowkit.Flowkit

	EmulatorGatway *gateway.EmulatorGateway

	ArchiveFlowkit *flowkit.Flowkit

	// Configured variables that are taken from the builder since we need them in the execution of overflow later on
	Network                      config.Network
	PrependNetworkToAccountNames bool
	ServiceAccountSuffix         string
	Gas                          int

	// flowkit, emulator and emulator debug log uses three different logging technologies so we have them all stored here
	// this flowkit Logger can go away when we can remove deprecations!
	Logger   output.Logger
	Log      *bytes.Buffer
	LogLevel int

	// If there was an error starting overflow it is stored here
	Error error

	// Paths that points to where .cdc files are stored and the posibilty to specify something besides the standard `transactions`/`scripts`subdirectories
	BasePath            string
	TransactionBasePath string
	ScriptBasePath      string

	// Filters to events to remove uneeded noise
	FilterOutFeeEvents                  bool
	FilterOutEmptyWithDrawDepositEvents bool
	GlobalEventFilter                   OverflowEventFilter

	// Signal to overflow that if there is an error after running a single interaction we should panic
	StopOnError bool

	// Signal to overflow that if this is not nil we should print events on interaction completion
	PrintOptions *[]OverflowPrinterOption

	// Mint this amount of flow to new accounts
	NewUserFlowAmount float64

	InputResolver InputResolver

	// the coverage report if any
	CoverageReport *runtime.CoverageReport

	// the string id of the system chunk transaction
	SystemChunkTransactionId string
}

OverflowState contains information about how to Overflow is confitured and the current runnig state

func Overflow 

func Overflow(opts ...OverflowOption) *OverflowState

Overflow will start an Overflow instance that panics if there are initialization errors

Will read the following ENV vars as default: OVERFLOW_ENV : set to "mainnet|testnet|emulator|embedded", default embedded OVERFLOW_LOGGING: set from 0-3. 0 is silent, 1 is print terse output, 2 is print output from flowkit, 3 is all lots we can OVERFLOW_CONTINUE: to continue this overflow on an already running emulator., default false OVERFLOW_STOP_ON_ERROR: will the process panic if an erorr is encountered. If set to false the result objects will have the error. default: false

Starting overflow without env vars will make it start in embedded mode deploying all contracts creating accounts

You can then chose to override this setting with the builder methods example 

Overflow(WithNetwork("mainnet"))

func OverflowTesting 

func OverflowTesting(opts ...OverflowOption) (*OverflowState, error)

func (*OverflowState) Account 

func (o *OverflowState) Account(key string) *accounts.Account

return the account of a given account

func (*OverflowState) AccountE 

func (o *OverflowState) AccountE(key string) (*accounts.Account, error)

AccountE fetch an account from State Note that if `PrependNetworkToAccountNames` is specified it is prefixed with the network so that you can use the same logical name across networks

func (*OverflowState) AccountPublicKey added in v1.14.0 

func (o *OverflowState) AccountPublicKey(name string) (string, error)

func (*OverflowState) AddContract 

func (o *OverflowState) AddContract(ctx context.Context, name string, code []byte, args []cadence.Value, filename string, update bool) error

func (*OverflowState) Address 

func (o *OverflowState) Address(key string) string

return the address of an given account

func (*OverflowState) BuildInteraction 

func (o *OverflowState) BuildInteraction(filename string, interactionType string, opts ...OverflowInteractionOption) *OverflowInteractionBuilder

create a flowInteractionBuilder from the sent in options

func (*OverflowState) CreateAccountsE 

func (o *OverflowState) CreateAccountsE(ctx context.Context) (*OverflowState, error)

CreateAccountsE ensures that all accounts present in the deployment block for the given network is present

func (*OverflowState) DownloadAndUploadFile 

func (o *OverflowState) DownloadAndUploadFile(url string, accountName string) error

DownloadAndUploadFile reads a file, base64 encodes it and chunk upload to /storage/upload

func (*OverflowState) DownloadImageAndUploadAsDataUrl 

func (o *OverflowState) DownloadImageAndUploadAsDataUrl(url, accountName string) error

DownloadImageAndUploadAsDataUrl download an image and upload as data url

func (*OverflowState) FetchEvents 

func (o *OverflowState) FetchEvents(opts ...OverflowEventFetcherOption) ([]OverflowPastEvent, error)

FetchEvents using the given options

func (*OverflowState) FetchEventsWithResult 

func (o *OverflowState) FetchEventsWithResult(opts ...OverflowEventFetcherOption) EventFetcherResult

FetchEvents using the given options

func (*OverflowState) FillUpStorage 

func (o *OverflowState) FillUpStorage(accountName string) *OverflowState

A method to fill up a users storage, useful when testing This has some issues with transaction fees

func (*OverflowState) FlowAddress 

func (o *OverflowState) FlowAddress(key string) flow.Address

return the flow Address of the given name

func (*OverflowState) GenerateStub 

func (o *OverflowState) GenerateStub(network, filePath string, standalone bool) (string, error)

func (*OverflowState) GetAccount 

func (o *OverflowState) GetAccount(ctx context.Context, key string) (*flow.Account, error)

GetAccount takes the account name and returns the state of that account on the given network.

func (*OverflowState) GetBlockAtHeight 

func (o *OverflowState) GetBlockAtHeight(ctx context.Context, height uint64) (*flow.Block, error)

get block at a given height

func (*OverflowState) GetBlockById 

func (o *OverflowState) GetBlockById(ctx context.Context, blockId string) (*flow.Block, error)

blockId should be a hexadecimal string

func (*OverflowState) GetBlockResult 

func (o *OverflowState) GetBlockResult(ctx context.Context, height uint64, logg *zap.Logger) (*BlockResult, error)

func (*OverflowState) GetCoverageReport 

func (o *OverflowState) GetCoverageReport() *runtime.CoverageReport

func (*OverflowState) GetFreeCapacity 

func (o *OverflowState) GetFreeCapacity(accountName string) int

Get the free capacity in an account

func (*OverflowState) GetLatestBlock 

func (o *OverflowState) GetLatestBlock(ctx context.Context) (*flow.Block, error)

get the latest block

func (*OverflowState) GetNetwork 

func (o *OverflowState) GetNetwork() string

func (*OverflowState) GetOverflowTransactionById 

func (o *OverflowState) GetOverflowTransactionById(ctx context.Context, id flow.Identifier) (*OverflowTransaction, error)

func (*OverflowState) GetTransactionById 

func (o *OverflowState) GetTransactionById(ctx context.Context, id flow.Identifier) (*flow.Transaction, error)

func (*OverflowState) GetTransactions 

func (o *OverflowState) GetTransactions(ctx context.Context, id flow.Identifier, logg *zap.Logger) ([]OverflowTransaction, OverflowEvents, error)

this is get from block, needs to return system chunk information

func (*OverflowState) InitializeContracts 

func (o *OverflowState) InitializeContracts(ctx context.Context) *OverflowState

InitializeContracts installs all contracts in the deployment block for the configured network

func (*OverflowState) MintFlowTokens 

func (o *OverflowState) MintFlowTokens(accountName string, amount float64) *OverflowState

func (*OverflowState) Parse 

func (o *OverflowState) Parse(codeFileName string, code []byte, network config.Network) (string, error)

Parse a given file into a resolved version

func (*OverflowState) ParseAll 

func (o *OverflowState) ParseAll() (*OverflowSolution, error)

Parse the given overflow state into a solution/npm-module

func (*OverflowState) ParseAllWithConfig 

func (o *OverflowState) ParseAllWithConfig(skipContracts bool, txSkip []string, scriptSkip []string) (*OverflowSolution, error)

Parse the gieven overflow state with filters

func (*OverflowState) QualifiedIdentifier 

func (o *OverflowState) QualifiedIdentifier(contract string, name string) (string, error)

account can either be a name from accounts or the raw value

func (*OverflowState) QualifiedIdentifierFromSnakeCase 

func (o *OverflowState) QualifiedIdentifierFromSnakeCase(typeName string) (string, error)

Qualified identifier from a snakeCase string Account_Contract_Struct

func (*OverflowState) RollbackToBlockHeight 

func (o *OverflowState) RollbackToBlockHeight(height uint64) error

func (*OverflowState) Script 

func (o *OverflowState) Script(filename string, opts ...OverflowInteractionOption) *OverflowScriptResult

run a script with the given code/filanem an options

Example 
o := Overflow(docOptions)

// the other major interaction you can run on Flow is a script, it uses the script DSL.
// Start it by specifying the script name from `scripts` folder
o.Script("test",
	// the test script requires an address as arguments, Overflow is smart enough that it
	// sees this and knows that there is an account for the emulator network called
	// `emulator-first` so it will insert that address as the argument.
	// If you change the network to testnet/mainnet later and name your stakholders
	// accordingly it will just work
	WithArg("account", "first"),
)

Output:

🧑 Created account: emulator-first with address: 01cf0e2f2f715450 with flow: 10.00
🧑 Created account: emulator-second with address: 179b6b1cb6755e31 with flow: 10.00
📜 deploy contracts NonFungibleToken, Debug, MetadataViews
⭐ Script test run result:"0x01cf0e2f2f715450"
Example (Inline) 
o := Overflow(docOptions)

// Script can be run inline
o.Script(`
pub fun main(account: Address): String {
    return getAccount(account).address.toString()
}`,
	WithArg("account", "first"),
	WithName("get_address"),
)

Output:

🧑 Created account: emulator-first with address: 01cf0e2f2f715450 with flow: 10.00
🧑 Created account: emulator-second with address: 179b6b1cb6755e31 with flow: 10.00
📜 deploy contracts NonFungibleToken, Debug, MetadataViews
⭐ Script get_address run result:"0x01cf0e2f2f715450"

func (*OverflowState) ScriptFN 

func (o *OverflowState) ScriptFN(outerOpts ...OverflowInteractionOption) OverflowScriptFunction

compose interactionOptions into a new Script function

func (*OverflowState) ScriptFileNameFN 

func (o *OverflowState) ScriptFileNameFN(filename string, outerOpts ...OverflowInteractionOption) OverflowScriptOptsFunction

compose fileName and interactionOptions into a new Script function

func (*OverflowState) ServiceAccountName 

func (o *OverflowState) ServiceAccountName() string

ServiceAccountName return the name of the current service account Note that if `PrependNetworkToAccountNames` is specified it is prefixed with the network so that you can use the same logical name across networks

func (*OverflowState) SignUserMessage 

func (o *OverflowState) SignUserMessage(account string, message string) (string, error)

Sign a user message

func (*OverflowState) StreamTransactions 

func (o *OverflowState) StreamTransactions(ctx context.Context, poll time.Duration, height uint64, logger *zap.Logger, channel chan<- BlockResult) error

This code is beta

func (*OverflowState) Tx 

func (o *OverflowState) Tx(filename string, opts ...OverflowInteractionOption) *OverflowResult

The main function for running an transasction in overflow

Example 
o := Overflow(docOptions)

// start the Tx DSL with the name of the transactions file, by default this
// is in the `transactions` folder in your root dit
o.Tx("arguments",
	// Customize the Transaction by sending in more InteractionOptions,
	// at minimum you need to set Signer and Args if any
	WithSigner("first"),
	// Arguments are always passed by name in the DSL builder, order does not matter
	WithArg("test", "overflow ftw!"),
)

Output:

🧑 Created account: emulator-first with address: 01cf0e2f2f715450 with flow: 10.00
🧑 Created account: emulator-second with address: 179b6b1cb6755e31 with flow: 10.00
📜 deploy contracts NonFungibleToken, Debug, MetadataViews
👌 Tx:arguments fee:0.00001000 gas:17
Example (Inline) 
o := Overflow(docOptions)

// The Tx dsl can also contain an inline transaction
o.Tx(`
		import Debug from "../contracts/Debug.cdc"
		transaction(message:String) {
		  prepare(acct: AuthAccount) {
				Debug.log(message) 
			} 
		}`,
	WithSigner("first"),
	WithArg("message", "overflow ftw!"),
)

Output:

🧑 Created account: emulator-first with address: 01cf0e2f2f715450 with flow: 10.00
🧑 Created account: emulator-second with address: 179b6b1cb6755e31 with flow: 10.00
📜 deploy contracts NonFungibleToken, Debug, MetadataViews
👌 Tx: fee:0.00001000 gas:25
=== Events ===
A.f8d6e0586b0a20c7.Debug.Log
  msg -> overflow ftw!
Example (Multisign) 
o := Overflow(docOptions)

// The Tx dsl supports multiple signers, note that the mainSigner is the last account
o.Tx(`
		import Debug from "../contracts/Debug.cdc"
		transaction {
			prepare(acct: AuthAccount, acct2: AuthAccount) {
				Debug.log("acct:".concat(acct.address.toString()))
				Debug.log("acct2:".concat(acct2.address.toString()))
			} 
		}`,
	WithSigner("first"),
	WithPayloadSigner("second"),
)

Output:

🧑 Created account: emulator-first with address: 01cf0e2f2f715450 with flow: 10.00
🧑 Created account: emulator-second with address: 179b6b1cb6755e31 with flow: 10.00
📜 deploy contracts NonFungibleToken, Debug, MetadataViews
👌 Tx: fee:0.00001000 gas:25
=== Events ===
A.f8d6e0586b0a20c7.Debug.Log
  msg -> acct:0x179b6b1cb6755e31
A.f8d6e0586b0a20c7.Debug.Log
  msg -> acct2:0x01cf0e2f2f715450

func (*OverflowState) TxFN 

func (o *OverflowState) TxFN(outerOpts ...OverflowInteractionOption) OverflowTransactionFunction

If you store this in a struct and add arguments to it it will not reset between calls

func (*OverflowState) TxFileNameFN 

func (o *OverflowState) TxFileNameFN(filename string, outerOpts ...OverflowInteractionOption) OverflowTransactionOptsFunction

func (*OverflowState) UploadFile 

func (o *OverflowState) UploadFile(filename string, accountName string) error

UploadFile reads a file, base64 encodes it and chunk upload to /storage/upload

func (*OverflowState) UploadImageAsDataUrl 

func (o *OverflowState) UploadImageAsDataUrl(filename string, accountName string) error

UploadImageAsDataUrl will upload a image file from the filesystem into /storage/upload of the given account

func (*OverflowState) UploadString 

func (o *OverflowState) UploadString(content string, accountName string) error

UploadString will upload the given string data in 1mb chunkts to /storage/upload of the given account

type OverflowTest 

type OverflowTest struct {
	O *OverflowState
	// contains filtered or unexported fields
}

func SetupTest 

func SetupTest(opts []OverflowOption, setup func(o *OverflowState) error) (*OverflowTest, error)

func (*OverflowTest) Reset 

func (ot *OverflowTest) Reset() error

func (*OverflowTest) Run 

func (ot *OverflowTest) Run(t *testing.T, name string, f func(t *testing.T))

func (*OverflowTest) Teardown 

func (ot *OverflowTest) Teardown()

type OverflowTransaction 

type OverflowTransaction struct {
	Id               string
	TransactionIndex int
	BlockId          string
	Events           []OverflowEvent
	Error            error
	Fee              float64
	Status           string
	Arguments        []Argument
	Authorizers      []string
	Stakeholders     map[string][]string
	Imports          []Import
	Payer            string
	ProposalKey      flow.ProposalKey
	GasLimit         uint64
	GasUsed          uint64
	ExecutionEffort  float64
	Script           []byte
}

func CreateOverflowTransactions 

func CreateOverflowTransactions(blockId string, transactionResult flow.TransactionResult, transaction flow.Transaction, txIndex int) (*OverflowTransaction, error)

type OverflowTransactionFunction 

type OverflowTransactionFunction func(filename string, opts ...OverflowInteractionOption) *OverflowResult

a type to define a function used to compose Transaction interactions

type OverflowTransactionOptsFunction 

type OverflowTransactionOptsFunction func(opts ...OverflowInteractionOption) *OverflowResult

a type to define a function used to compose Transaction interactions

type ProgressReaderWriter 

type ProgressReaderWriter interface {
	/// can return 0 if we do not have any progress thus far
	ReadProgress() (int64, error)
	WriteProgress(progress int64) error
}

type ProgressWriterFunction 

type ProgressWriterFunction func() error

Source Files

View all Source files

Directories

Path Synopsis
tools
overflow-generate
overflow-json

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.