stdlib

package
v1.3.0 Latest Latest
Warning

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

 Go to latest Published: Dec 3, 2024 License: Apache-2.0 Imports: 23 Imported by: 6

Documentation

Index

Constants

View Source 
const BLSTypeAggregatePublicKeysFunctionDocString = `` /* 295-byte string literal not displayed */
View Source 
const BLSTypeAggregatePublicKeysFunctionName = "aggregatePublicKeys"
View Source 
const BLSTypeAggregateSignaturesFunctionDocString = `` /* 493-byte string literal not displayed */
View Source 
const BLSTypeAggregateSignaturesFunctionName = "aggregateSignatures"
View Source 
const BLSTypeName = "BLS"
View Source 
const BlockHashLength = 32
View Source 
const CryptoContractLocation = common.IdentifierLocation("Crypto")
View Source 
const FlowLocationPrefix = "flow"
View Source 
const HashSize = 32
View Source 
const RLPTypeDecodeListFunctionDocString = `` /* 415-byte string literal not displayed */
View Source 
const RLPTypeDecodeListFunctionName = "decodeList"
View Source 
const RLPTypeDecodeStringFunctionDocString = `` /* 313-byte string literal not displayed */
View Source 
const RLPTypeDecodeStringFunctionName = "decodeString"
View Source 
const RLPTypeName = "RLP"
View Source 
const TestContractLocation = common.IdentifierLocation(testContractTypeName)

Variables

