stdlib

Documentation

Index

• Constants
• Variables
• func ContractCode(nonFungibleTokenAddress, fungibleTokenAddress, flowTokenAddress flow.Address) []byte
• func ContractTypeForChain(chainID flow.ChainID) *sema.CompositeType
• func NewBalanceCadenceType(address common.Address) *cadence.StructType
• func NewEVMAddressCadenceType(address common.Address) *cadence.StructType
• func NewEVMBlockCadenceType(address common.Address) *cadence.StructType
• func SetupEnvironment(env runtime.Environment, internalEVMValue interpreter.Value, ...)
• type CadenceTypes
  • func CadenceTypesForChain(chainID flow.ChainID) CadenceTypes

Constants

const (
	ContractName = "EVM"

	EVMAddressTypeBytesFieldName = "bytes"

	EVMAddressTypeQualifiedIdentifier = "EVM.EVMAddress"

	EVMBalanceTypeQualifiedIdentifier = "EVM.Balance"

	EVMResultTypeQualifiedIdentifier       = "EVM.Result"
	EVMResultTypeStatusFieldName           = "status"
	EVMResultTypeErrorCodeFieldName        = "errorCode"
	EVMResultTypeErrorMessageFieldName     = "errorMessage"
	EVMResultTypeGasUsedFieldName          = "gasUsed"
	EVMResultTypeDataFieldName             = "data"
	EVMResultTypeDeployedContractFieldName = "deployedContract"

	EVMStatusTypeQualifiedIdentifier = "EVM.Status"

	EVMBlockTypeQualifiedIdentifier = "EVM.EVMBlock"
)

const EVMAddressLength = 20

const InternalEVMContractName = "InternalEVM"

const InternalEVMTypeBalanceFunctionName = "balance"

const InternalEVMTypeBatchRunFunctionName = "batchRun"

const InternalEVMTypeCallFunctionName = "call"

const InternalEVMTypeCastToAttoFLOWFunctionName = "castToAttoFLOW"

const InternalEVMTypeCastToFLOWFunctionName = "castToFLOW"

const InternalEVMTypeCodeFunctionName = "code"

const InternalEVMTypeCodeHashFunctionName = "codeHash"

const InternalEVMTypeCommitBlockProposalFunctionName = "commitBlockProposal"

const InternalEVMTypeCreateCadenceOwnedAccountFunctionName = "createCadenceOwnedAccount"

const InternalEVMTypeDecodeABIFunctionName = "decodeABI"

const InternalEVMTypeDeployFunctionName = "deploy"

const InternalEVMTypeDepositFunctionName = "deposit"

const InternalEVMTypeDryRunFunctionName = "dryRun"

const InternalEVMTypeEncodeABIFunctionName = "encodeABI"

const InternalEVMTypeGetLatestBlockFunctionName = "getLatestBlock"

const InternalEVMTypeNonceFunctionName = "nonce"

const InternalEVMTypeRunFunctionName = "run"

const InternalEVMTypeWithdrawFunctionName = "withdraw"

Variables

var (
	EVMTransactionBytesCadenceType = cadence.NewVariableSizedArrayType(cadence.UInt8Type)

	EVMTransactionBytesType       = sema.NewVariableSizedType(nil, sema.UInt8Type)
	EVMTransactionsBatchBytesType = sema.NewVariableSizedType(nil, EVMTransactionBytesType)
	EVMAddressBytesType           = sema.NewConstantSizedType(nil, sema.UInt8Type, EVMAddressLength)

	EVMAddressBytesStaticType = interpreter.ConvertSemaArrayTypeToStaticArrayType(nil, EVMAddressBytesType)

	EVMAddressBytesCadenceType = cadence.NewConstantSizedArrayType(EVMAddressLength, cadence.UInt8Type)
)

var ContractMinimalCode string

var InternalEVMContractType = func() *sema.CompositeType {
	ty := &sema.CompositeType{
		Identifier: InternalEVMContractName,
		Kind:       common.CompositeKindContract,
	}

	ty.Members = sema.MembersAsMap([]*sema.Member{
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeRunFunctionName,
			InternalEVMTypeRunFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeDryRunFunctionName,
			InternalEVMTypeDryRunFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeBatchRunFunctionName,
			InternalEVMTypeBatchRunFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeCreateCadenceOwnedAccountFunctionName,
			InternalEVMTypeCreateCadenceOwnedAccountFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeCallFunctionName,
			InternalEVMTypeCallFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeDepositFunctionName,
			InternalEVMTypeDepositFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeWithdrawFunctionName,
			InternalEVMTypeWithdrawFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeDeployFunctionName,
			InternalEVMTypeDeployFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeCastToAttoFLOWFunctionName,
			InternalEVMTypeCastToAttoFLOWFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeCastToFLOWFunctionName,
			InternalEVMTypeCastToFLOWFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeBalanceFunctionName,
			InternalEVMTypeBalanceFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeNonceFunctionName,
			InternalEVMTypeNonceFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeCodeFunctionName,
			InternalEVMTypeCodeFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeCodeHashFunctionName,
			InternalEVMTypeCodeHashFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeEncodeABIFunctionName,
			InternalEVMTypeEncodeABIFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeDecodeABIFunctionName,
			InternalEVMTypeDecodeABIFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeGetLatestBlockFunctionName,
			InternalEVMTypeGetLatestBlockFunctionType,
			"",
		),
		sema.NewUnmeteredPublicFunctionMember(
			ty,
			InternalEVMTypeCommitBlockProposalFunctionName,
			InternalEVMTypeCommitBlockProposalFunctionType,
			"",
		),
	})
	return ty
}()

