framework

const (
	EnvVarTestConfigs = "CTF_CONFIGS"
	//nolint
	EnvVarAWSSecretsManager = "CTF_AWS_SECRETS_MANAGER"
	// EnvVarCI this is a default env variable many CI runners use so code can detect we run in CI
	EnvVarCI = "CI"
)

const (
	DefaultConfigFilePath    = "env.toml"
	DefaultOverridesFilePath = "overrides.toml"
)

const (
	LocalGrafanaBaseURL    = "http://localhost:3000"
	LocalLokiBaseURL       = "http://localhost:3030"
	LocalPrometheusBaseURL = "http://localhost:9099"
	LocalCLNodeErrorsURL   = "http://localhost:3000/d/a7de535b-3e0f-4066-bed7-d505b6ec9ef1/cl-node-errors?orgId=1&refresh=5s"
	LocalWorkflowEngineURL = "http://localhost:3000/d/ce589a98-b4be-4f80-bed1-bc62f3e4414a/workflow-engine?orgId=1&refresh=5s&from=now-15m&to=now"
	LocalLogsURL           = "" /* 410-byte string literal not displayed */
	LocalPrometheusURL     = "" /* 350-byte string literal not displayed */
	LocalPostgresDebugURL  = "" /* 262-byte string literal not displayed */
	LocalPyroScopeURL      = "" /* 134-byte string literal not displayed */
)