View Source 
var AccountCapabilityControllerDeletedEventType = newFlowEventType(
	"AccountCapabilityControllerDeleted",
	CapabilityControllerEventIDParameter,
	CapabilityControllerEventAddressParameter,
)
View Source 
var AccountCapabilityControllerIssuedEventType = newFlowEventType(
	"AccountCapabilityControllerIssued",
	CapabilityControllerEventIDParameter,
	CapabilityControllerEventAddressParameter,
	CapabilityControllerEventTypeParameter,
)
View Source 
var AccountContractAddedEventType = newFlowEventType(
	"AccountContractAdded",
	AccountEventAddressParameter,
	AccountEventCodeHashParameter,
	AccountEventContractParameter,
)
View Source 
var AccountContractRemovedEventType = newFlowEventType(
	"AccountContractRemoved",
	AccountEventAddressParameter,
	AccountEventCodeHashParameter,
	AccountEventContractParameter,
)
View Source 
var AccountContractUpdatedEventType = newFlowEventType(
	"AccountContractUpdated",
	AccountEventAddressParameter,
	AccountEventCodeHashParameter,
	AccountEventContractParameter,
)
View Source 
var AccountCreatedEventType = newFlowEventType(
	"AccountCreated",
	AccountEventAddressParameter,
)
View Source 
var AccountEventAddressParameter = sema.Parameter{
	Identifier:     "address",
	TypeAnnotation: sema.AddressTypeAnnotation,
}
View Source 
var AccountEventCodeHashParameter = sema.Parameter{
	Identifier:     "codeHash",
	TypeAnnotation: HashTypeAnnotation,
}
View Source 
var AccountEventContractParameter = sema.Parameter{
	Identifier:     "contract",
	TypeAnnotation: sema.StringTypeAnnotation,
}
View Source 
var AccountEventHashAlgorithmParameter = sema.Parameter{
	Identifier:     "hashAlgorithm",
	TypeAnnotation: sema.HashAlgorithmTypeAnnotation,
}
View Source 
var AccountEventKeyIndexParameter = sema.Parameter{
	Identifier:     "keyIndex",
	TypeAnnotation: sema.IntTypeAnnotation,
}
View Source 
var AccountEventKeyWeightParameter = sema.Parameter{
	Identifier:     "weight",
	TypeAnnotation: sema.UFix64TypeAnnotation,
}
View Source 
var AccountEventNameParameter = sema.Parameter{
	Identifier:     "name",
	TypeAnnotation: sema.StringTypeAnnotation,
}
View Source 
var AccountEventProviderParameter = sema.Parameter{
	Identifier:     "provider",
	TypeAnnotation: sema.AddressTypeAnnotation,
}
View Source 
var AccountEventPublicKeyIndexParameter = sema.Parameter{
	Identifier: "publicKey",
	TypeAnnotation: sema.NewTypeAnnotation(
		sema.IntType,
	),
}
View Source 
var AccountEventPublicKeyParameterAsCompositeType = sema.Parameter{
	Identifier: "publicKey",
	TypeAnnotation: sema.NewTypeAnnotation(
		sema.PublicKeyType,
	),
}
View Source 
var AccountEventRecipientParameter = sema.Parameter{
	Identifier:     "recipient",
	TypeAnnotation: sema.AddressTypeAnnotation,
}
View Source 
var AccountEventTypeParameter = sema.Parameter{
	Identifier:     "type",
	TypeAnnotation: sema.MetaTypeAnnotation,
}
View Source 
var AccountInboxClaimedEventType = newFlowEventType(
	"InboxValueClaimed",
	AccountEventProviderParameter,
	AccountEventRecipientParameter,
	AccountEventNameParameter,
)
View Source 
var AccountInboxPublishedEventType = newFlowEventType(
	"InboxValuePublished",
	AccountEventProviderParameter,
	AccountEventRecipientParameter,
	AccountEventNameParameter,
	AccountEventTypeParameter,
)
View Source 
var AccountInboxUnpublishedEventType = newFlowEventType(
	"InboxValueUnpublished",
	AccountEventProviderParameter,
	AccountEventNameParameter,
)
View Source 
var AccountKeyAddedFromPublicKeyEventType = newFlowEventType(
	"AccountKeyAdded",
	AccountEventAddressParameter,
	AccountEventPublicKeyParameterAsCompositeType,
	AccountEventKeyWeightParameter,
	AccountEventHashAlgorithmParameter,
	AccountEventKeyIndexParameter,
)
View Source 
var AccountKeyRemovedFromPublicKeyIndexEventType = newFlowEventType(
	"AccountKeyRemoved",
	AccountEventAddressParameter,
	AccountEventPublicKeyIndexParameter,
)
View Source 
var AssertFunction = NewStandardLibraryStaticFunction(
	"assert",
	assertFunctionType,
	assertFunctionDocString,
	func(invocation interpreter.Invocation) interpreter.Value {
		result, ok := invocation.Arguments[0].(interpreter.BoolValue)
		if !ok {
			panic(errors.NewUnreachableError())
		}

		if !result {
			var message string
			if len(invocation.Arguments) > 1 {
				messageValue, ok := invocation.Arguments[1].(*interpreter.StringValue)
				if !ok {
					panic(errors.NewUnreachableError())
				}
				message = messageValue.Str
			}
			panic(AssertionError{
				Message:       message,
				LocationRange: invocation.LocationRange,
			})
		}
		return interpreter.Void
	},
)
View Source 
var BLSType = func() *sema.CompositeType {
	var t = &sema.CompositeType{
		Identifier:         BLSTypeName,
		Kind:               common.CompositeKindContract,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var BLSTypeAggregatePublicKeysFunctionType = &sema.FunctionType{
	Purity: sema.FunctionPurityView,
	Parameters: []sema.Parameter{
		{
			Label:      sema.ArgumentLabelNotRequired,
			Identifier: "keys",
			TypeAnnotation: sema.NewTypeAnnotation(&sema.VariableSizedType{
				Type: sema.PublicKeyType,
			}),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(
		&sema.OptionalType{
			Type: sema.PublicKeyType,
		},
	),
}
View Source 
var BLSTypeAggregateSignaturesFunctionType = &sema.FunctionType{
	Purity: sema.FunctionPurityView,
	Parameters: []sema.Parameter{
		{
			Label:      sema.ArgumentLabelNotRequired,
			Identifier: "signatures",
			TypeAnnotation: sema.NewTypeAnnotation(&sema.VariableSizedType{
				Type: &sema.VariableSizedType{
					Type: sema.UInt8Type,
				},
			}),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(
		&sema.OptionalType{
			Type: &sema.VariableSizedType{
				Type: sema.UInt8Type,
			},
		},
	),
}
View Source 
var BLSTypeStaticType = interpreter.ConvertSemaToStaticType(nil, BLSType)
View Source 
var BlockIDStaticType = &interpreter.ConstantSizedStaticType{
	Type: interpreter.PrimitiveStaticTypeUInt8,
	Size: 32,
}
View Source 
var CapabilityControllerEventAddressParameter = sema.Parameter{
	Identifier:     "address",
	TypeAnnotation: sema.AddressTypeAnnotation,
}
View Source 
var CapabilityControllerEventIDParameter = sema.Parameter{
	Identifier:     "id",
	TypeAnnotation: sema.UInt64TypeAnnotation,
}
View Source 
var CapabilityControllerEventTypeParameter = sema.Parameter{
	Identifier:     "type",
	TypeAnnotation: sema.MetaTypeAnnotation,
}
View Source 
var CapabilityEventAddressParameter = sema.Parameter{
	Identifier:     "address",
	TypeAnnotation: sema.AddressTypeAnnotation,
}
View Source 
var CapabilityEventPathParameter = sema.Parameter{
	Identifier:     "path",
	TypeAnnotation: sema.PublicPathTypeAnnotation,
}
View Source 
var CapabilityPublishedEventType = newFlowEventType(
	"CapabilityPublished",
	CapabilityEventAddressParameter,
	CapabilityEventPathParameter,
	sema.Parameter{
		Identifier:     "capability",
		TypeAnnotation: sema.NewTypeAnnotation(&sema.CapabilityType{}),
	},
)
View Source 
var CapabilityUnpublishedEventType = newFlowEventType(
	"CapabilityUnpublished",
	CapabilityEventAddressParameter,
	CapabilityEventPathParameter,
)
View Source 
var FlowEventTypes = map[common.TypeID]*sema.CompositeType{}
View Source 
var HashType = &sema.ConstantSizedType{
	Size: HashSize,
	Type: sema.UInt8Type,
}
View Source 
var HashTypeAnnotation = sema.NewTypeAnnotation(HashType)
View Source 
var InclusiveRangeConstructorFunction = NewStandardLibraryStaticFunction(
	"InclusiveRange",
	inclusiveRangeConstructorFunctionType,
	inclusiveRangeConstructorFunctionDocString,
	func(invocation interpreter.Invocation) interpreter.Value {
		start, startOk := invocation.Arguments[0].(interpreter.IntegerValue)
		end, endOk := invocation.Arguments[1].(interpreter.IntegerValue)

		if !startOk || !endOk {
			panic(errors.NewUnreachableError())
		}

		inter := invocation.Interpreter
		locationRange := invocation.LocationRange

		startStaticType := start.StaticType(inter)
		endStaticType := end.StaticType(inter)
		if !startStaticType.Equal(endStaticType) {
			panic(interpreter.InclusiveRangeConstructionError{
				LocationRange: locationRange,
				Message: fmt.Sprintf(
					"start and end are of different types. start: %s and end: %s",
					startStaticType,
					endStaticType,
				),
			})
		}

		rangeStaticType := interpreter.NewInclusiveRangeStaticType(invocation.Interpreter, startStaticType)
		rangeSemaType := sema.NewInclusiveRangeType(invocation.Interpreter, invocation.ArgumentTypes[0])

		if len(invocation.Arguments) > 2 {
			step, ok := invocation.Arguments[2].(interpreter.IntegerValue)
			if !ok {
				panic(errors.NewUnreachableError())
			}

			stepStaticType := step.StaticType(inter)
			if stepStaticType != startStaticType {
				panic(interpreter.InclusiveRangeConstructionError{
					LocationRange: locationRange,
					Message: fmt.Sprintf(
						"step must be of the same type as start and end. start/end: %s and step: %s",
						startStaticType,
						stepStaticType,
					),
				})
			}

			return interpreter.NewInclusiveRangeValueWithStep(
				inter,
				locationRange,
				start,
				end,
				step,
				rangeStaticType,
				rangeSemaType,
			)
		}

		return interpreter.NewInclusiveRangeValue(
			inter,
			locationRange,
			start,
			end,
			rangeStaticType,
			rangeSemaType,
		)
	},
)
View Source 
var LogFunctionType = sema.NewSimpleFunctionType(
	sema.FunctionPurityImpure,
	[]sema.Parameter{
		{
			Label:          sema.ArgumentLabelNotRequired,
			Identifier:     "value",
			TypeAnnotation: sema.AnyStructTypeAnnotation,
		},
	},
	sema.VoidTypeAnnotation,
)
View Source 
var PanicFunction = NewStandardLibraryStaticFunction(
	"panic",
	panicFunctionType,
	panicFunctionDocString,
	func(invocation interpreter.Invocation) interpreter.Value {
		messageValue, ok := invocation.Arguments[0].(*interpreter.StringValue)
		if !ok {
			panic(errors.NewUnreachableError())
		}
		message := messageValue.Str

		panic(PanicError{
			Message:       message,
			LocationRange: invocation.LocationRange,
		})
	},
)
View Source 
var RLPContract = StandardLibraryValue{
	Name:  RLPTypeName,
	Type:  RLPType,
	Value: rlpContractValue,
	Kind:  common.DeclarationKindContract,
}
View Source 
var RLPType = func() *sema.CompositeType {
	var t = &sema.CompositeType{
		Identifier:         RLPTypeName,
		Kind:               common.CompositeKindContract,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var RLPTypeDecodeListFunctionType = &sema.FunctionType{
	Purity: sema.FunctionPurityView,
	Parameters: []sema.Parameter{
		{
			Label:      sema.ArgumentLabelNotRequired,
			Identifier: "input",
			TypeAnnotation: sema.NewTypeAnnotation(&sema.VariableSizedType{
				Type: sema.UInt8Type,
			}),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(
		&sema.VariableSizedType{
			Type: &sema.VariableSizedType{
				Type: sema.UInt8Type,
			},
		},
	),
}
View Source 
var RLPTypeDecodeStringFunctionType = &sema.FunctionType{
	Purity: sema.FunctionPurityView,
	Parameters: []sema.Parameter{
		{
			Label:      sema.ArgumentLabelNotRequired,
			Identifier: "input",
			TypeAnnotation: sema.NewTypeAnnotation(&sema.VariableSizedType{
				Type: sema.UInt8Type,
			}),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(
		&sema.VariableSizedType{
			Type: sema.UInt8Type,
		},
	),
}
View Source 
var RLPTypeStaticType = interpreter.ConvertSemaToStaticType(nil, RLPType)
View Source 
var SignatureAlgorithmConstructor = StandardLibraryValue{
	Name: sema.SignatureAlgorithmTypeName,
	Type: cryptoAlgorithmEnumConstructorType(
		sema.SignatureAlgorithmType,
		sema.SignatureAlgorithms,
	),
	Value: signatureAlgorithmConstructorValue,
	Kind:  common.DeclarationKindEnum,
}
View Source 
var StorageCapabilityControllerDeletedEventType = newFlowEventType(
	"StorageCapabilityControllerDeleted",
	CapabilityControllerEventIDParameter,
	CapabilityControllerEventAddressParameter,
)
View Source 
var StorageCapabilityControllerIssuedEventType = newFlowEventType(
	"StorageCapabilityControllerIssued",
	CapabilityControllerEventIDParameter,
	CapabilityControllerEventAddressParameter,
	CapabilityControllerEventTypeParameter,
	sema.Parameter{
		Identifier:     "path",
		TypeAnnotation: sema.StoragePathTypeAnnotation,
	},
)
View Source 
var StorageCapabilityControllerTargetChangedEventType = newFlowEventType(
	"StorageCapabilityControllerTargetChanged",
	CapabilityControllerEventIDParameter,
	CapabilityControllerEventAddressParameter,
	sema.Parameter{
		Identifier:     "path",
		TypeAnnotation: sema.StoragePathTypeAnnotation,
	},
)
View Source 
var ZeroModuloError = errors.NewDefaultUserError("modulo argument cannot be zero")
View Source 
var _, SignatureAlgorithmCaseValues = cryptoAlgorithmEnumValueAndCaseValues(
	sema.SignatureAlgorithmType,
	sema.SignatureAlgorithms,
	NewSignatureAlgorithmCase,
)

Functions

func BorrowCapabilityController 

func BorrowCapabilityController(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	capabilityAddress interpreter.AddressValue,
	capabilityID interpreter.UInt64Value,
	wantedBorrowType *sema.ReferenceType,
	capabilityBorrowType *sema.ReferenceType,
	handler CapabilityControllerHandler,
) interpreter.ReferenceValue

func CheckCapabilityController 

func CheckCapabilityController(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	capabilityAddress interpreter.AddressValue,
	capabilityID interpreter.UInt64Value,
	wantedBorrowType *sema.ReferenceType,
	capabilityBorrowType *sema.ReferenceType,
	handler CapabilityControllerHandler,
) interpreter.BoolValue

func CodeToHashValue 

func CodeToHashValue(inter *interpreter.Interpreter, code []byte) *interpreter.ArrayValue

func GetCheckedCapabilityControllerReference 

func GetCheckedCapabilityControllerReference(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	capabilityAddressValue interpreter.AddressValue,
	capabilityIDValue interpreter.UInt64Value,
	wantedBorrowType *sema.ReferenceType,
	capabilityBorrowType *sema.ReferenceType,
	handler CapabilityControllerHandler,
) interpreter.ReferenceValue

func IssueAccountCapabilityController 

func IssueAccountCapabilityController(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	handler CapabilityControllerIssueHandler,
	address common.Address,
	borrowStaticType *interpreter.ReferenceStaticType,
) interpreter.UInt64Value

func IssueStorageCapabilityController 

func IssueStorageCapabilityController(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	handler CapabilityControllerIssueHandler,
	address common.Address,
	borrowStaticType *interpreter.ReferenceStaticType,
	targetPathValue interpreter.PathValue,
) interpreter.UInt64Value

func NewAccountKeyValue 

func NewAccountKeyValue(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	accountKey *AccountKey,
	hasher Hasher,
) interpreter.Value

func NewAccountReferenceValue 

func NewAccountReferenceValue(
	inter *interpreter.Interpreter,
	handler AccountHandler,
	addressValue interpreter.AddressValue,
	authorization interpreter.Authorization,
	locationRange interpreter.LocationRange,
) interpreter.Value

func NewAccountValue 

func NewAccountValue(
	inter *interpreter.Interpreter,
	handler AccountHandler,
	addressValue interpreter.AddressValue,
) interpreter.Value

func NewBlockValue 

func NewBlockValue(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	block Block,
) interpreter.Value

func NewHashAlgorithmCase 

func NewHashAlgorithmCase(
	rawValue interpreter.UInt8Value,
	hasher Hasher,
) (
	interpreter.MemberAccessibleValue,
	error,
)

func NewHashAlgorithmFromValue 

func NewHashAlgorithmFromValue(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	value interpreter.Value,
) sema.HashAlgorithm

func NewPublicKeyFromFields 

func NewPublicKeyFromFields(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	publicKey *interpreter.ArrayValue,
	signAlgo *interpreter.SimpleCompositeValue,
	publicKeyValidator PublicKeyValidator,
) *interpreter.CompositeValue

func NewPublicKeyValue 

func NewPublicKeyValue(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	publicKey *PublicKey,
) *interpreter.CompositeValue

func NewSignatureAlgorithmCase 

func NewSignatureAlgorithmCase(rawValue interpreter.UInt8Value) interpreter.MemberAccessibleValue

func NewTestInterpreterContractValueHandler 

func NewTestInterpreterContractValueHandler(
	testFramework TestFramework,
) interpreter.ContractValueHandlerFunc

func PublicKeyFunctions 

func PublicKeyFunctions(
	inter *interpreter.Interpreter,
	publicKeyValue *interpreter.CompositeValue,
	handler PublicKeyFunctionsHandler,
) *interpreter.FunctionOrderedMap

func RevertibleRandom 

func RevertibleRandom(
	generator RandomGenerator,
	memoryGauge common.MemoryGauge,
	returnIntegerType sema.Type,
	moduloValue interpreter.Value,
) interpreter.Value

func TestCheckerContractValueHandler 

func TestCheckerContractValueHandler(
	checker *sema.Checker,
	declaration *ast.CompositeDeclaration,
	compositeType *sema.CompositeType,
) sema.ValueDeclaration

Types

type Account 

type Account struct {
	PublicKey *PublicKey
	Address   common.Address
}

type AccountContractAdditionAndNamesHandler 

type AccountContractAdditionAndNamesHandler interface {
	AccountContractAdditionHandler
	AccountContractNamesProvider
}

type AccountContractAdditionHandler 

type AccountContractAdditionHandler interface {
	EventEmitter
	AccountContractProvider
	ParseAndCheckProgram(
		code []byte,
		location common.Location,
		getAndSetProgram bool,
	) (*interpreter.Program, error)
	// UpdateAccountContractCode updates the code associated with an account contract.
	UpdateAccountContractCode(location common.AddressLocation, code []byte) error
	RecordContractUpdate(
		location common.AddressLocation,
		value *interpreter.CompositeValue,
	)
	ContractUpdateRecorded(location common.AddressLocation) bool
	InterpretContract(
		location common.AddressLocation,
		program *interpreter.Program,
		name string,
		invocation DeployedContractConstructorInvocation,
	) (
		*interpreter.CompositeValue,
		error,
	)
	TemporarilyRecordCode(location common.AddressLocation, code []byte)

	// StartContractAddition starts adding a contract.
	StartContractAddition(location common.AddressLocation)

	// EndContractAddition ends adding the contract
	EndContractAddition(location common.AddressLocation)

	// IsContractBeingAdded checks whether a contract is being added in the current execution.
	IsContractBeingAdded(location common.AddressLocation) bool
}

type AccountContractNamesProvider 

type AccountContractNamesProvider interface {
	// GetAccountContractNames returns the names of all contracts deployed in an account.
	GetAccountContractNames(address common.Address) ([]string, error)
}

type AccountContractProvider 

type AccountContractProvider interface {
	// GetAccountContractCode returns the code associated with an account contract.
	GetAccountContractCode(location common.AddressLocation) ([]byte, error)
}

type AccountContractRemovalHandler 

type AccountContractRemovalHandler interface {
	EventEmitter
	AccountContractProvider
	RemoveAccountContractCode(location common.AddressLocation) error
	RecordContractRemoval(location common.AddressLocation)
}

type AccountContractsHandler 

type AccountContractsHandler interface {
	AccountContractProvider
	AccountContractAdditionAndNamesHandler
	AccountContractRemovalHandler
}

type AccountCreator 

type AccountCreator interface {
	StorageCommitter
	EventEmitter
	AccountHandler
	// CreateAccount creates a new account.
	CreateAccount(payer common.Address) (address common.Address, err error)
}

type AccountHandler 

type AccountHandler interface {
	AccountIDGenerator
	BalanceProvider
	AvailableBalanceProvider
	AccountStorageHandler
	AccountKeysHandler
	AccountContractsHandler
}

type AccountIDGenerator 

type AccountIDGenerator interface {
	// GenerateAccountID generates a new, *non-zero*, unique ID for the given account.
	GenerateAccountID(address common.Address) (uint64, error)
}

type AccountKey 

type AccountKey struct {
	PublicKey *PublicKey
	KeyIndex  uint32
	Weight    int
	HashAlgo  sema.HashAlgorithm
	IsRevoked bool
}

type AccountKeyAdditionHandler 

type AccountKeyAdditionHandler interface {
	EventEmitter
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	Hasher
	// AddAccountKey appends a key to an account.
	AddAccountKey(address common.Address, key *PublicKey, algo sema.HashAlgorithm, weight int) (*AccountKey, error)
}

type AccountKeyProvider 

type AccountKeyProvider interface {
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	Hasher
	// GetAccountKey retrieves a key from an account by index.
	GetAccountKey(address common.Address, index uint32) (*AccountKey, error)
	AccountKeysCount(address common.Address) (uint32, error)
}

type AccountKeyRevocationHandler 

type AccountKeyRevocationHandler interface {
	EventEmitter
	Hasher
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	// RevokeAccountKey removes a key from an account by index.
	RevokeAccountKey(address common.Address, index uint32) (*AccountKey, error)
}

type AccountKeysHandler 

type AccountKeysHandler interface {
	AccountKeyProvider
	AccountKeyAdditionHandler
	AccountKeyRevocationHandler
}

type AccountStorageHandler 

type AccountStorageHandler interface {
	StorageUsedProvider
	StorageCapacityProvider
}

type AssertionError 

type AssertionError struct {
	interpreter.LocationRange
	Message string
}

func (AssertionError) Error 

func (e AssertionError) Error() string

func (AssertionError) IsUserError 

func (AssertionError) IsUserError()

type AuthorizationMismatchError 

type AuthorizationMismatchError struct {
	ExpectedAuthorization sema.Access
	FoundAuthorization    sema.Access
	ast.Range
}

AuthorizationMismatchError is reported during a contract upgrade, when a field value is given authorization that is more powerful than that which the migration would grant it

func (*AuthorizationMismatchError) Error 

func (e *AuthorizationMismatchError) Error() string

func (*AuthorizationMismatchError) IsUserError 

func (*AuthorizationMismatchError) IsUserError()

type AvailableBalanceProvider 

type AvailableBalanceProvider interface {
	// GetAccountAvailableBalance gets accounts default flow token balance - balance that is reserved for storage.
	GetAccountAvailableBalance(address common.Address) (uint64, error)
}

type BLSContractHandler 

type BLSContractHandler interface {
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	BLSPublicKeyAggregator
	BLSSignatureAggregator
}

type BLSPoPVerifier 

type BLSPoPVerifier interface {
	// BLSVerifyPOP verifies a proof of possession (PoP) for the receiver public key.
	BLSVerifyPOP(publicKey *PublicKey, signature []byte) (bool, error)
}

type BLSPublicKeyAggregator 

type BLSPublicKeyAggregator interface {
	PublicKeySignatureVerifier
	BLSPoPVerifier
	// BLSAggregatePublicKeys aggregate multiple BLS public keys into one.
	BLSAggregatePublicKeys(publicKeys []*PublicKey) (*PublicKey, error)
}

type BLSSignatureAggregator 

type BLSSignatureAggregator interface {
	// BLSAggregateSignatures aggregate multiple BLS signatures into one.
	BLSAggregateSignatures(signatures [][]byte) ([]byte, error)
}

type BalanceProvider 

type BalanceProvider interface {
	// GetAccountBalance gets accounts default flow token balance.
	GetAccountBalance(address common.Address) (uint64, error)
}

type Block 

type Block struct {
	Height    uint64
	View      uint64
	Hash      BlockHash
	Timestamp int64
}

type BlockAtHeightProvider 

type BlockAtHeightProvider interface {
	// GetBlockAtHeight returns the block at the given height.
	GetBlockAtHeight(height uint64) (block Block, exists bool, err error)
}

type BlockHash 

type BlockHash [BlockHashLength]byte

type Blockchain 

type Blockchain interface {
	RunScript(
		inter *interpreter.Interpreter,
		code string, arguments []interpreter.Value,
	) *ScriptResult

	CreateAccount() (*Account, error)

	GetAccount(interpreter.AddressValue) (*Account, error)

	AddTransaction(
		inter *interpreter.Interpreter,
		code string,
		authorizers []common.Address,
		signers []*Account,
		arguments []interpreter.Value,
	) error

	ExecuteNextTransaction() *TransactionResult

	CommitBlock() error

	DeployContract(
		inter *interpreter.Interpreter,
		name string,
		path string,
		arguments []interpreter.Value,
	) error

	Logs() []string

	ServiceAccount() (*Account, error)

	Events(
		inter *interpreter.Interpreter,
		eventType interpreter.StaticType,
	) interpreter.Value

	Reset(uint64)

	MoveTime(int64)

	CreateSnapshot(string) error

	LoadSnapshot(string) error
}

type CadenceV042ToV1ContractUpdateValidator 

type CadenceV042ToV1ContractUpdateValidator struct {
	*TypeComparator
	// contains filtered or unexported fields
}

func NewCadenceV042ToV1ContractUpdateValidator 

func NewCadenceV042ToV1ContractUpdateValidator(
	location common.Location,
	contractName string,
	provider AccountContractNamesProvider,
	oldProgram *ast.Program,
	newProgram *interpreter.Program,
	newElaborations map[common.Location]*sema.Elaboration,
) *CadenceV042ToV1ContractUpdateValidator

NewCadenceV042ToV1ContractUpdateValidator initializes and returns a validator, without performing any validation. Invoke the `Validate()` method of the validator returned, to start validating the contract.

func (*CadenceV042ToV1ContractUpdateValidator) Location 

func (validator *CadenceV042ToV1ContractUpdateValidator) Location() common.Location

func (*CadenceV042ToV1ContractUpdateValidator) Validate 

func (validator *CadenceV042ToV1ContractUpdateValidator) Validate() error

Validate validates the contract update, and returns an error if it is an invalid update.

func (*CadenceV042ToV1ContractUpdateValidator) WithUserDefinedTypeChangeChecker 

func (validator *CadenceV042ToV1ContractUpdateValidator) WithUserDefinedTypeChangeChecker(
	typeChangeCheckFunc func(oldTypeID common.TypeID, newTypeID common.TypeID) (checked, valid bool),
) *CadenceV042ToV1ContractUpdateValidator

type CapabilityControllerHandler 

type CapabilityControllerHandler interface {
	EventEmitter
}

type CapabilityControllerIssueHandler 

type CapabilityControllerIssueHandler interface {
	EventEmitter
	AccountIDGenerator
}

type CapabilityControllersMutatedDuringIterationError 

type CapabilityControllersMutatedDuringIterationError struct {
	interpreter.LocationRange
}

CapabilityControllersMutatedDuringIterationError

func (CapabilityControllersMutatedDuringIterationError) Error 

func (CapabilityControllersMutatedDuringIterationError) Error() string

func (CapabilityControllersMutatedDuringIterationError) IsUserError 

func (CapabilityControllersMutatedDuringIterationError) IsUserError()

type CompositeValueFunctionsHandler 

type CompositeValueFunctionsHandler func(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	compositeValue *interpreter.CompositeValue,
) *interpreter.FunctionOrderedMap

type CompositeValueFunctionsHandlers 

type CompositeValueFunctionsHandlers map[common.TypeID]CompositeValueFunctionsHandler

func DefaultStandardLibraryCompositeValueFunctionHandlers 

func DefaultStandardLibraryCompositeValueFunctionHandlers(
	handler StandardLibraryHandler,
) CompositeValueFunctionsHandlers

type ConformanceMismatchError 

type ConformanceMismatchError struct {
	DeclName           string
	MissingConformance string
	ast.Range
}

ConformanceMismatchError is reported during a contract update, when the enum conformance of the new program does not match the existing one.

func (*ConformanceMismatchError) Error 

func (e *ConformanceMismatchError) Error() string

func (*ConformanceMismatchError) IsUserError 

func (*ConformanceMismatchError) IsUserError()

type ContractNotFoundError 

type ContractNotFoundError struct {
	ast.Range
}

ContractNotFoundError is reported during a contract update, if no contract can be found in the program.

func (*ContractNotFoundError) Error 

func (e *ContractNotFoundError) Error() string

func (*ContractNotFoundError) IsUserError 

func (*ContractNotFoundError) IsUserError()

type ContractRemovalError 

type ContractRemovalError struct {
	interpreter.LocationRange
	Name string
}

ContractRemovalError

func (*ContractRemovalError) Error 

func (e *ContractRemovalError) Error() string

func (*ContractRemovalError) IsUserError 

func (*ContractRemovalError) IsUserError()

type ContractUpdateError 

type ContractUpdateError struct {
	Location     common.Location
	ContractName string
	Errors       []error
}

ContractUpdateError is reported upon any invalid update to a contract or contract interface. It contains all the errors reported during the update validation.

func (*ContractUpdateError) ChildErrors 

func (e *ContractUpdateError) ChildErrors() []error

func (*ContractUpdateError) Error 

func (e *ContractUpdateError) Error() string

func (*ContractUpdateError) ImportLocation 

func (e *ContractUpdateError) ImportLocation() common.Location

func (*ContractUpdateError) IsUserError 

func (*ContractUpdateError) IsUserError()

func (*ContractUpdateError) Unwrap 

func (e *ContractUpdateError) Unwrap() []error

type ContractUpdateValidator 

type ContractUpdateValidator struct {
	*TypeComparator
	// contains filtered or unexported fields
}

func NewContractUpdateValidator 

func NewContractUpdateValidator(
	location common.Location,
	contractName string,
	accountContractNamesProvider AccountContractNamesProvider,
	oldProgram *ast.Program,
	newProgram *ast.Program,
) *ContractUpdateValidator

NewContractUpdateValidator initializes and returns a validator, without performing any validation. Invoke the `Validate()` method of the validator returned, to start validating the contract.

func (*ContractUpdateValidator) Location 

func (validator *ContractUpdateValidator) Location() common.Location

func (*ContractUpdateValidator) Validate 

func (validator *ContractUpdateValidator) Validate() error

Validate validates the contract update, and returns an error if it is an invalid update.

type CurrentBlockProvider 

type CurrentBlockProvider interface {
	BlockAtHeightProvider
	// GetCurrentBlockHeight returns the current block height.
	GetCurrentBlockHeight() (uint64, error)
}

type DeployedContractConstructorInvocation 

type DeployedContractConstructorInvocation struct {
	ContractType         *sema.CompositeType
	ConstructorArguments []interpreter.Value
	ArgumentTypes        []sema.Type
	ParameterTypes       []sema.Type
	Address              common.Address
}

type EnumCaseMismatchError 

type EnumCaseMismatchError struct {
	ExpectedName string
	FoundName    string
	ast.Range
}

EnumCaseMismatchError is reported during an enum update, when an updated enum case does not match the existing enum case.

func (*EnumCaseMismatchError) Error 

func (e *EnumCaseMismatchError) Error() string

func (*EnumCaseMismatchError) IsUserError 

func (*EnumCaseMismatchError) IsUserError()

type EventEmitter 

type EventEmitter interface {
	EmitEvent(
		inter *interpreter.Interpreter,
		locationRange interpreter.LocationRange,
		eventType *sema.CompositeType,
		values []interpreter.Value,
	)
}

type ExtraneousFieldError 

type ExtraneousFieldError struct {
	DeclName  string
	FieldName string
	ast.Range
}

ExtraneousFieldError is reported during a contract update, when an updated composite declaration has more fields than the existing declaration.

func (*ExtraneousFieldError) Error 

func (e *ExtraneousFieldError) Error() string

func (*ExtraneousFieldError) IsUserError 

func (*ExtraneousFieldError) IsUserError()

type FieldMismatchError 

type FieldMismatchError struct {
	Err       error
	DeclName  string
	FieldName string
	ast.Range
}

FieldMismatchError is reported during a contract update, when a type of a field does not match the existing type of the same field.

func (*FieldMismatchError) Error 

func (e *FieldMismatchError) Error() string

func (*FieldMismatchError) IsUserError 

func (*FieldMismatchError) IsUserError()

func (*FieldMismatchError) SecondaryError 

func (e *FieldMismatchError) SecondaryError() string

type FlowLocation 

type FlowLocation struct{}

func (FlowLocation) Description 

func (l FlowLocation) Description() string

func (FlowLocation) ID 

func (l FlowLocation) ID() string

func (FlowLocation) MarshalJSON 

func (l FlowLocation) MarshalJSON() ([]byte, error)

func (FlowLocation) QualifiedIdentifier 

func (l FlowLocation) QualifiedIdentifier(typeID common.TypeID) string

func (FlowLocation) String 

func (l FlowLocation) String() string

func (FlowLocation) TypeID 

func (l FlowLocation) TypeID(memoryGauge common.MemoryGauge, qualifiedIdentifier string) common.TypeID

type Hasher 

type Hasher interface {
	// Hash returns the digest of hashing the given data with using the given hash algorithm
	Hash(data []byte, tag string, algorithm sema.HashAlgorithm) ([]byte, error)
}

type InvalidContractArgumentError 

type InvalidContractArgumentError struct {
	ExpectedType sema.Type
	ActualType   sema.Type
	Index        int
}

func (*InvalidContractArgumentError) Error 

func (e *InvalidContractArgumentError) Error() string

func (*InvalidContractArgumentError) IsUserError 

func (*InvalidContractArgumentError) IsUserError()

type InvalidContractDeploymentError 

type InvalidContractDeploymentError struct {
	Err error
	interpreter.LocationRange
}

InvalidContractDeploymentError

func (*InvalidContractDeploymentError) ChildErrors 

func (e *InvalidContractDeploymentError) ChildErrors() []error

func (*InvalidContractDeploymentError) Error 

func (e *InvalidContractDeploymentError) Error() string

func (*InvalidContractDeploymentError) IsUserError 

func (*InvalidContractDeploymentError) IsUserError()

func (*InvalidContractDeploymentError) Unwrap 

func (e *InvalidContractDeploymentError) Unwrap() error

type InvalidContractDeploymentOriginError 

type InvalidContractDeploymentOriginError struct {
	interpreter.LocationRange
}

InvalidContractDeploymentOriginError

func (*InvalidContractDeploymentOriginError) Error 

func (*InvalidContractDeploymentOriginError) Error() string

func (*InvalidContractDeploymentOriginError) IsUserError 

func (*InvalidContractDeploymentOriginError) IsUserError()

type InvalidDeclarationKindChangeError 

type InvalidDeclarationKindChangeError struct {
	Name    string
	OldKind common.DeclarationKind
	NewKind common.DeclarationKind
	ast.Range
}

InvalidDeclarationKindChangeError is reported during a contract update, when an attempt is made to convert an existing contract to a contract interface, or vise versa.

func (*InvalidDeclarationKindChangeError) Error 

func (e *InvalidDeclarationKindChangeError) Error() string

func (*InvalidDeclarationKindChangeError) IsUserError 

func (*InvalidDeclarationKindChangeError) IsUserError()

type InvalidTypeRemovalPragmaError 

type InvalidTypeRemovalPragmaError struct {
	Expression ast.Expression
	ast.Range
}

InvalidTypeRemovalPragmaError is reported during a contract update if a malformed #removedType pragma is encountered

func (*InvalidTypeRemovalPragmaError) Error 

func (e *InvalidTypeRemovalPragmaError) Error() string

func (*InvalidTypeRemovalPragmaError) IsUserError 

func (*InvalidTypeRemovalPragmaError) IsUserError()

type Logger 

type Logger interface {
	// ProgramLog logs program logs.
	ProgramLog(message string, locationRange interpreter.LocationRange) error
}

type MissingDeclarationError 

type MissingDeclarationError struct {
	Name string
	Kind common.DeclarationKind
	ast.Range
}

MissingDeclarationError is reported during a contract update, if an existing declaration is removed.

func (*MissingDeclarationError) Error 

func (e *MissingDeclarationError) Error() string

func (*MissingDeclarationError) IsUserError 

func (*MissingDeclarationError) IsUserError()

type MissingEnumCasesError 

type MissingEnumCasesError struct {
	DeclName string
	Expected int
	Found    int
	ast.Range
}

MissingEnumCasesError is reported during an enum update, if any enum cases are removed from an existing enum.

func (*MissingEnumCasesError) Error 

func (e *MissingEnumCasesError) Error() string

func (*MissingEnumCasesError) IsUserError 

func (*MissingEnumCasesError) IsUserError()

type NameMismatchError 

type NameMismatchError struct {
	OldName string
	NewName string
	ast.Range
}

NameMismatchError is reported during a contract update, when an a composite declaration has a different name than the existing declaration.

func (*NameMismatchError) Error 

func (e *NameMismatchError) Error() string

func (*NameMismatchError) IsUserError 

func (*NameMismatchError) IsUserError()

type OldProgramError 

type OldProgramError struct {
	Err      error
	Location common.Location
}

func (*OldProgramError) ChildErrors 

func (e *OldProgramError) ChildErrors() []error

func (*OldProgramError) Error 

func (e *OldProgramError) Error() string

func (*OldProgramError) ImportLocation 

func (e *OldProgramError) ImportLocation() common.Location

func (*OldProgramError) IsUserError 

func (e *OldProgramError) IsUserError()

func (*OldProgramError) Unwrap 

func (e *OldProgramError) Unwrap() error

type PanicError 

type PanicError struct {
	interpreter.LocationRange
	Message string
}

func (PanicError) Error 

func (e PanicError) Error() string

func (PanicError) IsUserError 

func (PanicError) IsUserError()

type PublicKey 

type PublicKey struct {
	PublicKey []byte
	SignAlgo  sema.SignatureAlgorithm
}

func NewPublicKeyFromValue 

func NewPublicKeyFromValue(
	inter *interpreter.Interpreter,
	locationRange interpreter.LocationRange,
	publicKey interpreter.MemberAccessibleValue,
) (
	*PublicKey,
	error,
)

type PublicKeyFunctionsHandler 

type PublicKeyFunctionsHandler interface {
	PublicKeySignatureVerifier
	BLSPoPVerifier
}

type PublicKeySignatureVerifier 

type PublicKeySignatureVerifier interface {
	// VerifySignature returns true if the given signature was produced by signing the given tag + data
	// using the given public key, signature algorithm, and hash algorithm.
	VerifySignature(
		signature []byte,
		tag string,
		signedData []byte,
		publicKey []byte,
		signatureAlgorithm sema.SignatureAlgorithm,
		hashAlgorithm sema.HashAlgorithm,
	) (bool, error)
}

type PublicKeyValidator 

type PublicKeyValidator interface {
	// ValidatePublicKey verifies the validity of a public key.
	ValidatePublicKey(key *PublicKey) error
}

type RLPDecodeListError 

type RLPDecodeListError struct {
	interpreter.LocationRange
	Msg string
}

func (RLPDecodeListError) Error 

func (e RLPDecodeListError) Error() string

func (RLPDecodeListError) IsUserError 

func (RLPDecodeListError) IsUserError()

type RLPDecodeStringError 

type RLPDecodeStringError struct {
	interpreter.LocationRange
	Msg string
}

func (RLPDecodeStringError) Error 

func (e RLPDecodeStringError) Error() string

func (RLPDecodeStringError) IsUserError 

func (RLPDecodeStringError) IsUserError()

type RandomGenerator 

type RandomGenerator interface {
	// ReadRandom reads pseudo-random bytes into the input slice, using distributed randomness.
	// The number of bytes read is equal to the length of input slice.
	ReadRandom([]byte) error
}

type ScriptResult 

type ScriptResult struct {
	Value interpreter.Value
	Error error
}

type StandardLibraryHandler 

type StandardLibraryHandler interface {
	Logger
	RandomGenerator
	BlockAtHeightProvider
	CurrentBlockProvider
	AccountCreator
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	BLSPublicKeyAggregator
	BLSSignatureAggregator
	Hasher
}

type StandardLibraryType 

type StandardLibraryType struct {
	Type sema.Type
	Name string
	Kind common.DeclarationKind
}

func (StandardLibraryType) TypeDeclarationKind 

func (t StandardLibraryType) TypeDeclarationKind() common.DeclarationKind

func (StandardLibraryType) TypeDeclarationName 

func (t StandardLibraryType) TypeDeclarationName() string

func (StandardLibraryType) TypeDeclarationPosition 

func (StandardLibraryType) TypeDeclarationPosition() *ast.Position

func (StandardLibraryType) TypeDeclarationType 

func (t StandardLibraryType) TypeDeclarationType() sema.Type

type StandardLibraryValue 

type StandardLibraryValue struct {
	Type           sema.Type
	Value          interpreter.Value
	Position       *ast.Position
	Name           string
	DocString      string
	ArgumentLabels []string
	Kind           common.DeclarationKind
}

func DefaultScriptStandardLibraryValues 

func DefaultScriptStandardLibraryValues(handler StandardLibraryHandler) []StandardLibraryValue

func DefaultStandardLibraryValues 

func DefaultStandardLibraryValues(handler StandardLibraryHandler) []StandardLibraryValue

func NewAccountConstructor 

func NewAccountConstructor(creator AccountCreator) StandardLibraryValue

func NewBLSContract 

func NewBLSContract(
	gauge common.MemoryGauge,
	handler BLSContractHandler,
) StandardLibraryValue

func NewGetAccountFunction 

func NewGetAccountFunction(handler AccountHandler) StandardLibraryValue

func NewGetAuthAccountFunction 

func NewGetAuthAccountFunction(handler AccountHandler) StandardLibraryValue

func NewGetBlockFunction 

func NewGetBlockFunction(provider BlockAtHeightProvider) StandardLibraryValue

func NewGetCurrentBlockFunction 

func NewGetCurrentBlockFunction(provider CurrentBlockProvider) StandardLibraryValue

func NewHashAlgorithmConstructor 

func NewHashAlgorithmConstructor(hasher Hasher) StandardLibraryValue

func NewLogFunction 

func NewLogFunction(logger Logger) StandardLibraryValue

func NewPublicKeyConstructor 

func NewPublicKeyConstructor(
	publicKeyValidator PublicKeyValidator,
) StandardLibraryValue

func NewRevertibleRandomFunction 

func NewRevertibleRandomFunction(generator RandomGenerator) StandardLibraryValue

func NewStandardLibraryStaticFunction 

func NewStandardLibraryStaticFunction(
	name string,
	functionType *sema.FunctionType,
	docString string,
	function interpreter.HostFunction,
) StandardLibraryValue

NewStandardLibraryStaticFunction should only be used for creating static functions.

func (StandardLibraryValue) ValueDeclarationArgumentLabels 

func (v StandardLibraryValue) ValueDeclarationArgumentLabels() []string

func (StandardLibraryValue) ValueDeclarationDocString 

func (v StandardLibraryValue) ValueDeclarationDocString() string

func (StandardLibraryValue) ValueDeclarationIsConstant 

func (v StandardLibraryValue) ValueDeclarationIsConstant() bool

func (StandardLibraryValue) ValueDeclarationKind 

func (v StandardLibraryValue) ValueDeclarationKind() common.DeclarationKind

func (StandardLibraryValue) ValueDeclarationName 

func (v StandardLibraryValue) ValueDeclarationName() string

func (StandardLibraryValue) ValueDeclarationPosition 

func (v StandardLibraryValue) ValueDeclarationPosition() *ast.Position

func (StandardLibraryValue) ValueDeclarationType 

func (v StandardLibraryValue) ValueDeclarationType() sema.Type

func (StandardLibraryValue) ValueDeclarationValue 

func (v StandardLibraryValue) ValueDeclarationValue() interpreter.Value

type StorageCapacityProvider 

type StorageCapacityProvider interface {
	StorageCommitter
	// GetStorageCapacity gets storage capacity in bytes on the address.
	GetStorageCapacity(address common.Address) (uint64, error)
}

type StorageCommitter 

type StorageCommitter interface {
	CommitStorageTemporarily(inter *interpreter.Interpreter) error
}

type StorageUsedProvider 

type StorageUsedProvider interface {
	StorageCommitter
	// GetStorageUsed gets storage used in bytes by the address at the moment of the function call.
	GetStorageUsed(address common.Address) (uint64, error)
}

type TestContractType 

type TestContractType struct {
	Checker          *sema.Checker
	CompositeType    *sema.CompositeType
	InitializerTypes []sema.Type
	// contains filtered or unexported fields
}

func GetTestContractType 

func GetTestContractType() *TestContractType

func (*TestContractType) NewTestContract 

func (t *TestContractType) NewTestContract(
	inter *interpreter.Interpreter,
	testFramework TestFramework,
	constructor interpreter.FunctionValue,
	invocationRange ast.Range,
) (
	*interpreter.CompositeValue,
	error,
)

type TestFailedError 

type TestFailedError struct {
	Err error
}

func (TestFailedError) Error 

func (e TestFailedError) Error() string

func (TestFailedError) IsUserError 

func (TestFailedError) IsUserError()

func (TestFailedError) Unwrap 

func (e TestFailedError) Unwrap() error

type TestFramework 

type TestFramework interface {
	EmulatorBackend() Blockchain

	ReadFile(string) (string, error)
}

type TransactionResult 

type TransactionResult struct {
	Error error
}

type TypeComparator 

type TypeComparator struct {
	RootDeclIdentifier *ast.Identifier
	// contains filtered or unexported fields
}

func (*TypeComparator) CheckConstantSizedTypeEquality 

func (c *TypeComparator) CheckConstantSizedTypeEquality(expected *ast.ConstantSizedType, found ast.Type) error

func (*TypeComparator) CheckDictionaryTypeEquality 

func (c *TypeComparator) CheckDictionaryTypeEquality(expected *ast.DictionaryType, found ast.Type) error

func (*TypeComparator) CheckFunctionTypeEquality 

func (c *TypeComparator) CheckFunctionTypeEquality(expected *ast.FunctionType, found ast.Type) error

func (*TypeComparator) CheckInstantiationTypeEquality 

func (c *TypeComparator) CheckInstantiationTypeEquality(expected *ast.InstantiationType, found ast.Type) error

func (*TypeComparator) CheckIntersectionTypeEquality 

func (c *TypeComparator) CheckIntersectionTypeEquality(expected *ast.IntersectionType, found ast.Type) error

func (*TypeComparator) CheckNominalTypeEquality 

func (c *TypeComparator) CheckNominalTypeEquality(expected *ast.NominalType, found ast.Type) error

func (*TypeComparator) CheckOptionalTypeEquality 

func (c *TypeComparator) CheckOptionalTypeEquality(expected *ast.OptionalType, found ast.Type) error

func (*TypeComparator) CheckReferenceTypeEquality 

func (c *TypeComparator) CheckReferenceTypeEquality(expected *ast.ReferenceType, found ast.Type) error

func (*TypeComparator) CheckVariableSizedTypeEquality 

func (c *TypeComparator) CheckVariableSizedTypeEquality(expected *ast.VariableSizedType, found ast.Type) error

type TypeMismatchError 

type TypeMismatchError struct {
	ExpectedType ast.Type
	FoundType    ast.Type
	ast.Range
}

TypeMismatchError is reported during a contract update, when a type of the new program does not match the existing type.

func (*TypeMismatchError) Error 

func (e *TypeMismatchError) Error() string

func (*TypeMismatchError) IsUserError 

func (*TypeMismatchError) IsUserError()

type TypeRemovalPragmaRemovalError 

type TypeRemovalPragmaRemovalError struct {
	RemovedType string
}

TypeRemovalPragmaRemovalError is reported during a contract update if a #removedType pragma is removed

func (*TypeRemovalPragmaRemovalError) Error 

func (e *TypeRemovalPragmaRemovalError) Error() string

func (*TypeRemovalPragmaRemovalError) IsUserError 

func (*TypeRemovalPragmaRemovalError) IsUserError()

type UnrepresentableEntitlementsUpgrade 

type UnrepresentableEntitlementsUpgrade struct {
	Type                 sema.Type
	InvalidAuthorization sema.Access
	ast.Range
}

UnrepresentableEntitlementsUpgrade is reported during a contract upgrade, when a composite or interface type is given access modifiers on its field that would cause the migration to produce an unrepresentable entitlement set for references to that type

func (*UnrepresentableEntitlementsUpgrade) Error 

func (e *UnrepresentableEntitlementsUpgrade) Error() string

func (*UnrepresentableEntitlementsUpgrade) IsUserError 

func (*UnrepresentableEntitlementsUpgrade) IsUserError()

func (*UnrepresentableEntitlementsUpgrade) SecondaryError 

func (e *UnrepresentableEntitlementsUpgrade) SecondaryError() string

type UpdateValidator 

type UpdateValidator interface {
	ast.TypeEqualityChecker

	Validate() error

	Location() common.Location
	// contains filtered or unexported methods
}

type UseOfRemovedTypeError 

type UseOfRemovedTypeError struct {
	Declaration ast.Declaration
	ast.Range
}

UseOfRemovedTypeError is reported during a contract update if a type is encountered that is also in a #removedType pragma

func (*UseOfRemovedTypeError) Error 

func (e *UseOfRemovedTypeError) Error() string

func (*UseOfRemovedTypeError) IsUserError 

func (*UseOfRemovedTypeError) IsUserError()

Source Files

View all Source files

Directories

Path Synopsis

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.