lock_release_pool

var AcceptOwnership = cldfops.NewOperation(
	"lock-release-pool:accept-ownership",
	stellarops.ContractDeploymentVersion,
	"Accepts lock-release pool ownership after transfer_ownership",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in AcceptOwnershipInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.AcceptOwnership(b.GetContext()); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var ApplyChainUpdates = cldfops.NewOperation(
	"lock-release-pool:apply-chain-updates",
	stellarops.ContractDeploymentVersion,
	"Adds or removes remote chain configs on the lock-release pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in ApplyChainUpdatesInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.ApplyChainUpdates(b.GetContext(), in.Adds, in.Removes); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var ApplyTokenFeeConfigUpdates = cldfops.NewOperation(
	"lock-release-pool:apply-token-fee-config-updates",
	stellarops.ContractDeploymentVersion,
	"Applies token-transfer fee config adds/disables on the lock-release pool (EVM applyTokenTransferFeeConfigUpdates parity)",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in ApplyTokenFeeConfigUpdatesInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.ApplyTokenFeeConfigUpdates(b.GetContext(), in.Adds, in.Disables); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var Deploy = stellarops.NewDeployOperation("lock-release-pool:deploy", "Deploys the lock-release pool Soroban contract from WASM")

var GetCurrentRateLimiterState = cldfops.NewOperation(
	"lock-release-pool:get-current-rate-limiter-state",
	stellarops.ContractDeploymentVersion,
	"Reads the current outbound/inbound rate limiter bucket state for a remote chain",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetCurrentRateLimiterStateInput) (GetCurrentRateLimiterStateOutput, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		state, err := c.GetCurrentRateLimiterState(b.GetContext(), in.RemoteChainSelector, in.FastFinality)
		if err != nil {
			return GetCurrentRateLimiterStateOutput{}, err
		}
		return GetCurrentRateLimiterStateOutput{State: state}, nil
	},
)

var GetTokenTransferFeeConfig = cldfops.NewOperation(
	"lock-release-pool:get-token-transfer-fee-config",
	stellarops.ContractDeploymentVersion,
	"Reads the token-transfer fee config for a destination chain on the lock-release pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetTokenTransferFeeConfigInput) (GetTokenTransferFeeConfigOutput, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		cfg, err := c.GetTokenTransferFeeConfig(b.GetContext(), in.DestChainSelector)
		if err != nil {
			return GetTokenTransferFeeConfigOutput{}, err
		}
		return GetTokenTransferFeeConfigOutput{Config: cfg}, nil
	},
)

var Initialize = cldfops.NewOperation(
	"lock-release-pool:initialize",
	stellarops.ContractDeploymentVersion,
	"Initializes lock-release pool with owner, token, router, ramp registry, RMN proxy, and lock box",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in InitializeInput) (stellarops.Void, error) {
		if in.RmnProxy == "" {
			return stellarops.Void{}, fmt.Errorf("lock-release pool initialize: rmn_proxy is required (EVM i_rmnProxy parity, no zero address)")
		}
		if in.LockBox == "" {
			return stellarops.Void{}, fmt.Errorf("lock-release pool initialize: lock_box is required (EVM i_lockBox parity, immutable constructor arg)")
		}
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.Initialize(b.GetContext(), in.Owner, in.Token, in.TokenDecimals, in.Router, in.RampRegistry, in.RmnProxy, in.LockBox); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var SetFeeAdmin = cldfops.NewOperation(
	"lock-release-pool:set-fee-admin",
	stellarops.ContractDeploymentVersion,
	"Sets the fee-admin address on the lock-release pool (EVM setDynamicConfig feeAdmin parity)",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetFeeAdminInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.SetFeeAdmin(b.GetContext(), in.FeeAdmin); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var SetRateLimitConfig = cldfops.NewOperation(
	"lock-release-pool:set-rate-limit-config",
	stellarops.ContractDeploymentVersion,
	"Sets outbound and inbound rate limit configs for a remote chain on the lock-release pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetRateLimitConfigInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.SetRateLimitConfig(b.GetContext(), in.Caller, in.RemoteChainSelector, in.OutboundConfig, in.InboundConfig, in.FastFinality); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var TransferOwnership = cldfops.NewOperation(
	"lock-release-pool:transfer-ownership",
	stellarops.ContractDeploymentVersion,
	"Transfers lock-release pool ownership to a pending new owner",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in TransferOwnershipInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.TransferOwnership(b.GetContext(), in.NewOwner); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var Upgrade = cldfops.NewOperation(
	"lock-release-pool:upgrade",
	stellarops.ContractDeploymentVersion,
	"Upgrades the lock-release pool Soroban contract in place to a new WASM hash",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in UpgradeInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.Upgrade(b.GetContext(), in.NewWasmHash); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var WithdrawFeeTokens = cldfops.NewOperation(
	"lock-release-pool:withdraw-fee-tokens",
	stellarops.ContractDeploymentVersion,
	"Withdraws accrued fee-token balances to a recipient on the lock-release pool (EVM withdrawFeeTokens parity)",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in WithdrawFeeTokensInput) (stellarops.Void, error) {
		c := lrpbindings.NewLockReleasePoolClient(d.Invoker, in.ContractID)
		if err := c.WithdrawFeeTokens(b.GetContext(), in.Caller, in.FeeTokens, in.Recipient); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)