token_pool

var AddRemotePool = cldfops.NewOperation(
	"token-pool:add-remote-pool",
	stellarops.ContractDeploymentVersion,
	"Adds a remote pool entry for one remote chain on a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in AddRemotePoolInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		if err := c.AddRemotePool(b.GetContext(), in.RemoteChainSelector, in.RemotePoolAddress); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var ApplyChainUpdates = cldfops.NewOperation(
	"token-pool:apply-chain-updates",
	stellarops.ContractDeploymentVersion,
	"Adds or removes remote chain configs on a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in ApplyChainUpdatesInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(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(
	"token-pool:apply-token-fee-config-updates",
	stellarops.ContractDeploymentVersion,
	"Applies per-remote token transfer fee config updates on a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in ApplyTokenFeeConfigUpdatesInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(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("token-pool:deploy", "Deploys a Soroban token pool contract from WASM")

var GetAdvancedPoolHooks = cldfops.NewOperation(
	"token-pool:get-advanced-pool-hooks",
	stellarops.ContractDeploymentVersion,
	"Reads the AdvancedPoolHooks wired to a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetAdvancedPoolHooksInput) (*string, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetAdvancedPoolHooks(b.GetContext())
	},
)

var GetAllowedFinalityConfig = cldfops.NewOperation(
	"token-pool:get-allowed-finality-config",
	stellarops.ContractDeploymentVersion,
	"Reads the allowed finality config of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetAllowedFinalityConfigInput) (uint32, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetAllowedFinalityConfig(b.GetContext())
	},
)

var GetCurrentRateLimiterState = cldfops.NewOperation(
	"token-pool:get-current-rate-limiter-state",
	stellarops.ContractDeploymentVersion,
	"Reads the current rate limiter bucket state for one remote chain on a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetCurrentRateLimiterStateInput) (*tpoolbindings.RateLimiterState, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetCurrentRateLimiterState(b.GetContext(), in.RemoteChainSelector, in.FastFinality)
	},
)

var GetFeeAdmin = cldfops.NewOperation(
	"token-pool:get-fee-admin",
	stellarops.ContractDeploymentVersion,
	"Reads the fee admin of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetFeeAdminInput) (*string, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetFeeAdmin(b.GetContext())
	},
)

var GetRateLimitAdmin = cldfops.NewOperation(
	"token-pool:get-rate-limit-admin",
	stellarops.ContractDeploymentVersion,
	"Reads the rate-limit admin of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetRateLimitAdminInput) (*string, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetRateLimitAdmin(b.GetContext())
	},
)

var GetRemotePools = cldfops.NewOperation(
	"token-pool:get-remote-pools",
	stellarops.ContractDeploymentVersion,
	"Reads the remote pool addresses a token pool stores for one remote chain",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetRemotePoolsInput) ([][]byte, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetRemotePools(b.GetContext(), in.RemoteChainSelector)
	},
)

var GetRemoteToken = cldfops.NewOperation(
	"token-pool:get-remote-token",
	stellarops.ContractDeploymentVersion,
	"Reads the remote token bytes a token pool stores for one remote chain",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetRemoteTokenInput) ([]byte, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetRemoteToken(b.GetContext(), in.RemoteChainSelector)
	},
)

var GetRouter = cldfops.NewOperation(
	"token-pool:get-router",
	stellarops.ContractDeploymentVersion,
	"Reads the router of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetRouterInput) (*string, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetRouter(b.GetContext())
	},
)

var GetToken = cldfops.NewOperation(
	"token-pool:get-token",
	stellarops.ContractDeploymentVersion,
	"Reads the token a token pool wraps",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetTokenInput) (string, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetToken(b.GetContext())
	},
)

var GetTokenDecimals = cldfops.NewOperation(
	"token-pool:get-token-decimals",
	stellarops.ContractDeploymentVersion,
	"Reads the decimals of the token a token pool wraps",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetTokenDecimalsInput) (uint32, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetTokenDecimals(b.GetContext())
	},
)

var GetTokenTransferFeeConfig = cldfops.NewOperation(
	"token-pool:get-token-transfer-fee-config",
	stellarops.ContractDeploymentVersion,
	"Reads the token transfer fee config for one destination chain on a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in GetTokenTransferFeeConfigInput) (*tpoolbindings.TokenTransferFeeConfig, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.GetTokenTransferFeeConfig(b.GetContext(), in.DestChainSelector)
	},
)

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

var IsSupportedChain = cldfops.NewOperation(
	"token-pool:is-supported-chain",
	stellarops.ContractDeploymentVersion,
	"Reads whether a token pool supports one remote chain",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in IsSupportedChainInput) (bool, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		return c.IsSupportedChain(b.GetContext(), in.RemoteChainSelector)
	},
)

var RemoveRemotePool = cldfops.NewOperation(
	"token-pool:remove-remote-pool",
	stellarops.ContractDeploymentVersion,
	"Removes a remote pool entry for one remote chain on a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in RemoveRemotePoolInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		if err := c.RemoveRemotePool(b.GetContext(), in.RemoteChainSelector, in.RemotePoolAddress); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var SetAdvancedPoolHooks = cldfops.NewOperation(
	"token-pool:set-advanced-pool-hooks",
	stellarops.ContractDeploymentVersion,
	"Wires an issuer-owned Advanced Pool Hooks contract to a token pool (pool-owner-gated)",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetAdvancedPoolHooksInput) (stellarops.Void, error) {
		if in.Hooks == "" {
			return stellarops.Void{}, fmt.Errorf("token pool set_advanced_pool_hooks: hooks contract id is required")
		}
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		if err := c.SetAdvancedPoolHooks(b.GetContext(), in.Hooks); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var SetAllowedFinalityConfig = cldfops.NewOperation(
	"token-pool:set-allowed-finality-config",
	stellarops.ContractDeploymentVersion,
	"Sets the allowed finality config of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetAllowedFinalityConfigInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		if err := c.SetAllowedFinalityConfig(b.GetContext(), in.AllowedFinality); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var SetFeeAdmin = cldfops.NewOperation(
	"token-pool:set-fee-admin",
	stellarops.ContractDeploymentVersion,
	"Sets the fee admin of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetFeeAdminInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		if err := c.SetFeeAdmin(b.GetContext(), in.FeeAdmin); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var SetRateLimitAdmin = cldfops.NewOperation(
	"token-pool:set-rate-limit-admin",
	stellarops.ContractDeploymentVersion,
	"Sets the rate-limit admin of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetRateLimitAdminInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		if err := c.SetRateLimitAdmin(b.GetContext(), in.Admin); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)

var SetRateLimitConfig = cldfops.NewOperation(
	"token-pool:set-rate-limit-config",
	stellarops.ContractDeploymentVersion,
	"Sets outbound and inbound rate limit configs for a remote chain on a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetRateLimitConfigInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(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 SetRouter = cldfops.NewOperation(
	"token-pool:set-router",
	stellarops.ContractDeploymentVersion,
	"Sets the router of a token pool",
	func(b cldfops.Bundle, d stellardeps.StellarDeps, in SetRouterInput) (stellarops.Void, error) {
		c := tpoolbindings.NewTokenPoolClient(d.Invoker, in.ContractID)
		if err := c.SetRouter(b.GetContext(), in.Router); err != nil {
			return stellarops.Void{}, err
		}
		return stellarops.Void{}, nil
	},
)