From 182c5bcbee1d6e6886dd41822a60218ad56b99ed Mon Sep 17 00:00:00 2001 From: Pam Selle Date: Fri, 25 Sep 2026 13:35:32 -0400 Subject: [PATCH 1/4] docs: add stellar-registry agent skill Adds skills/stellar-registry (SKILL.md + CLI and macro references) for listing on skills.stellar.org, and links it from the README. Also fixes the README quick start, which used a nonexistent `install` subcommand. Co-Authored-By: Claude Opus 5.5 --- README.md | 8 +- skills/stellar-registry/SKILL.md | 134 +++++++++++++++++++ skills/stellar-registry/references/cli.md | 62 +++++++++ skills/stellar-registry/references/macros.md | 114 ++++++++++++++++ 4 files changed, 316 insertions(+), 2 deletions(-) create mode 100644 skills/stellar-registry/SKILL.md create mode 100644 skills/stellar-registry/references/cli.md create mode 100644 skills/stellar-registry/references/macros.md diff --git a/README.md b/README.md index ae53841..33b5be4 100644 --- a/README.md +++ b/README.md @@ -42,8 +42,8 @@ stellar registry deploy \ -- \ --param1 value1 -# Install the deployed contract locally as a stellar-cli alias -stellar registry install my-contract-instance +# Create a local stellar-cli alias for the deployed contract +stellar registry create-alias my-contract-instance ``` Use `--help` on any command for full usage. See the crate README at @@ -74,6 +74,10 @@ It separates **Wasm publication** (reusable code), **contract deployment** (instances), and **local installation** (CLI aliases). The contracts themselves live in [stellar-registry/contracts](https://github.com/stellar-registry/contracts). +## Agent skill + +[`skills/stellar-registry`](./skills/stellar-registry/SKILL.md) is an [Agent Skill](https://skills.stellar.org/) that teaches coding agents the registry CLI workflow and the `import_contract!` / `import_contract_client!` / `import_asset!` macros. + ## Documentation - [CLI Commands](https://scaffoldstellar.com/docs/cli) diff --git a/skills/stellar-registry/SKILL.md b/skills/stellar-registry/SKILL.md new file mode 100644 index 0000000..b2ef1ee --- /dev/null +++ b/skills/stellar-registry/SKILL.md @@ -0,0 +1,134 @@ +--- +name: stellar-registry +description: Publish, deploy, and reuse named Soroban smart contracts through the Stellar Registry. Use when publishing a contract's wasm with a name and semantic version, deploying a named contract instance, looking up a contract id by name, aliasing a registry contract for `stellar contract invoke`, or making cross-contract calls from Rust with `stellar_registry::import_contract!`, `import_contract_client!`, or `import_asset!` (including XLM and other Stellar Asset Contracts). +--- + +# Stellar Registry + +The Stellar Registry is an on-chain contract that gives Soroban contracts human-readable names: + +- **Wasms** are published code with a name and semantic version (`my-token@1.2.0`). +- **Contracts** are deployed instances with a name (`my-token-instance`), no version. + +Two tools use it: + +1. **`stellar registry` CLI plugin**: publish, deploy, look up, upgrade. +2. **`stellar-registry` Rust crate**: macros that turn a registry name into a typed client at build time, so cross-contract calls need no hardcoded addresses. + +Browse what's already published at https://stellar.rgstry.xyz (`/wasms`, `/contracts`). + +## Setup + +```bash +# Requires the Stellar CLI (`stellar`). The registry is a plugin for it: +cargo install --locked stellar-registry-cli # or: cargo binstall stellar-registry-cli + +stellar keys generate alice --network testnet --fund # skip if you have an identity +stellar keys use alice +stellar network use testnet +``` + +Every command needs a source account and network. Set defaults as above, or pass `--source alice --network testnet`. + +## Names: verified vs. `unverified/` + +Names are `name` or `channel/name`. The default (verified) registry is **managed**: a new name must be approved by the registry manager before it can be published or deployed. For hackathons and experiments, **use the `unverified/` channel**, which is open to anyone: + +```bash +--wasm-name unverified/my-token # publish/deploy under the open channel +--contract-name unverified/my-token +``` + +Well-known verified names (e.g. `registry`, `unverified` itself) can be read by anyone without a prefix. + +## CLI workflow + +```bash +stellar contract build # produces target/wasm32v1-none/release/my_token.wasm + +# 1. Publish the wasm (name + version; both default to contract metadata if omitted) +stellar registry publish \ + --wasm target/wasm32v1-none/release/my_token.wasm \ + --wasm-name unverified/my-token --binver 0.1.0 + +# 2. Deploy a named instance. After `--`, pass the __constructor's args as flags +stellar registry deploy \ + --contract-name unverified/my-token --wasm-name unverified/my-token \ + -- --admin alice --decimal 7 +# (`-- --help` prints the constructor's arguments; `--version` pins a wasm version) + +# 3. Use it from the Stellar CLI by name +stellar registry create-alias unverified/my-token my-token +stellar contract invoke --id my-token -- --help + +# Look things up +stellar registry fetch-contract-id unverified/my-token +stellar registry current-version unverified/my-token +stellar registry download unverified/my-token -o my_token.wasm + +# Ship a new version to an existing instance +stellar registry publish --wasm ... --wasm-name unverified/my-token --binver 0.2.0 +stellar registry upgrade --contract-name unverified/my-token --wasm-name unverified/my-token +``` + +Try any write with `--dry-run` first (publish, publish-hash, register-contract, rename/update commands). Full command list: [references/cli.md](references/cli.md). + +## Calling registry contracts from Rust + +Add the crate to your contract: + +```toml +[dependencies] +stellar-registry = "0.1" +``` + +Pick the macro by what you have: + +| You have… | Use | You get | +|---|---|---| +| A **deployed contract name** | `import_contract!(env, name)` | A client already bound to its address | +| XLM or a classic asset (`xlm`, `"USDC:G..."`) | `import_contract!(env, xlm)` | `token::TokenClient` for its SAC | +| A **published wasm name** (+ optional version) | `import_contract_client!(name)` | A `name::Client` module; you supply the address | +| An asset, and you want its SAC id/admin client | `import_asset!("USDC:G...")` | Module with `contract_id`, `token_client`, `stellar_asset_client` | + +```rust +use soroban_sdk::{contract, contractimpl, Address, Env}; + +#[contract] +pub struct Tipper; + +#[contractimpl] +impl Tipper { + pub fn tip(env: &Env, from: Address, amount: i128) { + from.require_auth(); + let xlm = stellar_registry::import_contract!(env, xlm); + xlm.transfer(&from, &env.current_contract_address(), &amount); + } + + pub fn lookup(env: &Env, name: soroban_sdk::String) -> Address { + let registry = stellar_registry::import_contract!(env, registry); + registry.fetch_contract_id(&name) + } +} +``` + +**Build with the network set.** The macros resolve names at build time, reading `STELLAR_NETWORK`, which **defaults to `local`**: + +```bash +STELLAR_NETWORK=testnet stellar contract build +``` + +Details (caching, offline builds, hyphenated names, versions, unit-testing SAC calls): [references/macros.md](references/macros.md). + +## Common pitfalls + +- **Authorization failure on publish or deploy**: you used a bare name on the managed registry. Prefix with `unverified/`. +- **`Error(Contract, #N)` from the registry**: common codes are `#2` no such version, `#3` wasm name taken by another author, `#4` no such contract, `#5` contract name already deployed, `#8` version must be greater than the latest, `#9` invalid name (≤64 chars, ASCII alphanumeric/`-`/`_`, starts with a letter, not a Rust keyword), `#11` these exact wasm bytes were already published. +- **`upgrade` fails**: the registry calls the contract's own `upgrade(wasm_hash)` function, so the contract must implement one. If it exposes `admin()`, that admin must sign. +- **Macro resolves the wrong address or can't find a contract**: `STELLAR_NETWORK` wasn't set at build time. It defaults to `local`, so asset/XLM contract ids are computed for the wrong network without any error. +- **`unresolved import super` / `no soroban_sdk in the root` from `import_contract_client!`**: add `use soroban_sdk;` to the module where you call it. `import_contract!` and `import_asset!` don't need this. +- **Macro says `stellar` or the registry plugin is missing / too old**: the macros shell out to `stellar registry` during `cargo build`. Run `cargo install stellar-registry-cli --force`. +- **Hyphens or channels in a macro name**: use a string literal, `import_contract!(env, "unverified/my-token")`. The module is named with `-` replaced by `_`. +- **Redeployed a contract but still calling the old one**: the address is baked in at build time. `cargo clean` (or delete `target/stellar//deployed/`) and rebuild. +- **Contract flagged as compromised**: `fetch-contract-id`, `create-alias`, and `import_contract!` refuse it. This is intentional; use `--force` on the CLI only if you're sure. +- **There is no `stellar registry install`**. Use `create-alias`. diff --git a/skills/stellar-registry/references/cli.md b/skills/stellar-registry/references/cli.md new file mode 100644 index 0000000..904aee1 --- /dev/null +++ b/skills/stellar-registry/references/cli.md @@ -0,0 +1,62 @@ +# `stellar registry` command reference + +Every command also accepts the standard Stellar CLI network and signing flags: `--source-account/--source`, `--network`, `--rpc-url`, `--network-passphrase`, `--inclusion-fee`, `--sign-with-key`, `--sign-with-ledger`, `--sign-with-lab`. These fall back to `STELLAR_ACCOUNT`, `STELLAR_NETWORK`, etc., and to `stellar keys use` / `stellar network use` defaults. `STELLAR_REGISTRY_CONTRACT_ID` overrides the root registry address. + +Any `` can be channel-prefixed (`unverified/`) to target a sub-registry instead of the managed root registry. + +## Wasms (published code) + +| Command | Purpose | Key arguments | +|---|---|---| +| `publish` | Upload a wasm and publish it under a name + semver | `--wasm `, `--wasm-name `, `--binver ` (both read from contract metadata if omitted), `-a/--author`, `--dry-run` | +| `publish-hash` | Publish a wasm that's already uploaded on-chain | `--wasm-hash `, `--wasm-name`, `--version`, `-a/--author`, `--dry-run` | +| `current-version ` | Latest published version | | +| `fetch-hash ` | Hash of a published wasm | `--version` | +| `download ` | Fetch the wasm bytes | `--version`, `-o/--out-file` (default stdout) | + +Versions must strictly increase for a given name. Only the original author can publish new versions of a name. + +## Contracts (deployed instances) + +| Command | Purpose | Key arguments | +|---|---|---| +| `deploy` | Deploy a published wasm and register the instance by name | `--contract-name` (alias `--deploy-as`), `--wasm-name`, `--version`, `--deployer`, `-- ` | +| `deploy-unnamed` | Deploy a published wasm without registering a name | `--wasm-name`, `--version`, `--salt `, `--deployer`, `-- ` | +| `register-contract` | Name an already-deployed contract | `--contract-name`, `--contract-address `, `--owner`, `--dry-run` | +| `fetch-contract-id ` | Resolve a name to its `C...` address | `--force` (return it even if flagged compromised) | +| `create-alias [LOCAL_NAME]` | Save a local `stellar contract alias` for use with `--id ` | `-f/--force` (overwrite; allow flagged contracts) | +| `upgrade` | Upgrade a named contract to a published wasm version | `--contract-name`, `--wasm-name`, `--version` (default latest) | +| `rename-contract` | Rename a registration | `--contract-name`, `--new-name`, `--dry-run` | +| `update-contract-address` | Point a name at a different address | `--contract-name`, `--new-address`, `--dry-run` | +| `update-contract-owner` | Transfer ownership of a registration | `--contract-name`, `--new-owner`, `--dry-run` | +| `version` | Print the plugin version | | + +### Constructor arguments + +Anything after `--` on `deploy` / `deploy-unnamed` is passed to the contract's `__constructor` as `--arg value` flags. Don't name the function; it's added for you. Addresses can be identity names (`--admin alice`). Run with `-- --help` to print the constructor's signature. Contracts without a constructor take no arguments. + +### Upgrades + +`upgrade` looks up the wasm hash for `--wasm-name`/`--version`, then calls the named contract's `upgrade(wasm_hash)` function. If the contract exposes `admin()`, the registry requires that admin's signature. Otherwise the contract's own `upgrade` must enforce authorization. + +## Examples + +```bash +# Publish to the open channel and deploy with a constructor +stellar registry publish --wasm target/wasm32v1-none/release/counter.wasm \ + --wasm-name unverified/counter --binver 1.0.0 +stellar registry deploy --contract-name unverified/my-counter \ + --wasm-name unverified/counter -- --owner alice + +# Deploy a specific older version +stellar registry deploy --contract-name unverified/counter-v1 \ + --wasm-name unverified/counter --version 1.0.0 -- --owner alice + +# Give an existing contract a registry name +stellar registry register-contract --contract-name unverified/my-dao \ + --contract-address CABC...XYZ + +# Use a registry contract from the CLI +stellar registry create-alias unverified/my-counter counter +stellar contract invoke --id counter -- increment +``` diff --git a/skills/stellar-registry/references/macros.md b/skills/stellar-registry/references/macros.md new file mode 100644 index 0000000..b631121 --- /dev/null +++ b/skills/stellar-registry/references/macros.md @@ -0,0 +1,114 @@ +# `stellar-registry` macros + +```toml +[dependencies] +soroban-sdk = "..." # your existing version; generated code uses your `soroban_sdk` +stellar-registry = "0.1" +``` + +All three macros run at **build time**. `import_contract!` and `import_contract_client!` shell out to `stellar registry` (the `stellar-registry-cli` plugin) and `stellar contract fetch`, so both `stellar` and the plugin must be on `PATH` when you `cargo build`. A default identity (`stellar keys use `) must also be set, since the lookups need a source account. + +**Network selection:** set `STELLAR_NETWORK` (e.g. `testnet`, `mainnet`) in the build environment. It defaults to `local`. It selects the cache directory and the network passphrase used to compute asset contract ids. + +```bash +STELLAR_NETWORK=testnet stellar contract build +``` + +## `import_contract!(env, name)`: deployed contract → bound client + +```rust +let dao = stellar_registry::import_contract!(env, our_dao); // env: &Env +dao.create_proposal(/* ... */); + +let game = stellar_registry::import_contract!(env, "unverified/my-game"); +``` + +- `name` is a bare ident or a string literal, optionally channel-prefixed. Use a string for hyphens or `/`. The generated module uses `_` in place of `-`. +- **No `@version`**: deployed contracts don't have versions. +- Resolves at build time: + - **address** via `stellar registry fetch-contract-id`, cached at `target/stellar//deployed/.id` (`__.id` for prefixed names). While online, the cache is ignored and the lookup always runs, so a contract **flagged as compromised fails compilation**. + - **wasm** via `stellar contract fetch --id
` (the contract's *actual* on-chain code), cached beside the id. So it works even if the wasm was never published to the registry. +- The address is compiled in. **If the named contract is redeployed, delete the cached files (or `cargo clean`) and rebuild.** + +### Assets (SACs): `xlm`, `native`, `"CODE:ISSUER"` + +```rust +let xlm = stellar_registry::import_contract!(env, xlm); +xlm.transfer(&from, &to, &amount); + +let usdc = stellar_registry::import_contract!(env, "USDC:GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN"); +``` + +Asset names resolve the Stellar Asset Contract id **offline** and return `soroban_sdk::token::TokenClient`. There's no registry lookup and no cache, and it works with `STELLAR_NO_REGISTRY=1`. A registered name that points at a SAC (e.g. `"circle/usdc"`) also returns a `TokenClient`. + +## `import_contract_client!(name)`: published wasm → client type only + +```rust +use soroban_sdk; // required in scope, or: "unresolved import `super`, no `soroban_sdk` in the root" + +stellar_registry::import_contract_client!(registry); // latest version +stellar_registry::import_contract_client!("unverified/my-game"); +stellar_registry::import_contract_client!("registry@1.0.0"); // pinned; leading `v` ok + +// Later, bind it to an address you supply: +let client = registry::Client::new(env, &some_address); +``` + +- Generates a module (e.g. `registry`) equivalent to `soroban_sdk::contractimport!` on the downloaded wasm. It **doesn't** bind an address. +- Use it when you have many instances of one wasm, take addresses as arguments, or need a specific version's interface. +- Looks for `target/stellar//[__][_].wasm` first (a workspace contract you compiled, or one fetched with `stellar registry download`), and downloads it from the registry only if missing. + +## `import_asset!("asset")`: SAC id and clients as a module + +```rust +stellar_registry::import_asset!("native"); // or "xlm" +stellar_registry::import_asset!("USDC:GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN"); + +let id = USDC::contract_id(env); +USDC::token_client(env).balance(&who); +USDC::stellar_asset_client(env).mint(&to, &amount); // issuer/admin interface +``` + +Computed entirely offline from the asset and the build-time network passphrase (`STELLAR_NETWORK` / `STELLAR_NETWORK_PASSPHRASE`). The module is named after the asset code. + +## Offline / reproducible builds + +Set `STELLAR_NO_REGISTRY=1` to forbid network calls. Then: + +- `import_contract!` needs the cached `.id` and wasm under `target/stellar//deployed/`. Build online once, or create them with `stellar registry fetch-contract-id` and `stellar contract fetch`. +- `import_contract_client!` needs the wasm in `target/stellar//` (e.g. from `stellar registry download -o target/stellar//.wasm`). +- Asset forms (`xlm`, `"CODE:ISSUER"`, `import_asset!`) need nothing. + +## Unit-testing code that calls a SAC + +The SAC address baked in by `import_contract!(env, xlm)` doesn't exist in a sandboxed test `Env`. Swap in a test double behind `cfg(test)` and keep the call site the same: + +```rust +#[cfg(not(test))] +mod xlm { + use soroban_sdk::{token, Env}; + pub fn token_client(env: &Env) -> token::TokenClient<'_> { + stellar_registry::import_contract!(env, xlm) + } +} + +#[cfg(test)] +mod xlm { + use soroban_sdk::{contracttype, testutils::Address as _, token, Address, Env}; + #[contracttype] + enum DataKey { Sac } + + // Call from the test after registering your contract; mint to users via the returned address. + pub fn register(env: &Env, contract_id: &Address) -> Address { + let sac = env.register_stellar_asset_contract_v2(Address::generate(env)); + env.as_contract(contract_id, || env.storage().instance().set(&DataKey::Sac, &sac.address())); + sac.address() + } + pub fn token_client(env: &Env) -> token::TokenClient<'_> { + let address: Address = env.storage().instance().get(&DataKey::Sac).unwrap(); + token::TokenClient::new(env, &address) + } +} +``` + +The contract calls `xlm::token_client(env)` either way. The same pattern works for any `import_contract!` target: register a mock contract in tests. From b64ba3b18895f8a0af117e5b75388663b9999c39 Mon Sep 17 00:00:00 2001 From: Pam Selle Date: Fri, 25 Sep 2026 13:36:03 -0400 Subject: [PATCH 2/4] docs(cli): replace nonexistent install command with create-alias The README documented `stellar registry install` and passing a constructor function name after `--`; neither matches the CLI. Co-Authored-By: Claude Opus 5.5 --- crates/stellar-registry-cli/README.md | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/crates/stellar-registry-cli/README.md b/crates/stellar-registry-cli/README.md index 6dfac20..55ab607 100644 --- a/crates/stellar-registry-cli/README.md +++ b/crates/stellar-registry-cli/README.md @@ -46,27 +46,27 @@ stellar registry deploy \ --wasm-name \ [--version ] \ -- \ - [CONSTRUCTOR_FUNCTION] [CONSTRUCTOR_ARGS...] + [CONSTRUCTOR_ARGS...] ``` Options: - `--contract-name`: Name to give this contract instance (required) - `--wasm-name`: Name of the published contract to deploy (required) - `--version`: Specific version of the published contract to deploy (optional, defaults to most recent version) -- `CONSTRUCTOR_FUNCTION`: Optional constructor function name if contract implements initialization -- `CONSTRUCTOR_ARGS`: Optional arguments for the constructor function +- `CONSTRUCTOR_ARGS`: Arguments for the contract's `__constructor`, as `--arg-name value` (run with `-- --help` to list them) -Note: Use `--` to separate CLI options from constructor function and arguments. +Note: Use `--` to separate CLI options from constructor arguments. -### Install +### Create alias -Install a deployed contract as an alias to be used by `stellar-cli`: +Create a local alias for a deployed contract, to be used by `stellar-cli`: ```bash -stellar registry install +stellar registry create-alias [LOCAL_NAME] ``` Options: -- `CONTRACT_NAME`: Name of the deployed contract to install (required) +- `CONTRACT_NAME`: Name of the deployed contract (required) +- `LOCAL_NAME`: Alias to create (optional, defaults to the registry name) ## Configuration @@ -106,15 +106,14 @@ stellar registry deploy \ --wasm-name token \ --version "1.0.0" \ -- \ - initialize \ --name "My Token" \ --symbol "MTK" \ --decimals 7 ``` -3. Install the deployed contract: +3. Create a local alias for the deployed contract: ```bash -stellar registry install my-token +stellar registry create-alias my-token ``` Then can interact with the contract with `stellar-cli`: From 8e892104fabdf135de87d55895eaf9f840060cf9 Mon Sep 17 00:00:00 2001 From: Pam Selle Date: Fri, 25 Sep 2026 13:37:55 -0400 Subject: [PATCH 3/4] docs(skill): cover channel+version names, module naming, interface lookup Gaps found by testing the skill with a fresh agent. Co-Authored-By: Claude Opus 5.5 --- skills/stellar-registry/SKILL.md | 2 ++ skills/stellar-registry/references/macros.md | 12 +++++++++++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/skills/stellar-registry/SKILL.md b/skills/stellar-registry/SKILL.md index b2ef1ee..2f4e35b 100644 --- a/skills/stellar-registry/SKILL.md +++ b/skills/stellar-registry/SKILL.md @@ -112,6 +112,8 @@ impl Tipper { } ``` +Before calling a contract's methods, list them with `stellar contract info interface --id ` (get the id from `stellar registry fetch-contract-id `). + **Build with the network set.** The macros resolve names at build time, reading `STELLAR_NETWORK`, which **defaults to `local`**: ```bash diff --git a/skills/stellar-registry/references/macros.md b/skills/stellar-registry/references/macros.md index b631121..96221b7 100644 --- a/skills/stellar-registry/references/macros.md +++ b/skills/stellar-registry/references/macros.md @@ -2,10 +2,19 @@ ```toml [dependencies] -soroban-sdk = "..." # your existing version; generated code uses your `soroban_sdk` +soroban-sdk = "25" # or your existing version; generated code uses your `soroban_sdk` stellar-registry = "0.1" ``` +**Module names** (for the generated modules and clients): the channel is dropped, `-` becomes `_`, and the name is lowercased. `"unverified/my-game"` → `my_game`. Assets are the exception: `import_asset!` names the module exactly after the asset code (`USDC`, `xlm`). + +**See a contract's methods before coding against it:** + +```bash +stellar contract info interface --id $(stellar registry fetch-contract-id unverified/price-oracle) +stellar registry download unverified/escrow --version 1.2.0 -o escrow.wasm && stellar contract info interface --wasm escrow.wasm +``` + All three macros run at **build time**. `import_contract!` and `import_contract_client!` shell out to `stellar registry` (the `stellar-registry-cli` plugin) and `stellar contract fetch`, so both `stellar` and the plugin must be on `PATH` when you `cargo build`. A default identity (`stellar keys use `) must also be set, since the lookups need a source account. **Network selection:** set `STELLAR_NETWORK` (e.g. `testnet`, `mainnet`) in the build environment. It defaults to `local`. It selects the cache directory and the network passphrase used to compute asset contract ids. @@ -49,6 +58,7 @@ use soroban_sdk; // required in scope, or: "unresolved import `super`, no `sor stellar_registry::import_contract_client!(registry); // latest version stellar_registry::import_contract_client!("unverified/my-game"); stellar_registry::import_contract_client!("registry@1.0.0"); // pinned; leading `v` ok +stellar_registry::import_contract_client!("unverified/escrow@1.2.0"); // channel + version → module `escrow` // Later, bind it to an address you supply: let client = registry::Client::new(env, &some_address); From 3477b55499dcc13cc94c1b3f41aa96da0038f8b5 Mon Sep 17 00:00:00 2001 From: Pam Selle Date: Fri, 25 Sep 2026 13:44:28 -0400 Subject: [PATCH 4/4] docs(skill): recommend soroban-sdk 28 (latest stable, verified) Co-Authored-By: Claude Opus 5.5 --- skills/stellar-registry/references/macros.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/skills/stellar-registry/references/macros.md b/skills/stellar-registry/references/macros.md index 96221b7..110e98c 100644 --- a/skills/stellar-registry/references/macros.md +++ b/skills/stellar-registry/references/macros.md @@ -2,7 +2,7 @@ ```toml [dependencies] -soroban-sdk = "25" # or your existing version; generated code uses your `soroban_sdk` +soroban-sdk = "28" # or your existing version; generated code uses your `soroban_sdk` stellar-registry = "0.1" ```