const (
	// ProductDashboardUUID is a default product dashboard uuid, can be static since it's our local environment
	ProductDashboardUUID = "f8a04cef-653f-46d3-86df-87c532300672"

	ReadmeTmpl = `## Chainlink Developer Environment

This template provides a complete Chainlink development environment with pre-configured infrastructure and observability tools, enabling rapid development while maintaining high quality standards.

🔧 Address all **TODO** comments and implement "product_configuration.go"

💻 Enter the shell:
` + "```" + `bash
just cli && {{ .CLIName }} sh
` + "```" + `

🚀 Spin up the environment
` + "```" + `bash
up ↵
` + "```" + `

🔍 Implement system-level smoke tests (tests/smoke_test.go) and run them:
` + "```" + `bash
test smoke ↵
` + "```" + `

📈 Implement load/chaos tests (tests/load_test.go) and run them:
` + "```" + `bash
test load ↵
` + "```" + `

🔄 **Enforce** quality standards in CI: copy .github/workflows to your CI folder, commit and make them pass
`
	// GoModTemplate go module template
	GoModTemplate = `` /* 726-byte string literal not displayed */

	// GitIgnoreTmpl default gitignore template
	GitIgnoreTmpl = `compose/
blockscout/
env-out.toml`

	// GrafanaDashboardTmpl is a Grafana dashboard template for your product
	GrafanaDashboardTmpl = `` /* 18430-byte string literal not displayed */

	// ConfigTOMLTmpl is a default env.toml template for devenv describind components configuration
	ConfigTOMLTmpl = `` /* 782-byte string literal not displayed */

	// CILoadChaosTemplate is a continuous integration template for end-to-end load/chaos tests
	CILoadChaosTemplate = `` /* 2408-byte string literal not displayed */

	// CISmokeTmpl is a continuous integration template for end-to-end smoke tests
	CISmokeTmpl = `` /* 2424-byte string literal not displayed */

	// CompletionTmpl is a go-prompt library completion template providing interactive prompt
	CompletionTmpl = `` /* 4841-byte string literal not displayed */

	// CLITmpl is a Cobra library CLI template with basic devenv commands
	CLITmpl = `` /* 8201-byte string literal not displayed */

	// LoadTestTmpl is a load/chaos test template
	LoadTestTmpl = `` /* 2958-byte string literal not displayed */

	// SmokeTestTmpl is a smoke test template
	SmokeTestTmpl = `` /* 2085-byte string literal not displayed */

	// CLDFTmpl is a Chainlink Deployments Framework template
	CLDFTmpl = `` /* 13403-byte string literal not displayed */

	// DebugToolsTmpl is a template for various debug tools, tracing, tx debug, etc
	DebugToolsTmpl = `` /* 304-byte string literal not displayed */

	// ConfigTmpl is a template for reading and writing devenv configuration (env.toml, env-out.toml)
	ConfigTmpl = `` /* 4534-byte string literal not displayed */

	// EnvironmentTmpl is an environment.go template - main file for environment composition
	EnvironmentTmpl = `package {{ .PackageName }}

import (
	"fmt"

	"github.com/smartcontractkit/chainlink-testing-framework/framework"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/jd"

	ns "github.com/smartcontractkit/chainlink-testing-framework/framework/components/simple_node_set"
)

type Cfg struct {
    OnChain         *OnChain                ` + "`" + `toml:"on_chain"` + "`" + `
    Blockchains []*blockchain.Input ` + "`" + `toml:"blockchains" validate:"required"` + "`" + `
    NodeSets    []*ns.Input         ` + "`" + `toml:"nodesets"    validate:"required"` + "`" + `
    JD          *jd.Input           ` + "`" + `toml:"jd"` + "`" + `
}

func NewEnvironment() (*Cfg, error) {
	endTracing := tracing()
	defer endTracing()

	if err := framework.DefaultNetwork(nil); err != nil {
		return nil, err
	}
	in, err := Load[Cfg]()
	if err != nil {
		return nil, fmt.Errorf("failed to load configuration: %w", err)
	}
	_, err = blockchain.NewBlockchainNetwork(in.Blockchains[0])
	if err != nil {
		return nil, fmt.Errorf("failed to create blockchain network 1337: %w", err)
	}
	if err := DefaultProductConfiguration(in, ConfigureNodesNetwork); err != nil {
		return nil, fmt.Errorf("failed to setup default CLDF orchestration: %w", err)
	}
	_, err = ns.NewSharedDBNodeSet(in.NodeSets[0], nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create new shared db node set: %w", err)
	}
	if err := DefaultProductConfiguration(in, ConfigureProductContractsJobs); err != nil {
		return nil, fmt.Errorf("failed to setup default CLDF orchestration: %w", err)
	}
	return in, Store[Cfg](in)
}
`
	// SingleNetworkProductConfigurationTmpl is an single-network EVM product configuration template
	SingleNetworkEVMProductConfigurationTmpl = `package {{ .PackageName }}

import (
	"context"
	"fmt"
	"math/big"
	"os"
	"time"

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
	"github.com/smartcontractkit/chainlink-evm/gethwrappers/shared/generated/link_token"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/clclient"
)

const (
		ConfigureNodesNetwork ConfigPhase = iota
		ConfigureProductContractsJobs
)

var Plog = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.DebugLevel).With().Fields(map[string]any{"component": "on_chain"}).Logger()

type OnChain struct {
	LinkContractAddress              string                 ` + "`" + `toml:"link_contract_address"` + "`" + `
	CLNodesFundingETH                float64                ` + "`" + `toml:"cl_nodes_funding_eth"` + "`" + `
	CLNodesFundingLink               float64                ` + "`" + `toml:"cl_nodes_funding_link"` + "`" + `
	VerificationTimeoutSec           time.Duration          ` + "`" + `toml:"verification_timeout_sec"` + "`" + `
	ContractsConfigurationTimeoutSec time.Duration          ` + "`" + `toml:"contracts_configuration_timeout_sec"` + "`" + `
	GasSettings                      *GasSettings           ` + "`" + `toml:"gas_settings"` + "`" + `
	Verify                           bool                   ` + "`" + `toml:"verify"` + "`" + `
	DeployedContracts                *DeployedContracts     ` + "`" + `toml:"deployed_contracts"` + "`" + `
}

type DeployedContracts struct {
	SomeContractAddr string ` + "`" + `toml:"some_contract_addr"` + "`" + `
}


type GasSettings struct {
	FeeCapMultiplier int64 ` + "`" + `toml:"fee_cap_multiplier"` + "`" + `
	TipCapMultiplier int64 ` + "`" + `toml:"tip_cap_multiplier"` + "`" + `
}

type Jobs struct {
	ConfigPollIntervalSeconds time.Duration ` + "`" + `toml:"config_poll_interval_sec"` + "`" + `
	MaxTaskDurationSec        time.Duration ` + "`" + `toml:"max_task_duration_sec"` + "`" + `
}

type ConfigPhase int

// deployLinkAndMint is a universal action that deploys link token and mints required amount of LINK token for all the nodes.
func deployLinkAndMint(ctx context.Context, in *Cfg, c *ethclient.Client, auth *bind.TransactOpts, rootAddr string, transmitters []common.Address) (*link_token.LinkToken, error) {
	addr, tx, lt, err := link_token.DeployLinkToken(auth, c)
	if err != nil {
		return nil, fmt.Errorf("could not create link token contract: %w", err)
	}
	_, err = bind.WaitDeployed(ctx, c, tx)
	if err != nil {
		return nil, err
	}
	Plog.Info().Str("Address", addr.Hex()).Msg("Deployed link token contract")
	tx, err = lt.GrantMintRole(auth, common.HexToAddress(rootAddr))
	if err != nil {
		return nil, fmt.Errorf("could not grant mint role: %w", err)
	}
	_, err = bind.WaitMined(ctx, c, tx)
	if err != nil {
		return nil, err
	}
	// mint for public keys of nodes directly instead of transferring
	for _, transmitter := range transmitters {
		amount := new(big.Float).Mul(big.NewFloat(in.OnChain.CLNodesFundingLink), big.NewFloat(1e18))
		amountWei, _ := amount.Int(nil)
		Plog.Info().Msgf("Minting LINK for transmitter address: %s", transmitter.Hex())
		tx, err = lt.Mint(auth, transmitter, amountWei)
		if err != nil {
			return nil, fmt.Errorf("could not transfer link token contract: %w", err)
		}
		_, err = bind.WaitMined(ctx, c, tx)
		if err != nil {
			return nil, err
		}
	}
	return lt, nil
}


func configureContracts(in *Cfg, c *ethclient.Client, auth *bind.TransactOpts, cl []*clclient.ChainlinkClient, rootAddr string, transmitters []common.Address) (*DeployedContracts, error) {
	ctx, cancel := context.WithTimeout(context.Background(), in.OnChain.ContractsConfigurationTimeoutSec*time.Second)
	defer cancel()
	Plog.Info().Msg("Deploying LINK token contract")
	_, err := deployLinkAndMint(ctx, in, c, auth, rootAddr, transmitters)
	if err != nil {
		return nil, fmt.Errorf("could not create link token contract and mint: %w", err)
	}
	// TODO: use client and deploy your contracts
	return &DeployedContracts{
		SomeContractAddr: "",
	}, nil
}

func configureJobs(in *Cfg, clNodes []*clclient.ChainlinkClient, contracts *DeployedContracts) error {
	bootstrapNode := clNodes[0]
	workerNodes := clNodes[1:]
	// TODO: define your jobs
	job := ""
	_, _, err := bootstrapNode.CreateJobRaw(job)
	if err != nil {
		return fmt.Errorf("creating bootstrap job have failed: %w", err)
	}

	for _, chainlinkNode := range workerNodes {
		// TODO: define your job for nodes here
		job := ""
		_, _, err = chainlinkNode.CreateJobRaw(job)
		if err != nil {
			return fmt.Errorf("creating job on node have failed: %w", err)
		}
	}
	return nil
}

// DefaultProductConfiguration is default product configuration that includes:
// - Deploying required prerequisites (LINK token, shared contracts)
// - Applying product-specific changesets
// - Creating cldf.Environment, connecting to components, see *Cfg fields
// - Generating CL nodes configs
// All the data can be added *Cfg struct like and is synced between local machine and remote environment
// so later both local and remote tests can use it.
func DefaultProductConfiguration(in *Cfg, phase ConfigPhase) error {
	pkey := GetNetworkPrivateKey()
	if pkey == "" {
		return fmt.Errorf("PRIVATE_KEY environment variable not set")
	}
	switch phase {
	case ConfigureNodesNetwork:
		Plog.Info().Msg("Applying default CL nodes configuration")
		node := in.Blockchains[0].Out.Nodes[0]
		chainID := in.Blockchains[0].ChainID
		// configure node set and generate CL nodes configs
		netConfig := fmt.Sprintf(` + "`" + `
    [[EVM]]
    LogPollInterval = '1s'
    BlockBackfillDepth = 100
    LinkContractAddress = '%s'
    ChainID = '%s'
    MinIncomingConfirmations = 1
    MinContractPayment = '0.0000001 link'
    FinalityDepth = %d

    [[EVM.Nodes]]
    Name = 'default'
    WsUrl = '%s'
    HttpUrl = '%s'

    [Feature]
    FeedsManager = true
    LogPoller = true
    UICSAKeys = true
    [OCR2]
    Enabled = true
    SimulateTransactions = false
    DefaultTransactionQueueDepth = 1
    [P2P.V2]
    Enabled = true
    ListenAddresses = ['0.0.0.0:6690']

	   [Log]
   JSONConsole = true
   Level = 'debug'
   [Pyroscope]
   ServerAddress = 'http://host.docker.internal:4040'
   Environment = 'local'
   [WebServer]
    SessionTimeout = '999h0m0s'
    HTTPWriteTimeout = '3m'
   SecureCookies = false
   HTTPPort = 6688
   [WebServer.TLS]
   HTTPSPort = 0
    [WebServer.RateLimit]
    Authenticated = 5000
    Unauthenticated = 5000
   [JobPipeline]
   [JobPipeline.HTTPRequest]
   DefaultTimeout = '1m'
    [Log.File]
    MaxSize = '0b'
` + "`" + `, in.OnChain.LinkContractAddress, chainID, 5, node.InternalWSUrl, node.InternalHTTPUrl)
		for _, nodeSpec := range in.NodeSets[0].NodeSpecs {
			nodeSpec.Node.TestConfigOverrides = netConfig
		}
		Plog.Info().Msg("Nodes network configuration is finished")
	case ConfigureProductContractsJobs:
		Plog.Info().Msg("Connecting to CL nodes")
		nodeClients, err := clclient.New(in.NodeSets[0].Out.CLNodes)
		if err != nil {
			return err
		}
		transmitters := make([]common.Address, 0)
		ethKeyAddresses := make([]string, 0)
		for i, nc := range nodeClients {
			addr, err := nc.ReadPrimaryETHKey(in.Blockchains[0].ChainID)
			if err != nil {
				return err
			}
			ethKeyAddresses = append(ethKeyAddresses, addr.Attributes.Address)
			transmitters = append(transmitters, common.HexToAddress(addr.Attributes.Address))
			Plog.Info().
				Int("Idx", i).
				Str("ETH", addr.Attributes.Address).
				Msg("Node info")
		}
		// ETH examples
		c, auth, rootAddr, err := ETHClient(in)
		if err != nil {
			return fmt.Errorf("could not create basic eth client: %w", err)
		}
		for _, addr := range ethKeyAddresses {
			if err := FundNodeEIP1559(c, pkey, addr, in.OnChain.CLNodesFundingETH); err != nil {
				return err
			}
		}
		contracts, err := configureContracts(in, c, auth, nodeClients, rootAddr, transmitters)
		if err != nil {
			return err
		}
		if err := configureJobs(in, nodeClients, contracts); err != nil {
			return err
		}
		Plog.Info().Str("BootstrapNode", in.NodeSets[0].Out.CLNodes[0].Node.ExternalURL).Send()
		for _, n := range in.NodeSets[0].Out.CLNodes[1:] {
			Plog.Info().Str("Node", n.Node.ExternalURL).Send()
		}
		in.OnChain.DeployedContracts = contracts
	}
	return nil
}
`
	// JustFileTmpl is a Justfile template used for building and publishing Docker images
	JustFileTmpl = `` /* 311-byte string literal not displayed */

)

const (
	DefaultCTFLogsDir = "logs/docker"
)

const (
	DefaultConfigDir = "."
)

const (
	EnvVarIgnoreCriticalLogs = "CTF_IGNORE_CRITICAL_LOGS"
)

const (
	EnvVarLogLevel = "CTF_LOG_LEVEL"
)