sequences

var DeployAdvancedPoolHooks = cldf_ops.NewSequence(
	"stellar-deploy-advanced-pool-hooks",
	SequenceVersion,
	"Deploys and initializes the Advanced Pool Hooks Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployAdvancedPoolHooksInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "Advanced Pool Hooks"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, aphops.Deploy,
			stellarccip.AdvancedPoolHooksDatastoreRef(in.Qualifier), in.ChainSelector,
			componentSaltLabel("advanced-pool-hooks", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, aphops.Initialize, aphops.InitializeInput{
					ContractID:        contractID,
					Owner:             owner,
					Allowlist:         in.Allowlist,
					ThresholdAmount:   in.ThresholdAmount,
					AuthorizedCallers: in.AuthorizedCallers,
					PolicyEngine:      in.PolicyEngine,
				}, withComponentInstanceIdempotencyKey[aphops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var DeployAdvancedPoolHooksExtractor = cldf_ops.NewSequence(
	"stellar-deploy-advanced-pool-hooks-extractor",
	SequenceVersion,
	"Deploys the stateless Advanced Pool Hooks Extractor Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployAdvancedPoolHooksExtractorInput) (ComponentDeployOutput, error) {
		if err := statReleaseWasm(in.WasmPath, "Advanced Pool Hooks Extractor"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployStatelessComponent(b.GetContext(), b, deps, aphxops.Deploy,
			stellarccip.AdvancedPoolHooksExtractorDatastoreRef(), in.ChainSelector,
			"advanced-pool-hooks-extractor", in.WasmPath, in.ExistingAddresses)
	},
)

var DeployBnmToken = cldf_ops.NewSequence(
	"stellar-deploy-bnm-token",
	SequenceVersion,
	"Deploys and initializes the BnM Soroban token with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployBnmTokenContractInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		name, symbol, decimals := bnmTokenDefaults(in.Name, in.Symbol, in.Decimals)
		if err := statReleaseWasm(in.WasmPath, "BnM token"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, bnmops.Deploy,
			stellarccip.BnmTokenDatastoreRef(), in.ChainSelector, "bnm-token", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, bnmops.Initialize, bnmops.InitializeInput{
					ContractID: contractID,
					Admin:      owner,
					Name:       name,
					Symbol:     symbol,
					Decimals:   decimals,
				}, withComponentIdempotencyKey[bnmops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployBurnMintPool = cldf_ops.NewSequence(
	"stellar-deploy-burn-mint-pool",
	SequenceVersion,
	"Deploys and initializes the burn-mint token pool with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployBurnMintPoolInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "Burn-mint pool"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, bmpops.Deploy,
			stellarccip.BurnMintPoolDatastoreRef(in.Qualifier), in.ChainSelector,
			componentSaltLabel("burn-mint-pool", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, bmpops.Initialize, bmpops.InitializeInput{
					ContractID:    contractID,
					Owner:         owner,
					Token:         in.Token,
					TokenDecimals: in.TokenDecimals,
					Router:        in.Router,
					RampRegistry:  in.RampRegistry,
					RmnProxy:      in.RmnProxy,
				}, withComponentInstanceIdempotencyKey[bmpops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var DeployCCIPReceiver = cldf_ops.NewSequence(
	"stellar-deploy-ccip-receiver",
	SequenceVersion,
	"Deploys and initializes the ccip_receiver_example Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployCCIPReceiverInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "ccip_receiver_example"); err != nil {
			return ComponentDeployOutput{}, err
		}
		if in.Router == "" {
			return ComponentDeployOutput{}, fmt.Errorf("router is required: deploy Router first")
		}
		return deployAndInitialize(b.GetContext(), b, deps, recvops.Deploy,
			stellarccip.CCIPReceiverDatastoreRefWithQualifier(in.Qualifier), in.ChainSelector,
			componentSaltLabel("ccip-receiver-example", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, recvops.Initialize, recvops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					Router:     in.Router,
				}, withComponentInstanceIdempotencyKey[recvops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var DeployCommitteeVerifier = cldf_ops.NewSequence(
	"stellar-deploy-committee-verifier",
	SequenceVersion,
	"Deploys and initializes the CommitteeVerifier Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployCommitteeVerifierInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		allowlistAdmin := in.AllowlistAdmin
		if allowlistAdmin == "" {
			allowlistAdmin = owner
		}
		feeAggregator := in.FeeAggregator
		if feeAggregator == "" {
			feeAggregator = owner
		}
		versionTag := in.VersionTag
		if versionTag == [4]byte{} {
			versionTag = stellarutil.DefaultCommitteeVerifierVersionTag()
		}
		if err := statReleaseWasm(in.WasmPath, "Committee Verifier"); err != nil {
			return ComponentDeployOutput{}, err
		}
		if len(in.StorageLocations) == 0 {
			return ComponentDeployOutput{}, fmt.Errorf("storageLocations is required: pass the committee storage locations")
		}
		if in.RmnProxy == "" {
			return ComponentDeployOutput{}, fmt.Errorf("rmnProxy is required: deploy RMN Proxy first")
		}
		return deployAndInitialize(b.GetContext(), b, deps, cvops.Deploy,
			stellarccip.CommitteeVerifierDatastoreRefWithQualifier(in.Qualifier), in.ChainSelector, componentSaltLabel("committee-verifier", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, cvops.Initialize, cvops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					DynamicConfig: cvbindings.DynamicConfig{
						AllowlistAdmin: &allowlistAdmin,
						FeeAggregator:  &feeAggregator,
					},
					StorageLocations: in.StorageLocations,
					RmnProxy:         in.RmnProxy,
					VersionTag:       versionTag,
				}, withComponentInstanceIdempotencyKey[cvops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var DeployExecutor = cldf_ops.NewSequence(
	"stellar-deploy-executor",
	SequenceVersion,
	"Deploys and initializes the Executor Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployExecutorInput) (ComponentDeployOutput, error) {
		qualifier := in.Qualifier
		if qualifier == "" {
			qualifier = stellarccip.DefaultExecutorQualifier
		}
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		maxCCVs := in.MaxCCVsPerMsg
		if maxCCVs == 0 {

			maxCCVs = 10
		}
		feeAggregator := in.FeeAggregator
		if feeAggregator == "" {
			feeAggregator = owner
		}
		if err := statReleaseWasm(in.WasmPath, "Executor"); err != nil {
			return ComponentDeployOutput{}, err
		}
		out, err := deployAndInitialize(b.GetContext(), b, deps, execops.Deploy,
			stellarccip.ExecutorDatastoreRefWithQualifier(in.Qualifier), in.ChainSelector, componentSaltLabel("executor", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, execops.Initialize, execops.InitializeInput{
					ContractID:    contractID,
					Owner:         owner,
					MaxCCVsPerMsg: maxCCVs,
					DynamicConfig: executorbindings.DynamicConfig{
						AllowedFinalityConfig: in.AllowedFinalityConfig,
						CcvAllowlistEnabled:   in.CcvAllowlistEnabled,
						FeeAggregator:         &feeAggregator,
					},
				}, withComponentInstanceIdempotencyKey[execops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
		if err != nil {
			return ComponentDeployOutput{}, err
		}

		proxyRef := stellarccip.ExecutorProxyDatastoreRef(qualifier)
		refs, err := componentRefs(proxyRef, in.ChainSelector, out.ContractID)
		if err != nil {
			return ComponentDeployOutput{}, err
		}
		proxyRow := refs[0]
		if existing := findExistingComponentRef(in.ExistingAddresses, proxyRef, in.ChainSelector); existing == nil || existing.Address != proxyRow.Address {
			out.Refs = append(out.Refs, proxyRow)
		}
		return out, nil
	},
)

var DeployFeeQuoter = cldf_ops.NewSequence(
	"stellar-deploy-fee-quoter",
	SequenceVersion,
	"Deploys and initializes the FeeQuoter Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployFeeQuoterInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "FeeQuoter"); err != nil {
			return ComponentDeployOutput{}, err
		}
		if in.FeeToken == "" {
			return ComponentDeployOutput{}, fmt.Errorf("feeToken is required: pass the fee-token SAC strkey")
		}
		maxFee := in.MaxFeeJuelsPerMsg
		if maxFee == nil {
			maxFee = big.NewInt(1_000_000_000_000_000_000)
		}
		callers := in.AuthorizedCallers
		if len(callers) == 0 {
			callers = []string{owner}
		}
		return deployAndInitialize(b.GetContext(), b, deps, fqops.Deploy,
			stellarccip.FeeQuoterDatastoreRef(), in.ChainSelector, "fee-quoter", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, fqops.Initialize, fqops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					StaticConfig: fqbindings.StaticConfig{
						LinkToken:         in.FeeToken,
						MaxFeeJuelsPerMsg: maxFee,
					},
					AuthorizedCallers: callers,
				}, withComponentIdempotencyKey[fqops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployLinkToken = cldf_ops.NewSequence(
	"stellar-deploy-link-token",
	SequenceVersion,
	"Deploys and initializes the LINK Soroban token with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployLinkTokenInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		name, symbol, decimals := linkTokenDefaults(in.Name, in.Symbol, in.Decimals)
		if err := statReleaseWasm(in.WasmPath, "LINK token"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, lnkops.Deploy,
			stellarccip.LinkTokenDatastoreRef(), in.ChainSelector, "link-token", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, lnkops.Initialize, lnkops.InitializeInput{
					ContractID: contractID,
					Admin:      owner,
					Name:       name,
					Symbol:     symbol,
					Decimals:   decimals,
				}, withComponentIdempotencyKey[lnkops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployLockReleasePool = cldf_ops.NewSequence(
	"stellar-deploy-lock-release-pool",
	SequenceVersion,
	"Deploys and initializes the canonical lock-release token pool with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployLockReleasePoolInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "Lock-release pool"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, lrops.Deploy,
			stellarccip.LockReleasePoolDatastoreRef(in.Qualifier), in.ChainSelector,
			componentSaltLabel("lock-release-pool", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, lrops.Initialize, lrops.InitializeInput{
					ContractID:    contractID,
					Owner:         owner,
					Token:         in.Token,
					TokenDecimals: in.TokenDecimals,
					Router:        in.Router,
					RampRegistry:  in.RampRegistry,
					RmnProxy:      in.RmnProxy,
					LockBox:       in.LockBox,
				}, withComponentInstanceIdempotencyKey[lrops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var DeployOffRamp = cldf_ops.NewSequence(
	"stellar-deploy-offramp",
	SequenceVersion,
	"Deploys and initializes the OffRamp Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployOffRampInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "OffRamp"); err != nil {
			return ComponentDeployOutput{}, err
		}
		if in.RmnProxy == "" {
			return ComponentDeployOutput{}, fmt.Errorf("rmnProxy is required: deploy RMN Proxy first")
		}
		if in.TokenAdminRegistry == "" {
			return ComponentDeployOutput{}, fmt.Errorf("tokenAdminRegistry is required: deploy TokenAdminRegistry first")
		}
		return deployAndInitialize(b.GetContext(), b, deps, offrampops.Deploy,
			stellarccip.OffRampDatastoreRef(), in.ChainSelector, "offramp", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, offrampops.Initialize, offrampops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					Config: offrampbindings.StaticConfig{
						ChainSelector:      in.ChainSelector,
						RmnProxy:           in.RmnProxy,
						TokenAdminRegistry: in.TokenAdminRegistry,
					},
				}, withComponentIdempotencyKey[offrampops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployOnRamp = cldf_ops.NewSequence(
	"stellar-deploy-onramp",
	SequenceVersion,
	"Deploys and initializes the OnRamp Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployOnRampInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		feeAggregator := in.FeeAggregator
		if feeAggregator == "" {
			feeAggregator = owner
		}
		maxUsdCents := in.MaxUsdCentsPerMessage
		if maxUsdCents == 0 {

			maxUsdCents = 500_000
		}
		if err := statReleaseWasm(in.WasmPath, "OnRamp"); err != nil {
			return ComponentDeployOutput{}, err
		}
		if in.TokenAdminRegistry == "" {
			return ComponentDeployOutput{}, fmt.Errorf("tokenAdminRegistry is required: deploy TokenAdminRegistry first")
		}
		if in.RmnProxy == "" {
			return ComponentDeployOutput{}, fmt.Errorf("rmnProxy is required: deploy RMN Proxy first")
		}
		if in.FeeQuoter == "" {
			return ComponentDeployOutput{}, fmt.Errorf("feeQuoter is required: deploy FeeQuoter first")
		}
		return deployAndInitialize(b.GetContext(), b, deps, onrampops.Deploy,
			stellarccip.OnRampDatastoreRef(), in.ChainSelector, "onramp", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, onrampops.Initialize, onrampops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					StaticConfig: onrampbindings.StaticConfig{
						ChainSelector:         in.ChainSelector,
						TokenAdminRegistry:    in.TokenAdminRegistry,
						RmnProxy:              in.RmnProxy,
						MaxUsdCentsPerMessage: maxUsdCents,
					},
					DynamicConfig: onrampbindings.DynamicConfig{
						FeeQuoter:     in.FeeQuoter,
						FeeAggregator: feeAggregator,
					},
				}, withComponentIdempotencyKey[onrampops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployRMNProxy = cldf_ops.NewSequence(
	"stellar-deploy-rmn-proxy",
	SequenceVersion,
	"Deploys and initializes the RMN Proxy Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployRMNProxyInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "RMN Proxy"); err != nil {
			return ComponentDeployOutput{}, err
		}
		if in.RmnRemote == "" {
			return ComponentDeployOutput{}, fmt.Errorf("rmnRemote is required: deploy RMN Remote first")
		}
		return deployAndInitialize(b.GetContext(), b, deps, rmnproxyops.Deploy,
			stellarccip.RMNProxyDatastoreRef(), in.ChainSelector, "rmn-proxy", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, rmnproxyops.Initialize, rmnproxyops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					RmnRemote:  in.RmnRemote,
				}, withComponentIdempotencyKey[rmnproxyops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployRMNRemote = cldf_ops.NewSequence(
	"stellar-deploy-rmn-remote",
	SequenceVersion,
	"Deploys and initializes the RMN Remote Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployRMNRemoteInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "RMN Remote"); err != nil {
			return ComponentDeployOutput{}, err
		}
		curseAdmins := in.CurseAdmins
		if in.EnableFastCurse {
			fastQual := in.FastCurseQualifier
			if fastQual == "" {
				fastQual = cciputils.UltraFastCurseMCMSQualifier
			}
			fastTL, ok := mcmsutil.FindExistingStellarTimelock(in.ExistingAddresses, in.ChainSelector, fastQual)
			if !ok {
				return ComponentDeployOutput{}, fmt.Errorf(
					"enable fast curse: no RBACTimelock deployed for qualifier %q on chain %d; deploy the fast-curse MCMS stack first", fastQual, in.ChainSelector)
			}
			curseAdmins = append([]string{fastTL}, curseAdmins...)
		}
		return deployAndInitialize(b.GetContext(), b, deps, rmnremoteops.Deploy,
			stellarccip.RMNRemoteDatastoreRef(), in.ChainSelector, "rmn-remote", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, rmnremoteops.Initialize, rmnremoteops.InitializeInput{
					ContractID:  contractID,
					Owner:       owner,
					CurseAdmins: curseAdmins,
				}, withComponentIdempotencyKey[rmnremoteops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployRampRegistry = cldf_ops.NewSequence(
	"stellar-deploy-ramp-registry",
	SequenceVersion,
	"Deploys and initializes the RampRegistry Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployRampRegistryInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "RampRegistry"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, rrops.Deploy,
			stellarccip.RampRegistryDatastoreRef(), in.ChainSelector, "ramp-registry", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, rrops.Initialize, rrops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
				}, withComponentIdempotencyKey[rrops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployRouter = cldf_ops.NewSequence(
	"stellar-deploy-router",
	SequenceVersion,
	"Deploys and initializes the Router Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployRouterInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "Router"); err != nil {
			return ComponentDeployOutput{}, err
		}
		if in.RmnProxy == "" {
			return ComponentDeployOutput{}, fmt.Errorf("rmnProxy is required: deploy RMN Proxy first")
		}
		return deployAndInitialize(b.GetContext(), b, deps, routerops.Deploy,
			stellarccip.RouterDatastoreRef(), in.ChainSelector, "router", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, routerops.Initialize, routerops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					RmnProxy:   in.RmnProxy,
				}, withComponentIdempotencyKey[routerops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeploySiloedLockReleasePool = cldf_ops.NewSequence(
	"stellar-deploy-siloed-lock-release-pool",
	SequenceVersion,
	"Deploys and initializes the siloed lock-release token pool with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeploySiloedLockReleasePoolInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "Siloed lock-release pool"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, slrrops.Deploy,
			stellarccip.SiloedLockReleasePoolDatastoreRef(in.Qualifier), in.ChainSelector,
			componentSaltLabel("siloed-lock-release-pool", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, slrrops.Initialize, slrrops.InitializeInput{
					ContractID:    contractID,
					Owner:         owner,
					Token:         in.Token,
					TokenDecimals: in.TokenDecimals,
					Router:        in.Router,
					RampRegistry:  in.RampRegistry,
					RmnProxy:      in.RmnProxy,
				}, withComponentInstanceIdempotencyKey[slrrops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var DeployStellarCREForwarder = cldfops.NewSequence(
	"stellar-deploy-cre-forwarder",
	stellarops.ContractDeploymentVersion,
	"Deploy and bootstrap the CRE forwarder Soroban contract (deployer-owned until governance handoff)",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in DeployStellarCREForwarderInput) (seqcore.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return seqcore.OnChainOutput{}, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		qual := mcmsutil.QualifierStr(in.Qualifier)

		dep, err := stellarDeployerFromChain(ch)
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		deps := stellardeps.FromDeployer(dep)

		if existing, found := FindExistingStellarCREForwarder(in.ExistingAddresses, in.ChainSelector, qual); found {
			return seqcore.OnChainOutput{Addresses: []datastore.AddressRef{StellarCREForwarderDatastoreRef(in.ChainSelector, qual, existing)}}, nil
		}

		wasm, err := ResolveCREForwarderWasmPath()
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		depOut, err := cldfops.ExecuteOperation(b, creforwarderops.Deploy, deps, stellarops.DeployInput{
			WasmPath: wasm,
			Salt:     CREForwarderDeploySalt(in.ChainSelector, qual),
		})
		if err != nil {
			return seqcore.OnChainOutput{}, fmt.Errorf("cre forwarder deploy: %w", err)
		}
		cid := depOut.Output.ContractID

		_, err = cldfops.ExecuteOperation(b, creforwarderops.Initialize, deps, creforwarderops.InitializeInput{
			ContractID: cid,
			Owner:      dep.SignerAddress(),
		})
		if err != nil {
			return seqcore.OnChainOutput{}, fmt.Errorf("cre forwarder initialize: %w", err)
		}

		if cfg := in.InitialDONConfig; cfg != nil {
			_, err = cldfops.ExecuteOperation(b, creforwarderops.SetConfig, deps, creforwarderops.SetConfigInput{
				ContractID:    cid,
				DonID:         cfg.DonID,
				ConfigVersion: cfg.ConfigVersion,
				F:             cfg.F,
				Signers:       cfg.Signers,
			})
			if err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("cre forwarder set_config: %w", err)
			}
		}
		for _, transmitter := range in.Transmitters {
			_, err = cldfops.ExecuteOperation(b, creforwarderops.AddForwarder, deps, creforwarderops.AddForwarderInput{
				ContractID: cid,
				Forwarder:  transmitter,
			})
			if err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("cre forwarder add_forwarder %s: %w", transmitter, err)
			}
		}

		return seqcore.OnChainOutput{Addresses: []datastore.AddressRef{StellarCREForwarderDatastoreRef(in.ChainSelector, qual, cid)}}, nil
	},
)

var DeployStellarMCMS = cldfops.NewSequence(
	"stellar-deploy-mcms",
	deploy.MCMSVersion,
	"Deploy three role-specific Soroban MCMS instances and a self-administered RBACTimelock",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in deploy.MCMSDeploymentConfigPerChainWithAddress) (seqcore.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return seqcore.OnChainOutput{}, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		qual := mcmsutil.QualifierStr(in.Qualifier)
		label := mcmsutil.QualifierStr(in.Label)

		dep, err := stellarDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		deps := stellardeps.FromDeployer(dep)

		roleConfig := map[mcmsutil.MCMSRole]mcmstypes.Config{
			mcmsutil.RoleProposer:  in.Proposer,
			mcmsutil.RoleCanceller: in.Canceller,
			mcmsutil.RoleBypasser:  in.Bypasser,
		}

		addrs := map[mcmsutil.MCMSRole]string{}
		fresh := map[mcmsutil.MCMSRole]bool{}
		var mcmsWasm string
		for _, role := range mcmsutil.AllMCMSRoles {
			existing, found, err := mcmsutil.FindExistingStellarMCMSByRole(in.ExistingAddresses, in.ChainSelector, qual, role)
			if err != nil {
				return seqcore.OnChainOutput{}, err
			}
			if found {
				addrs[role] = existing
				continue
			}
			if mcmsWasm == "" {
				if mcmsWasm, err = mcmsutil.ResolveMCMSWasmPath(); err != nil {
					return seqcore.OnChainOutput{}, err
				}
			}
			salt := mcmsutil.MCMSRoleDeploySalt(in.ChainSelector, qual, label, role)
			depOut, err := cldfops.ExecuteOperation(b, mcmsops.Deploy, deps, stellarops.DeployInput{WasmPath: mcmsWasm, Salt: salt})
			if err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("mcms deploy (%s): %w", role, err)
			}
			addrs[role] = depOut.Output.ContractID
			fresh[role] = true
		}

		tlID, haveTL := mcmsutil.FindExistingStellarTimelock(in.ExistingAddresses, in.ChainSelector, qual)
		if !haveTL {
			tlWasm, err := mcmsutil.ResolveTimelockWasmPath()
			if err != nil {
				return seqcore.OnChainOutput{}, err
			}
			tlSalt := mcmsutil.TimelockDeploySalt(in.ChainSelector, qual, label)
			tlOut, err := cldfops.ExecuteOperation(b, timelockops.Deploy, deps, stellarops.DeployInput{WasmPath: tlWasm, Salt: tlSalt})
			if err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("timelock deploy: %w", err)
			}
			tlID = tlOut.Output.ContractID

			minDelay, err := timelockMinDelay(in)
			if err != nil {
				return seqcore.OnChainOutput{}, err
			}

			_, err = cldfops.ExecuteOperation(b, timelockops.Initialize, deps, timelockops.InitializeInput{
				ContractID: tlID,
				MinDelay:   minDelay,
				Proposers:  []string{addrs[mcmsutil.RoleProposer]},
				Cancellers: []string{addrs[mcmsutil.RoleProposer], addrs[mcmsutil.RoleCanceller]},
				Bypassers:  []string{addrs[mcmsutil.RoleBypasser]},
			})
			if err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("timelock initialize: %w", err)
			}
		}

		chainNetID := mcmsutil.ChainNetworkID(ch.NetworkPassphrase)
		for _, role := range mcmsutil.AllMCMSRoles {
			if !fresh[role] {
				continue
			}
			cfg := roleConfig[role]
			signerAddrs, signerGroups, gq, gp, _, err := mcmsutil.ConfigToStellarSetConfig(&cfg, true)
			if err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("mcms config (%s): %w", role, err)
			}
			_, err = cldfops.ExecuteOperation(b, mcmsops.Initialize, deps, mcmsops.InitializeInput{
				ContractID:      addrs[role],
				Owner:           tlID,
				ChainNetworkID:  chainNetID,
				SignerAddresses: signerAddrs,
				SignerGroups:    signerGroups,
				GroupQuorums:    gq,
				GroupParents:    gp,
				InstanceLabel:   role.InstanceLabel(),
			})
			if err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("mcms initialize (%s): %w", role, err)
			}
		}

		refs := make([]datastore.AddressRef, 0, len(mcmsutil.AllMCMSRoles)+1)
		for _, role := range mcmsutil.AllMCMSRoles {
			ref, err := mcmsutil.StellarMCMSRoleDatastoreRef(in.ChainSelector, qual, role, addrs[role])
			if err != nil {
				return seqcore.OnChainOutput{}, err
			}
			refs = append(refs, ref)
		}
		refs = append(refs, mcmsutil.StellarTimelockDatastoreRef(in.ChainSelector, qual, tlID))
		return seqcore.OnChainOutput{Addresses: refs}, nil
	},
)

var DeployTokenAdminRegistry = cldf_ops.NewSequence(
	"stellar-deploy-token-admin-registry",
	SequenceVersion,
	"Deploys and initializes the TokenAdminRegistry Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployTokenAdminRegistryInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "TokenAdminRegistry"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, tarops.Deploy,
			stellarccip.TokenAdminRegistryDatastoreRef(), in.ChainSelector, "token-admin-registry", in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, tarops.Initialize, tarops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
				}, withComponentIdempotencyKey[tarops.InitializeInput](in.ChainSelector))
				return err
			})
	},
)

var DeployTokenLockBox = cldf_ops.NewSequence(
	"stellar-deploy-token-lock-box",
	SequenceVersion,
	"Deploys and initializes the TokenLockBox Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployTokenLockBoxInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		if err := statReleaseWasm(in.WasmPath, "Token lock box"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, tlbops.Deploy,
			stellarccip.TokenLockBoxDatastoreRef(in.Qualifier), in.ChainSelector,
			componentSaltLabel("token-lock-box", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, tlbops.Initialize, tlbops.InitializeInput{
					ContractID: contractID,
					Owner:      owner,
					Token:      in.Token,
				}, withComponentInstanceIdempotencyKey[tlbops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var DeployVVR = cldf_ops.NewSequence(
	"stellar-deploy-versioned-verifier-resolver",
	SequenceVersion,
	"Deploys and initializes the VersionedVerifierResolver Soroban contract with skip-if-exists",
	func(b cldf_ops.Bundle, deps ComponentDeps, in DeployVVRInput) (ComponentDeployOutput, error) {
		owner := defaultOwner(in.Owner, deps.DeployerAddress)
		feeAggregator := in.FeeAggregator
		if feeAggregator == "" {
			feeAggregator = owner
		}
		if err := statReleaseWasm(in.WasmPath, "VVR"); err != nil {
			return ComponentDeployOutput{}, err
		}
		return deployAndInitialize(b.GetContext(), b, deps, vvrops.Deploy,
			stellarccip.VVRDatastoreRefWithQualifier(in.Qualifier), in.ChainSelector, componentSaltLabel("versioned-verifier-resolver", in.Qualifier), in.WasmPath, owner, in.ExistingAddresses,
			func(contractID string) error {
				_, err := execStellarCCIPOp(b, deps.StellarDeps, vvrops.Initialize, vvrops.InitializeInput{
					ContractID:    contractID,
					Owner:         owner,
					FeeAggregator: feeAggregator,
				}, withComponentInstanceIdempotencyKey[vvrops.InitializeInput](in.ChainSelector, in.Qualifier))
				return err
			})
	},
)

var ErrBaseExecutionGasCostLowered = errors.New("baseExecutionGasCost would be lowered")

var ErrZeroAddressNotAllowed = errors.New("zero address not allowed")

var FamilyDefaultAllowedFinality = func() uint32 {
	raw := finality.Config{WaitForFinality: true, WaitForSafe: true, BlockDepth: 1}.Raw()
	return binary.BigEndian.Uint32(raw[:])
}()

var FinalizeStellarDeployMCMS = cldfops.NewSequence(
	"stellar-finalize-deploy-mcms",
	deploy.MCMSVersion,
	"Verify no residual deployer authority and timelock ownership of each MCMS after deploy",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in deploy.MCMSDeploymentConfigPerChainWithAddress) (seqcore.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return seqcore.OnChainOutput{}, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		dep, err := stellarDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		if err := VerifyStellarMCMSGovernance(b.GetContext(), stellardeps.FromDeployer(dep), in.ExistingAddresses, in.ChainSelector, mcmsutil.QualifierStr(in.Qualifier), dep.SignerAddress()); err != nil {
			return seqcore.OnChainOutput{}, fmt.Errorf("mcms deployment finalize: %w", err)
		}
		return seqcore.OnChainOutput{}, nil
	},
)

var GrantAdminRoleToTimelockStellar = cldfops.NewSequence(
	"stellar-grant-admin-role-to-timelock",
	deploy.MCMSVersion,
	"No-op: Stellar has no CallProxy executor grant step (EVM parity stub)",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in deploy.GrantAdminRoleToTimelockConfigPerChainWithSelector) (seqcore.OnChainOutput, error) {
		return seqcore.OnChainOutput{}, nil
	},
)

var SequenceVersion = semver.MustParse("2.0.0")

var StellarAcceptOwnership = cldfops.NewSequence(
	"stellar-seq-accept-ownership",
	deploy.MCMSVersion,
	"Accepts Soroban contract ownership via MCMS or deployer",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarTransferOwnershipInput) (output seqcore.OnChainOutput, err error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return output, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return output, err
		}
		deps := stellardeps.FromDeployer(dep)
		deployerAddr := dep.SignerAddress()
		ctx := b.GetContext()

		for _, ref := range in.ContractRef {

			cid, err := ownership.NormalizeContractAddress(ref.Address)
			if err != nil {
				return output, fmt.Errorf("accept ownership on chain %d: %w", in.ChainSelector, err)
			}
			ref.Address = cid
			owner, err := ownership.ContractOwner(ctx, deps, ref)
			if err != nil {
				return output, fmt.Errorf("read owner %s: %w", ref.Address, err)
			}
			if owner == in.ProposedOwner {
				continue
			}
			var wo evmcontract.WriteOutput
			switch {
			case in.ProposedOwner == deployerAddr:
				if err := ownership.ExecuteAcceptOwnership(b, deps, ref); err != nil {
					return output, fmt.Errorf("accept ownership %s: %w", ref.Address, err)
				}
				wo = evmcontract.WriteOutput{
					ChainSelector: in.ChainSelector,
					ExecInfo:      &evmcontract.ExecInfo{Hash: "stellar-direct-accept"},
				}
			case in.ProposedOwner == in.GovernanceAddr:
				data, err := mcmsutil.EncodeSorobanMCMSInvokePayload("accept_ownership", nil)
				if err != nil {
					return output, err
				}
				wo = evmcontract.WriteOutput{
					ChainSelector: in.ChainSelector,
					Tx: mcmstypes.Transaction{
						OperationMetadata: mcmstypes.OperationMetadata{
							ContractType: string(ref.Type),
						},
						To:               ref.Address,
						Data:             data,
						AdditionalFields: mcmsutil.StellarMCMSTxAdditionalFields(),
					},
				}
			default:
				return output, fmt.Errorf(
					"accept routing: proposed owner %q must be deployer %q or governance %q for %s",
					in.ProposedOwner, deployerAddr, in.GovernanceAddr, ref.Address,
				)
			}
			batchOp, err := evmcontract.NewBatchOperationFromWrites([]evmcontract.WriteOutput{wo})
			if err != nil {
				return output, err
			}
			output.BatchOps = append(output.BatchOps, batchOp)
		}
		return output, nil
	},
)

var StellarActivateRMN = cldfops.NewSequence(
	"stellar-seq-activate-rmn",
	deploy.MCMSVersion,
	"Grants curse admins and transfers Stellar RMN Remote ownership to the governance timelock",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarActivateRMNInput) (output seqcore.OnChainOutput, err error) {
		govQual := in.GovernanceQualifier
		if govQual == "" {
			govQual = cciputils.RMNTimelockQualifier
		}
		fastQual := in.FastCurseQualifier
		if fastQual == "" {
			fastQual = cciputils.UltraFastCurseMCMSQualifier
		}

		govTL, ok := mcmsutil.FindExistingStellarTimelock(in.ExistingAddresses, in.ChainSelector, govQual)
		if !ok {
			return output, fmt.Errorf("no RBACTimelock deployed for qualifier %q on chain %d; deploy the %s MCMS stack first", govQual, in.ChainSelector, govQual)
		}
		fastTL, ok := mcmsutil.FindExistingStellarTimelock(in.ExistingAddresses, in.ChainSelector, fastQual)
		if !ok {
			return output, fmt.Errorf("no RBACTimelock deployed for qualifier %q on chain %d; deploy the fast-curse MCMS stack first", fastQual, in.ChainSelector)
		}

		rmnRecordedRef, opsRef, err := resolveRMNRemoteRefs(in)
		if err != nil {
			return output, err
		}

		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return output, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return output, err
		}
		deps := stellardeps.FromDeployer(dep)
		deployerAddr := dep.SignerAddress()
		ctx := b.GetContext()

		owner, err := ownership.ContractOwner(ctx, deps, opsRef)
		if err != nil {
			return output, fmt.Errorf("read RMN Remote owner: %w", err)
		}
		currentAdmins, err := ownership.CurseAdmins(ctx, deps, opsRef)
		if err != nil {
			return output, fmt.Errorf("read RMN Remote curse admins: %w", err)
		}

		added := dedupeStrkeys(append([]string{fastTL}, in.ExtraCurseAdmins...))
		if slices.Contains(added, owner) {
			b.Logger.Warnw("RMN Remote owner is being added to the curse-admin list; on chain nothing filters the owner out of the stored list", "owner", owner)
		}
		var toAdd []string
		for _, addr := range added {
			if !slices.Contains(currentAdmins, addr) {
				toAdd = append(toAdd, addr)
			}
		}

		var batchOps []mcmstypes.BatchOperation

		if len(toAdd) > 0 {
			route, err := routeCurseAdminGrant(owner, deployerAddr, govTL)
			if err != nil {
				return output, err
			}
			switch route {
			case curseAdminGrantDirect:
				if err := ownership.ExecuteApplyCurseAdminUpdates(b, deps, opsRef, toAdd, nil); err != nil {
					return output, fmt.Errorf("apply curse admin updates: %w", err)
				}
			case curseAdminGrantPropose:
				data, err := mcmsutil.EncodeSorobanMCMSInvokePayload("apply_curse_admin_updates", []xdr.ScVal{
					scval.AddressSliceToScVal(toAdd),
					scval.AddressSliceToScVal(nil),
				})
				if err != nil {
					return output, err
				}
				batchOps = append(batchOps, mcmsutil.MCMSInvokeTx(opsRef, data))
			}
		}

		if len(in.SubjectsToMigrate) > 0 {
			if owner != deployerAddr {
				return output, fmt.Errorf(
					"cannot migrate curse subjects: RMN Remote owner %q is not the deployer %q; migration must happen before ownership transfer",
					owner, deployerAddr,
				)
			}
			for _, subject := range in.SubjectsToMigrate {
				if _, err := cldfops.ExecuteOperation(b, rmnremoteops.Curse, deps, rmnremoteops.CurseInput{
					ContractID: opsRef.Address,
					Caller:     deployerAddr,
					Subjects:   [][16]byte{subject},
				}); err != nil {
					return output, fmt.Errorf("migrate curse subject %x: %w", subject, err)
				}
			}
		}

		transferReport, err := cldfops.ExecuteSequence(b, StellarTransferOwnershipViaMCMS, chains, StellarTransferOwnershipInput{
			TransferOwnershipPerChainInput: deploy.TransferOwnershipPerChainInput{
				ChainSelector: in.ChainSelector,
				ContractRef:   []datastore.AddressRef{opsRef},
				ProposedOwner: govTL,
			},
			GovernanceAddr: govTL,
		})
		if err != nil {
			return output, fmt.Errorf("transfer RMN Remote ownership: %w", err)
		}
		batchOps = append(batchOps, transferReport.Output.BatchOps...)

		output.BatchOps = batchOps

		output.Addresses = append(output.Addresses, rmnRecordedRef)
		return output, nil
	},
)

var StellarApplyDestChainConfig = cldfops.NewSequence(
	"stellar-apply-dest-chain-config",
	stellarops.ContractDeploymentVersion,
	"Apply dest chain config updates on Stellar FeeQuoter",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarApplyDestChainConfigInput) (seqcore.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[in.Selector]
		if !ok {
			return seqcore.OnChainOutput{}, fmt.Errorf("stellar chain %d not found", in.Selector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		deps := stellardeps.FromDeployer(dep)

		var cfgArgs []fqbindings.DestChainConfigArgs
		for destSel, cfg := range in.Settings {
			cfgArgs = append(cfgArgs, fqbindings.DestChainConfigArgs{
				DestChainSelector: destSel,
				Config: fqbindings.DestChainConfig{
					IsEnabled:             cfg.IsEnabled,
					MaxDataBytes:          cfg.MaxDataBytes,
					MaxPerMsgGasLimit:     cfg.MaxPerMsgGasLimit,
					DestGasOverhead:       cfg.DestGasOverhead,
					DestGasPerPayloadByte: uint32(cfg.DestGasPerPayloadByteBase),
					DefaultTokenFeeUsd:    uint32(cfg.DefaultTokenFeeUSDCents),
					DefaultTokenDestGas:   cfg.DefaultTokenDestGasOverhead,
					DefaultTxGasLimit:     cfg.DefaultTxGasLimit,
					NetworkFeeUsdCents:    uint32(cfg.NetworkFeeUSDCents),
					LinkPremiumPercent:    uint32(cfg.V2Params.LinkFeeMultiplierPercent),
				},
			})
		}
		if len(cfgArgs) == 0 {
			return seqcore.OnChainOutput{}, nil
		}
		_, err = cldfops.ExecuteOperation(b, fqops.ApplyDestChainConfigs, deps, fqops.ApplyDestChainConfigsInput{
			ContractID: in.FQContractID,
			Configs:    cfgArgs,
		})
		if err != nil {
			return seqcore.OnChainOutput{}, fmt.Errorf("apply dest chain configs on chain %d: %w", in.Selector, err)
		}
		return seqcore.OnChainOutput{}, nil
	},
)

var StellarConfigureChainForLanes = cldf_ops.NewSequence(
	"stellar-configure-chain-for-lanes",
	SequenceVersion,
	"Applies full lane wiring (OffRamp, OnRamp, Executor, FeeQuoter, Router) and committee verifier signature quorums on Stellar for each remote lane",
	func(b cldf_ops.Bundle, chains cldf_chain.BlockChains, input ccvadapters.ConfigureChainForLanesInput) (seq_core.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[input.ChainSelector]
		if !ok {
			return seq_core.OnChainOutput{}, fmt.Errorf("stellar chain not found for selector %d", input.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return seq_core.OnChainOutput{}, fmt.Errorf("stellar deployer from chain: %w", err)
		}
		return runStellarConfigureChainForLanes(b, stellardeps.FromDeployer(dep), input)
	},
)

var StellarCurse = cldfops.NewSequence(
	"stellar-curse-rmn-remote",
	stellarops.ContractDeploymentVersion,
	"Curse subjects on Stellar RMN Remote",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarCurseInput) (seqcore.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return seqcore.OnChainOutput{}, fmt.Errorf("stellar chain %d not found", in.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		deps := stellardeps.FromDeployer(dep)
		deployerAddr := dep.SignerAddress()

		caller, effectiveQualifier, err := authorizeCurseCaller(in, deployerAddr)
		if err != nil {
			return seqcore.OnChainOutput{}, fmt.Errorf(
				"curse on chain %d: %w; grant curse-admin access with apply_curse_admin_updates, or set the MCMS qualifier to a stack that is authorized",
				in.ChainSelector, err,
			)
		}

		if caller == deployerAddr {
			if _, err := cldfops.ExecuteOperation(b, rmnremoteops.Curse, deps, rmnremoteops.CurseInput{
				ContractID: in.RMNContractID,
				Caller:     caller,
				Subjects:   in.Subjects,
			}); err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("curse on chain %d: %w", in.ChainSelector, err)
			}
			return directExecOutput(b, in.ChainSelector, in.RMNContractID, "stellar-direct-curse")
		}

		if in.MCMSQualifier == "" {
			return seqcore.OnChainOutput{}, fmt.Errorf(
				"curse on chain %d cannot run directly (deployer %s is neither the owner %s nor a curse admin of RMN Remote %s) and no MCMS qualifier was supplied to route a proposal; set the qualifier %q in the MCMS config to propose via its timelock %s",
				in.ChainSelector, deployerAddr, in.Owner, in.RMNContractID, effectiveQualifier, caller,
			)
		}

		data, err := mcmsutil.EncodeSorobanMCMSInvokePayload("curse", []xdr.ScVal{
			scval.AddressToScVal(caller),
			scval.Bytes16SliceToScVal(in.Subjects),
		})
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		b.Logger.Infow("proposing stellar curse via MCMS",
			"qualifier", in.MCMSQualifier, "timelock", caller, "chainSelector", in.ChainSelector)
		return seqcore.OnChainOutput{
			BatchOps: []mcmstypes.BatchOperation{{
				ChainSelector: mcmstypes.ChainSelector(in.ChainSelector),
				Transactions: []mcmstypes.Transaction{{
					OperationMetadata: mcmstypes.OperationMetadata{ContractType: rmnremoteops.ContractType},
					To:                in.RMNContractID,
					Data:              data,
					AdditionalFields:  mcmsutil.StellarMCMSTxAdditionalFields(),
				}},
			}},
		}, nil
	},
)

var StellarDeployChainContracts = cldf_ops.NewSequence(
	"stellar-deploy-chain-contracts",
	SequenceVersion,
	"Deploys Stellar Soroban CCIP contracts via CLDF Stellar chain (adapter path); uses pre-stashed offchain topology from CCV pre-deploy when present.",
	func(b cldf_ops.Bundle, chains cldf_chain.BlockChains, input ccvadapters.DeployChainContractsInput) (DeployChainContractsOutput, error) {
		ch, ok := chains.StellarChains()[input.ChainSelector]
		if !ok {
			return DeployChainContractsOutput{}, fmt.Errorf("stellar chain not found for selector %d", input.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return DeployChainContractsOutput{}, fmt.Errorf("stellar deployer from chain: %w", err)
		}
		deps := stellardeps.FromDeployer(dep)
		lg := stellarccip.DefaultStellarDeployZerolog()
		host, err := stellarccip.NewCLDFStellarCCIPDevenvHost(ch, lg, dep)
		if err != nil {
			return DeployChainContractsOutput{}, fmt.Errorf("stellar devenv host: %w", err)
		}
		offTopo, _ := TakeStellarDeployOffchainTopologyForSelector(input.ChainSelector)
		output, err := RunStellarCCIPFullDeploy(b.GetContext(), b, deps, host, offTopo, DeployStellarCCIPInnerInput{
			ChainSelector:     input.ChainSelector,
			AllSelectors:      allSelectorsFromBlockChains(chains),
			ExistingAddresses: input.ExistingAddresses,
		})
		if err != nil {
			return DeployChainContractsOutput{}, err
		}
		return DeployChainContractsOutput{OnChainOutput: output}, nil
	},
)

var StellarSetCommitteeVerifierFinality = cldfops.NewSequence(
	"stellar-seq-set-committee-verifier-finality",
	stellarops.ContractDeploymentVersion,
	"Sets the Stellar Committee Verifier allowed finality, directly or via MCMS",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarSetCommitteeVerifierFinalityInput) (output seqcore.OnChainOutput, err error) {
		if err := in.AllowedFinality.Validate(); err != nil {
			return output, err
		}
		raw := in.AllowedFinality.Raw()
		allowed := binary.BigEndian.Uint32(raw[:])

		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return output, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return output, fmt.Errorf("stellar deployer from chain: %w", err)
		}
		deps := stellardeps.FromDeployer(dep)

		owner, err := readContractOwner(b.GetContext(), deps, in.CommitteeVerifier)
		if err != nil {
			return output, fmt.Errorf("read owner of committee verifier %s: %w", in.CommitteeVerifier.Address, err)
		}
		switch owner {
		case dep.SignerAddress():
			_, err := cldfops.ExecuteOperation(b, cvops.SetAllowedFinalityConfig, deps, cvops.SetAllowedFinalityConfigInput{
				ContractID:            in.CommitteeVerifier.Address,
				AllowedFinalityConfig: allowed,
			})
			return output, err
		case in.Timelock:
			data, err := mcmsutil.EncodeSorobanMCMSInvokePayload("set_allowed_finality_config", []xdr.ScVal{scval.Uint32ToScVal(allowed)})
			if err != nil {
				return output, fmt.Errorf("encode set_allowed_finality_config payload: %w", err)
			}
			output.BatchOps = []mcmstypes.BatchOperation{mcmsutil.MCMSInvokeTx(in.CommitteeVerifier, data)}
			return output, nil
		default:
			return output, fmt.Errorf("committee verifier %s owner %q is neither the deployer %q nor the timelock %q",
				in.CommitteeVerifier.Address, owner, dep.SignerAddress(), in.Timelock)
		}
	},
)

var StellarSetTokenTransferFee = cldfops.NewSequence(
	"stellar-set-token-transfer-fee",
	stellarops.ContractDeploymentVersion,
	"Set per-token transfer fees on Stellar FeeQuoter",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarSetTokenTransferFeeInput) (seqcore.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[in.Selector]
		if !ok {
			return seqcore.OnChainOutput{}, fmt.Errorf("stellar chain %d not found", in.Selector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		deps := stellardeps.FromDeployer(dep)

		var cfgArgs []fqbindings.TokenFeeConfigArgs
		for destSel, tokenFees := range in.Settings {
			for token, feeArgs := range tokenFees {
				if feeArgs == nil {
					continue
				}
				cfgArgs = append(cfgArgs, fqbindings.TokenFeeConfigArgs{
					DestChainSelector: destSel,
					Token:             token,
					Config: fqbindings.TokenTransferFeeConfig{
						DestBytesOverhead: feeArgs.DestBytesOverhead,
						DestGasOverhead:   feeArgs.DestGasOverhead,
						FeeUsdCents:       feeArgs.MinFeeUSDCents,
						IsEnabled:         feeArgs.IsEnabled,
					},
				})
			}
		}
		if len(cfgArgs) == 0 {
			return seqcore.OnChainOutput{}, nil
		}
		_, err = cldfops.ExecuteOperation(b, fqops.ApplyTokenFeeConfigs, deps, fqops.ApplyTokenFeeConfigsInput{
			ContractID: in.FQContractID,
			AddConfigs: cfgArgs,
		})
		if err != nil {
			return seqcore.OnChainOutput{}, fmt.Errorf("apply token fee configs on chain %d: %w", in.Selector, err)
		}
		return seqcore.OnChainOutput{}, nil
	},
)

var StellarTransferOwnershipViaMCMS = cldfops.NewSequence(
	"stellar-seq-transfer-ownership-via-mcms",
	deploy.MCMSVersion,
	"Transfers Soroban contract ownership via MCMS or deployer",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarTransferOwnershipInput) (output seqcore.OnChainOutput, err error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return output, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return output, err
		}
		deps := stellardeps.FromDeployer(dep)
		deployerAddr := dep.SignerAddress()
		ctx := b.GetContext()

		for _, ref := range in.ContractRef {

			cid, err := ownership.NormalizeContractAddress(ref.Address)
			if err != nil {
				return output, fmt.Errorf("transfer ownership on chain %d: %w", in.ChainSelector, err)
			}
			ref.Address = cid
			owner, err := ownership.ContractOwner(ctx, deps, ref)
			if err != nil {
				return output, fmt.Errorf("read owner %s: %w", ref.Address, err)
			}
			if owner == in.ProposedOwner {
				continue
			}
			var wo evmcontract.WriteOutput
			switch {
			case owner == deployerAddr:
				if err := ownership.ExecuteTransferOwnership(b, deps, ref, in.ProposedOwner); err != nil {
					return output, fmt.Errorf("transfer ownership %s: %w", ref.Address, err)
				}
				wo = evmcontract.WriteOutput{
					ChainSelector: in.ChainSelector,
					ExecInfo:      &evmcontract.ExecInfo{Hash: "stellar-direct-transfer"},
				}
			case owner == in.GovernanceAddr:
				data, err := mcmsutil.EncodeSorobanMCMSInvokePayload("transfer_ownership", []xdr.ScVal{scval.AddressToScVal(in.ProposedOwner)})
				if err != nil {
					return output, err
				}
				wo = evmcontract.WriteOutput{
					ChainSelector: in.ChainSelector,
					Tx: mcmstypes.Transaction{
						OperationMetadata: mcmstypes.OperationMetadata{
							ContractType: string(ref.Type),
						},
						To:               ref.Address,
						Data:             data,
						AdditionalFields: mcmsutil.StellarMCMSTxAdditionalFields(),
					},
				}
			default:
				return output, fmt.Errorf(
					"contract %s owner %q is neither deployer %q nor governance %q",
					ref.Address, owner, deployerAddr, in.GovernanceAddr,
				)
			}
			batchOp, err := evmcontract.NewBatchOperationFromWrites([]evmcontract.WriteOutput{wo})
			if err != nil {
				return output, err
			}
			output.BatchOps = append(output.BatchOps, batchOp)
		}
		return output, nil
	},
)

var StellarUncurse = cldfops.NewSequence(
	"stellar-uncurse-rmn-remote",
	stellarops.ContractDeploymentVersion,
	"Uncurses subjects on Stellar RMN Remote",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarCurseInput) (seqcore.OnChainOutput, error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return seqcore.OnChainOutput{}, fmt.Errorf("stellar chain %d not found", in.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		deps := stellardeps.FromDeployer(dep)
		deployerAddr := dep.SignerAddress()

		if in.Owner == "" {
			return seqcore.OnChainOutput{}, fmt.Errorf(
				"uncurse on chain %d: RMN Remote owner is unknown and uncurse is owner-only, so it cannot be routed; "+
					"the curse adapter reads the owner (failing loudly on RPC errors), so an empty Owner means the input bypassed it — populate Owner in the input", in.ChainSelector)
		}

		if deployerAddr == in.Owner {
			if _, err := cldfops.ExecuteOperation(b, rmnremoteops.Uncurse, deps, rmnremoteops.UncurseInput{
				ContractID: in.RMNContractID,
				Subjects:   in.Subjects,
			}); err != nil {
				return seqcore.OnChainOutput{}, fmt.Errorf("uncurse on chain %d: %w", in.ChainSelector, err)
			}
			return directExecOutput(b, in.ChainSelector, in.RMNContractID, "stellar-direct-uncurse")
		}

		caller, effectiveQualifier, err := authorizeCurseCaller(in, deployerAddr)
		if err != nil {
			return seqcore.OnChainOutput{}, fmt.Errorf(
				"uncurse on chain %d: %w; uncurse is owner-only — curse-admin grants cannot authorize it; transfer RMN Remote ownership, or route via the owner timelock's qualifier",
				in.ChainSelector, err,
			)
		}
		if caller != in.Owner {
			return seqcore.OnChainOutput{}, fmt.Errorf(
				"uncurse on chain %d via qualifier %q is not possible: uncurse is owner-only and fast-uncurse is not supported; route it through the owner timelock %s",
				in.ChainSelector, in.MCMSQualifier, in.Owner)
		}

		if in.MCMSQualifier == "" {
			return seqcore.OnChainOutput{}, fmt.Errorf(
				"uncurse on chain %d is owner-only and the deployer %s is not the owner %s, so it must run as a proposal via the owner timelock %s; set the MCMS qualifier %q in the MCMS config",
				in.ChainSelector, deployerAddr, in.Owner, caller, effectiveQualifier,
			)
		}

		data, err := mcmsutil.EncodeSorobanMCMSInvokePayload("uncurse", []xdr.ScVal{
			scval.Bytes16SliceToScVal(in.Subjects),
		})
		if err != nil {
			return seqcore.OnChainOutput{}, err
		}
		b.Logger.Infow("proposing stellar uncurse via MCMS",
			"qualifier", in.MCMSQualifier, "timelock", caller, "chainSelector", in.ChainSelector)
		return seqcore.OnChainOutput{
			BatchOps: []mcmstypes.BatchOperation{{
				ChainSelector: mcmstypes.ChainSelector(in.ChainSelector),
				Transactions: []mcmstypes.Transaction{{
					OperationMetadata: mcmstypes.OperationMetadata{ContractType: rmnremoteops.ContractType},
					To:                in.RMNContractID,
					Data:              data,
					AdditionalFields:  mcmsutil.StellarMCMSTxAdditionalFields(),
				}},
			}},
		}, nil
	},
)

var StellarUpgradeContractsViaMCMS = cldfops.NewSequence(
	"stellar-seq-upgrade-contracts-via-mcms",
	deploy.MCMSVersion,
	"Upgrades Soroban CCIP contracts in place via MCMS or deployer",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in StellarUpgradeContractsInput) (output seqcore.OnChainOutput, err error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return output, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		dep, err := stellardeployment.NewDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return output, err
		}
		deps := stellardeps.FromDeployer(dep)
		deployerAddr := dep.SignerAddress()
		ctx := b.GetContext()

		for _, ref := range in.ContractRef {
			wo, err := upgradeContractRef(ctx, b, deps, dep, deployerAddr, in.GovernanceAddr, in.ChainSelector, ref)
			if err != nil {
				return output, err
			}
			batchOp, err := evmcontract.NewBatchOperationFromWrites([]evmcontract.WriteOutput{wo})
			if err != nil {
				return output, err
			}
			output.BatchOps = append(output.BatchOps, batchOp)
		}
		return output, nil
	},
)

var UpdateStellarMCMSConfig = cldfops.NewSequence(
	"stellar-update-mcms-config",
	deploy.MCMSVersion,
	"Updates signer config on Stellar MCMS directly or through its timelock",
	func(b cldfops.Bundle, chains cldfchain.BlockChains, in deploy.UpdateMCMSConfigInputPerChainWithSelector) (output seqcore.OnChainOutput, err error) {
		ch, ok := chains.StellarChains()[in.ChainSelector]
		if !ok {
			return output, fmt.Errorf("stellar chain %d not found in environment", in.ChainSelector)
		}
		dep, err := stellarDeployerFromChain(ch, stellardeployment.WithLogger(b.Logger))
		if err != nil {
			return output, err
		}
		deps := stellardeps.FromDeployer(dep)
		signerAddrs, signerGroups, gq, gp, _, err := mcmsutil.ConfigToStellarSetConfig(&in.MCMConfig, true)
		if err != nil {
			return output, err
		}
		cfg := mcmsops.SetConfigInput{
			SignerAddresses: signerAddrs,
			SignerGroups:    signerGroups,
			GroupQuorums:    gq,
			GroupParents:    gp,
			ClearRoot:       true,
		}
		for _, ref := range in.MCMContracts {
			if ref.Address == "" {
				continue
			}
			governanceAddr, _ := mcmsutil.FindExistingStellarTimelock(in.ExistingAddresses, in.ChainSelector, ref.Qualifier)
			wo, err := setStellarMCMSConfigForRef(b.GetContext(), b, deps, dep.SignerAddress(), governanceAddr, in.ChainSelector, ref, cfg)
			if err != nil {
				return output, err
			}
			if wo.Executed() {
				continue
			}
			batchOp, err := evmcontract.NewBatchOperationFromWrites([]evmcontract.WriteOutput{wo})
			if err != nil {
				return output, err
			}
			output.BatchOps = append(output.BatchOps, batchOp)
		}
		return output, nil
	},
)