var InternalEVMTypeBalanceFunctionType = &sema.FunctionType{
	Purity: sema.FunctionPurityView,
	Parameters: []sema.Parameter{
		{
			Label:          "address",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.UIntType),
}

var InternalEVMTypeBatchRunFunctionType *sema.FunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "txs",
			TypeAnnotation: sema.NewTypeAnnotation(EVMTransactionsBatchBytesType),
		},
		{
			Label:          "coinbase",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},

	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.NewVariableSizedType(nil, sema.AnyStructType)),
}

var InternalEVMTypeCallFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "from",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
		{
			Label:          "to",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
		{
			Label:          "data",
			TypeAnnotation: sema.NewTypeAnnotation(sema.ByteArrayType),
		},
		{
			Label:          "gasLimit",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UInt64Type),
		},
		{
			Label:          "value",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UIntType),
		},
	},

	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.AnyStructType),
}

var InternalEVMTypeCastToAttoFLOWFunctionType = &sema.FunctionType{
	Purity: sema.FunctionPurityView,
	Parameters: []sema.Parameter{
		{
			Label:          "balance",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UFix64Type),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.UIntType),
}

var InternalEVMTypeCastToFLOWFunctionType = &sema.FunctionType{
	Purity: sema.FunctionPurityView,
	Parameters: []sema.Parameter{
		{
			Label:          "balance",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UIntType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.UFix64Type),
}

var InternalEVMTypeCodeFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "address",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.ByteArrayType),
}

var InternalEVMTypeCodeHashFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "address",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.ByteArrayType),
}

var InternalEVMTypeCommitBlockProposalFunctionType = &sema.FunctionType{
	Parameters:           []sema.Parameter{},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.VoidType),
}

var InternalEVMTypeCreateCadenceOwnedAccountFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "uuid",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UInt64Type),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
}

var InternalEVMTypeDecodeABIFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Identifier: "types",
			TypeAnnotation: sema.NewTypeAnnotation(
				sema.NewVariableSizedType(nil, sema.MetaType),
			),
		},
		{
			Label:          "data",
			TypeAnnotation: sema.NewTypeAnnotation(sema.ByteArrayType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(
		sema.NewVariableSizedType(nil, sema.AnyStructType),
	),
}

var InternalEVMTypeDeployFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "from",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
		{
			Label:          "code",
			TypeAnnotation: sema.NewTypeAnnotation(sema.ByteArrayType),
		},
		{
			Label:          "gasLimit",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UInt64Type),
		},
		{
			Label:          "value",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UIntType),
		},
	},

	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.AnyStructType),
}

var InternalEVMTypeDepositFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "from",
			TypeAnnotation: sema.NewTypeAnnotation(sema.AnyResourceType),
		},
		{
			Label:          "to",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.VoidType),
}

var InternalEVMTypeDryRunFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "tx",
			TypeAnnotation: sema.NewTypeAnnotation(EVMTransactionBytesType),
		},
		{
			Label:          "from",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},

	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.AnyStructType),
}

var InternalEVMTypeEncodeABIFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:      sema.ArgumentLabelNotRequired,
			Identifier: "values",
			TypeAnnotation: sema.NewTypeAnnotation(
				sema.NewVariableSizedType(nil, sema.AnyStructType),
			),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.ByteArrayType),
}

var InternalEVMTypeGetLatestBlockFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{},

	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.AnyStructType),
}

var InternalEVMTypeNonceFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "address",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.UInt64Type),
}

var InternalEVMTypeRunFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "tx",
			TypeAnnotation: sema.NewTypeAnnotation(EVMTransactionBytesType),
		},
		{
			Label:          "coinbase",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
	},

	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.AnyStructType),
}

var InternalEVMTypeWithdrawFunctionType = &sema.FunctionType{
	Parameters: []sema.Parameter{
		{
			Label:          "from",
			TypeAnnotation: sema.NewTypeAnnotation(EVMAddressBytesType),
		},
		{
			Label:          "amount",
			TypeAnnotation: sema.NewTypeAnnotation(sema.UIntType),
		},
	},
	ReturnTypeAnnotation: sema.NewTypeAnnotation(sema.AnyResourceType),
}

Functions

func ContractCode

func ContractCode(nonFungibleTokenAddress, fungibleTokenAddress, flowTokenAddress flow.Address) []byte

func ContractTypeForChain

func ContractTypeForChain(chainID flow.ChainID) *sema.CompositeType

func NewBalanceCadenceType

func NewBalanceCadenceType(address common.Address) *cadence.StructType

func NewEVMAddressCadenceType

func NewEVMAddressCadenceType(address common.Address) *cadence.StructType

func NewEVMBlockCadenceType

func NewEVMBlockCadenceType(address common.Address) *cadence.StructType

func SetupEnvironment

func SetupEnvironment(
	env runtime.Environment,
	internalEVMValue interpreter.Value,
	contractAddress flow.Address,
)

Types

type CadenceTypes

type CadenceTypes struct {
	TransactionExecuted *cadence.EventType
	BlockExecuted       *cadence.EventType
}

func CadenceTypesForChain

func CadenceTypesForChain(chainID flow.ChainID) CadenceTypes