SilverScript begins in the public record with an initial Kaspa Covenants SDK merged on January 29, 2026. PR #1 added a Rust CovenantBuilder that embeds state, accepts action data, computes a transition, reconstructs expected output scripts, and verifies them. It was compiler infrastructure and testable reference code, not a finished language or mainnet application platform.

Key takeaways

• SilverScript PR #1 merged one commit with 811 additions across seven files into the repository’s master branch.
• The new kaspa-covenant-sdk crate centered on a 764-line builder for state-aware covenant scripts.
• A transition closure consumes old state and action data, leaves new state, and lets the script verify one or more expected output script public keys.
• Tests covered a state update, a one-to-two state split, authorized outputs, large data, and full script-engine execution.
• The SDK depended on experimental Covenant++ Rusty Kaspa code and did not establish stable compiler syntax, network activation, audits, or production readiness.

What was added in SilverScript PR #1?

The official SilverScript PR #1, titled “Initial Covenants SDK to be used by the compiler,” merged on January 29, 2026. GitHub records one commit, seven changed files, 811 additions, and three deletions. Most of the implementation arrived in covenants/sdk/src/builder.rs.

The workspace gained a kaspa-covenant-sdk crate and dependencies on Rusty Kaspa’s consensus, hash, transaction-script, and script-error packages. The root configuration also raised the declared minimum Rust version to 1.85.0 and pointed the Kaspa dependencies at the experimental covpp-reset1 branch used for Covenant++ work at that time.

That dependency choice is important context: the SDK was built alongside a moving protocol implementation, not against a finalized stable interface.

What does the CovenantBuilder actually do?

The builder packages a recurring UTXO state-machine pattern. A developer supplies current state bytes and the expected action-data length. A transition closure defines how the old state and action produce new state. The builder then reconstructs the redeem script expected in a continuation output. It hashes that script, creates the corresponding pay-to-script-hash script public key, and compares it with the transaction output.

In plain English, the input’s rules can require that the next UTXO commits to the correct updated rules and state. The transaction does not mutate an account in place; it consumes an old UTXO and creates authorized successor outputs.

The lower-level fields required to carry this data through client software are covered in Kaspa Covenant Fields Across RPC, PSKT, UTXO, and JavaScript APIs.

How are absolute and authorized outputs checked?

The API offered two output targets. verify_output_spk_at checks an output at an absolute transaction index. verify_authorized_output_spk_at checks an authorized-output slot associated with the spending input. A separate option can require an exact authorized-output count.

For every requested target, the generated script reconstructs the expected redeem script around a new-state value. It hashes the script with Blake2b and wraps the hash as a P2SH script public key. It then compares that key with the selected output. A transition that creates multiple successor states must leave enough new-state blobs for every verification target.

This mechanism can express patterns such as one state continuing into one output or splitting into two controlled outputs. It does not automatically define token conservation, ownership, fees, upgrade policy, or application-specific safety; those rules still belong to the covenant design.

Why does the builder resolve placeholders iteratively?

The redeem script needs to inspect and reconstruct bytes from its own unlocking script, so it must know serialized offsets and lengths. Those values depend on the final script size, while the final size can itself change when encoded length constants change.

The builder addresses that circular dependency by emitting an initial placeholder, measuring the serialized result, recalculating the offsets, and repeating until the values stabilize. It caps the process at eight iterations and returns a PlaceholderDidNotConverge error if stabilization fails. It also returns explicit errors when state or an output target is missing.

That implementation detail is not marketing trivia. Byte-accurate construction is a security and interoperability requirement for scripts that verify reconstructed outputs.

What evidence did the initial tests provide?

The added tests exercised the builder through Rusty Kaspa’s transaction-script engine with covenant flags and context enabled. One test advanced numeric state using action data and checked an absolute output plus two authorized outputs. Another modeled a one-to-two split in which one successor received an action-selected amount and the second received the remainder.

The file also included a large-state and large-action test, helper checks for emitted opcodes, script-length assertions, and negative error paths. These tests show that the proposed builder pattern executed within the associated development code.

They are not an independent audit or a guarantee that every compiler-generated covenant is safe. Test coverage validates defined cases; formal specifications, adversarial testing, resource analysis, and application review remain necessary.

How did this relate to the Covenant++ roadmap?

The earlier Kaspa covenant ID and sequencing commitment merge added consensus-side identity and context. SilverScript’s initial SDK moved up one layer by giving a future compiler a reusable way to assemble state-transition scripts.

The PR did not include a mature language specification, parser, type system, deployment tool, wallet integration, or stable package release. Its title says the SDK was “to be used by the compiler,” which distinguishes the builder from the compiler and language experience still under development.

What are the roadmap and price implications?

A higher-level builder can reduce repetitive byte-level work and make experiments easier to reproduce. If the protocol, compiler, wallet, and audit layers mature together, such tooling could lower the barrier to UTXO applications.

The merge does not justify a KAS price forecast. One SDK commit does not measure production adoption, locked value, user demand, fee generation, security, or activation timing. It is best read as verifiable developer infrastructure within a broader experimental roadmap.

Frequently asked questions

Was SilverScript a complete programming language in PR #1?

No. The pull request added the initial covenant SDK intended for use by a compiler. It did not establish a finished language toolchain or stable application platform.

What is the difference between state and action data?

State represents data carried by the current covenant UTXO. Action data is supplied when spending it. The transition logic combines them to determine the state required in successor outputs.

Did the test suite prove the SDK was safe for funds?

No. The tests demonstrated specified execution paths in development code. Production safety also requires stable consensus rules, comprehensive review, audits, wallet protections, and careful application design.

Source and verification note

This article is based on merged kaspanet/silverscript PR #1 and its public merge commit. File counts, dependency changes, builder behavior, error cases, and tests were checked against the GitHub diff. The source establishes an initial compiler-facing SDK; it does not establish mainnet activation, a completed compiler, an independent audit, or a KAS price outcome.