Introduction
Automation often reaches an interesting point: the big things are solved, but one small recurring task still keeps pulling you back into manual work.
That was the case for me with SPS delegation.
ShardWorks was already staking my SPS rewards reliably. But because I run an SPS Validator and prefer to delegate those rewards onward to a battle account, I still had to do one part by hand: check what had accumulated and send it to the right account. It was not difficult. It was simply repetitive, easy to forget, and exactly the kind of operational friction automation should remove.
With the latest implementation, that gap is gone.
The Problem
In a multi-account Splinterlands setup, staking and delegation are not always the same thing.
One account may be the place where SPS rewards accumulate. Another may be the account that actually needs the delegated SPS for gameplay, brawls, or broader account strategy. That creates a very real workflow: rewards come in, they get staked, and then they need to be delegated onward.
Until now, that second step was still manual. That is exactly the kind of task humans should not be doing forever.
What’s New
ShardWorks now supports SPS delegation from a configurable source account to one or more target accounts as a first-class automation flow.
In practical terms, that means you can now define:
- which account acts as the SPS delegation source
- which target accounts should receive delegated SPS
- what percentage share each target should receive
Once configured, ShardWorks can calculate the currently available SPS delegation delta and distribute it automatically according to your chosen shares.
This is not a bolt-on script hidden somewhere in the background. It is a proper operation in the system, wired into configuration, scheduling, execution, UI preview, and flow visualization.
How It Works
The implementation is deliberately simple in concept, but careful in execution.
ShardWorks reads the delegation state of the configured source account by looking at the on-chain balance data it already has access to. Specifically, it compares:
- total staked SPS (SPSP)
- SPS already delegated out (SPSP-OUT)
From that, it computes the amount that is actually available to delegate right now. The available amount is split across the configured targets using percentage shares. If the result involves rounding, the remainder is absorbed in a controlled way so the full amount is allocated cleanly. And if the available amount is below the configured minimum, the operation simply skips instead of producing noise.
Each delegation is then broadcast as a Splinterlands token delegation transaction using the sm_delegate_tokens custom JSON operation.
An important design choice here is that this flow uses posting authority, not active authority. For a feature like SPS delegation, that is the right call: less privilege, less exposure, and a better fit for secure automation.
Why it matters
Useful automation is not only about flashy operations. It is often about removing the persistent little chores that sit between otherwise clean systems. Delegating validator-derived SPS onward to battle accounts is a perfect example: not glamorous, but deeply useful when you do it repeatedly.
And once that pattern exists, it opens the door to richer account-to-account automation models inside the platform.
ShardWorks is still in closed beta testing. If you're interested in trying it out, reach out in the comments.
