Repository navigation
Conversation
This was referenced Nov 19, 2026
added 19 commits
November 19, 2026 13:42
typescript.yml compared the package.json version against the parent commit to decide whether to build, test and publish. A rebase-merge puts the version bump below the tip, so the check saw no change and skipped the publish: npm stayed at 0.1.1 while package.json moved to 0.2.0 and 0.3.0. Check the registry's version list instead. A version missing from npm is built, tested and published, whichever commit bumped it, and a failed publish is retried by the next run. A failed registry request fails the job rather than counting as unpublished.
The wheel left out the generated bindings: glsdk/glsdk.py is listed in .gitignore, and hatchling skips ignored files unless they are force-included, so `import glsdk` failed with "No module named 'glsdk.glsdk'". Force-include it like the shared library. On Windows the hook packaged the library as glsdk/libglsdk.dll, while the UniFFI loader opens glsdk/glsdk.dll, the name cargo gives it. glsdk.__version__ was hard-coded to 0.4.0, read it from the installed package's metadata instead.
The committed bindings predate the doc comment change on Scheduler.lightning_available, which changed its UniFFI checksum, so they refused to load against a current build of the library.
The gl-client Python package was published from the internal GitLab mirror by a manual job that rewrote the version with sed and built a single Linux wheel, and the gl-sdk Python package was not published or even built anywhere. python.yml now publishes both through PyPI trusted publishing, in the `pypi` environment: - a gl-client-py-vX.Y.Z tag publishes gl-client from the wheels and sdist the workflow already builds; - a gl-sdk-vX.Y.Z tag publishes gl-sdk from a new set of wheels for Linux x86_64 and aarch64 (cargo zigbuild against glibc 2.17), macOS arm64 and x86_64, and Windows x64. Each wheel bundles the library with bindings regenerated from it, is retagged from py3-none-any to its platform, and is smoke tested where the runner can load it. Both jobs refuse files whose version differs from the tag. The release tags also match release.yml's crate tag pattern, so release.yml now skips crates with `publish = false`, which gl-client-py and gl-sdk-node set: they are released to PyPI and npm, not crates.io. A gl-sdk-vX.Y.Z tag keeps publishing the gl-sdk crate as well.
gl-plugin, gl-signerproxy and gl-cli were published from the internal GitLab mirror by manual jobs on date-stamped tags, which rewrote the version with sed and published without the changelog and semver checks release.yml runs. Publish them from release.yml like the other crates, and leave the mirror with only the Maven Central pipeline.
List every published artifact with the workflow and trigger that publishes it, document the Python release tags and their overlap with the crate tags, and replace the npm and Python gaps with how the new checks work and the PyPI setup they need.
The Swift package was built in Blockstream/gl-sdk-swift by a workflow dispatched by hand after each gl-sdk release, so nothing built the XCFramework before a release, and automating the dispatch from here would need a token for the other repository. Build it here instead. swift.yml builds the XCFramework and the Swift bindings on changes to the SDK and compiles them as a Swift package for the iOS simulator. On a gl-sdk-vX.Y.Z tag it attaches the zip, its checksum and glsdk.swift to the gl-sdk-vX.Y.Z release, creating the release if release.yml has not yet. gl-sdk-swift's publish.yml picks them up from there, so each repository only writes to itself.
GitHub no longer runs jobs on macos-14 ("The configuration
'macos-14-arm64-us-default' is not supported"), which failed the gl-sdk
macOS wheels at once and would fail the npm aarch64-apple-darwin build
whenever it runs.
xcodebuild names the schemes of a Swift package itself, and the package built to compile the bindings has no scheme named GreenlightSDK. List the schemes and build the library product's, or the whole package's.
crates.io rejected gl-signerproxy 0.4.0 with "wildcard (`*`) dependency constraints are not allowed on crates.io", for `log = "*"`. 0.4 is the version range Cargo.lock already resolves to (0.4.29).
Neither is meant for crates.io, and crates.io already has an unrelated uniffi-bindgen. The release plan publishes every workspace crate that does not set publish = false.
publish-crates.yml takes the crates to release, in dependency order, and runs the checks of the tag-triggered release.yml on all of them: changelog, semver, tests. It then runs one multi-package cargo publish, which in a dry run packages each crate and builds it against the others' packages through a local registry overlay, so the dry run passes before any of them is on crates.io. The old dry run never ran cargo publish at all. A real run skips versions crates.io already has, uploads the rest and creates a <crate>-vX.Y.Z GitHub release for each.
python.yml no longer publishes on gl-client-py-v* and gl-sdk-v* tags. release.yml calls it with the packages to publish and a dry-run flag. Both modes check that each file carries the version from pyproject.toml and that twine accepts the metadata. The dry run stops there, outside the pypi environment, so it needs no approval. The concurrency group names the workflow itself: a called workflow sees the caller's github.workflow, and the workflows release.yml calls would share a group and cancel each other.
typescript.yml published on every push to main whose version npm did not have yet. It now always builds and tests, and publishes only when release.yml calls it, or runs `npm publish --dry-run` for a dry run.
Every Swift build checks out gl-sdk-swift's main and runs its scripts/prepare.sh and scripts/check-package.sh against the fresh XCFramework, instead of an inline copy of its Package.swift. A template change there that does not fit the build fails here first. A real release, called from release.yml, attaches the assets to the gl-sdk-vX.Y.Z release, waits for gl-sdk-swift to tag X.Y.Z and verifies it with scripts/verify.sh, so the Swift release shows on this repository's Actions page.
Actions > Release > Run workflow now releases the crates, both Python packages, npm, Swift and Maven, replacing the per-crate tag trigger. Its plan step reads each version from the repository, asks the registry whether it is published and writes the plan to the run summary. A real release, from main only, publishes what is missing, crates first, then the bindings in parallel. A dry run, the default, exercises every selected artifact up to the upload, from any branch. The plan also fails on wildcard dependency requirements, which crates.io only rejects on upload, and on bindings whose versions disagree.
`./gradlew :lib:publishAllPublicationsToBundleRepository` writes the publications in the Maven repository layout with checksums, unsigned, like Maven Local. GitHub builds it for a release, and the internal GitLab mirror signs and uploads it.
kotlin.yml, called by release.yml, builds the publications as an unsigned bundle in the Maven repository layout and runs it through contrib/maven-central/check-bundle.sh with a throwaway key: POM fields, the md5 and sha1 checksums, every file signed and verified. A real release attaches the bundle and its SHA-256 to the gl-sdk-vX.Y.Z release, where Blockstream's release infrastructure picks it up, signs it with Blockstream's key and uploads it, and waits until the version is on repo1.maven.org. No Maven credentials are on GitHub. It also ran on pushes to master, a branch this repository does not have, and on gl-sdk-* tags; it now runs on main.
cdecker
force-pushed
the
2026m11-release-public
branch
from
November 19, 2026 14:54
7b797aa to
d6d5034
Compare
The internal GitLab mirror ran the Kotlin snapshots and the manual Maven Central release from this tree. Releases are started from the Release workflow here now, and the Maven Central upload happens outside this repository, from the bundle the workflow attaches to the gl-sdk release. Maven -SNAPSHOT builds are no longer published.
cdecker
force-pushed
the
2026m11-release-public
branch
from
November 19, 2026 17:38
d6d5034 to
8fb8f33
Compare
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
One place to release every SDK artifact: Actions > Release > Run workflow. A dry run, the default, builds, tests and packages everything up to the upload, from any branch and at any time. A real release, from
mainonly, publishes whatever the registries don't have yet, so a re-run finishes a partly failed release. Pushing a tag no longer publishes anything.The crates go first, then the bindings in parallel, so a binding never ships a
gl-sdkwhose crates failed. The plan also fails on what only a registry would reject: wildcard dependencies (crates.io refused gl-signerproxy 0.4.0 forlog = "*") and bindings whose versions disagree withgl-sdk.release.ymlper<crate>-vX.Y.Ztagpublish-crates.ymlcargo publish --dry-runof all crates togethergl-client,gl-sdkon PyPIpython.ymltwine check --strict@greenlightcln/glsdkmainwith an unpublished versiontypescript.ymlnpm publish --dry-runGreenlightSDK(Swift)swift.yml, dispatched by handswift.yml+ gl-sdk-swiftpublish.ymlprepare.sh+check-package.shcom.blockstream:glsdkkotlin.ymlbuilds it, signed and uploaded internallycheck-bundle.sh, throwaway keyNeither repository holds credentials for another. Swift and Maven are pulled by their publisher, hourly, and
release.ymlwaits for them, so the outcome still shows here:sequenceDiagram participant R as release.yml participant Rel as gl-sdk-vX.Y.Z release participant S as gl-sdk-swift publish.yml (hourly) participant G as Blockstream release infra (hourly) participant C as Maven Central R->>Rel: XCFramework zip, glsdk.swift R->>Rel: glsdk-maven-X.Y.Z.zip (unsigned) S->>Rel: poll → Package.swift, tag X.Y.Z G->>Rel: poll → check checksum + uploader G->>C: sign with Blockstream key, upload R->>S: wait for tag X.Y.Z, verify like SwiftPM R->>C: wait for repo1.maven.orgNo Maven Central credentials or signing key are on GitHub. The bundle is built and checked here and signed where the key is, outside this repository. The GitLab pipeline is gone (
.gitlab-ci.yml,gitlab/), and with it the Maven-SNAPSHOTbuilds.Also in here:
gl-examplesanduniffi-bindgenarepublish = false(crates.io'suniffi-bindgenis someone else's), thegl-sdkwheel fixes (missingglsdk.py, Windowsglsdk.dll, stale checksum,__version__), andmacos-15instead of the retiredmacos-14, which kept npm 0.3.1 from publishing.The gl-client 0.8.0 / gl-sdk 0.5.1 release went out ahead of this, the old way, in #770. This branch is rebased onto it.
Evidence
python3 .github/scripts/release_plan.pyagainst today's registries:log = "*"back in gl-signerproxy:error: gl-signerproxy: dependency log = "*", crates.io rejects wildcard requirements, exit 1.release.ymlnever rancargo publish.After:
cargo publish --dry-runof an already published crate warnsalready exists on crates.io indexand stops before the upload, so the dry run can cover every crate at any time.scripts/verify.shpasses against the published 0.5.1 and 0.4.1.scripts/prepare.shon the real 0.5.1 zip renders the package for a test version, and refuses a zip that doesn't match its checksum, or an emptyglsdk.swift, which the old inline version would have committed.contrib/maven-central/check-bundle.shon a bundle in Gradle's layout signs and verifies all 11 files, writes the md5 and sha1 checksums, drops Gradle's checksums andmaven-metadata.xml, warns about a missing javadoc jar, and refuses a wrong version or a bundle without one. The internal side was run against a local fake of this repository's releases: it signs the bundle, and refuses one not uploaded by the Release workflow.Merge Danger
Door: one-way
Merging is safe on its own: every publish now waits for a dispatched run of
release.yml. The first real release is the one-way step. Run a dry run first.Blast Radius: registries
Before the first real release:
scripts/prepare.shfrom gl-sdk-swift'smain, so without it the Swift checks fail.gl-clientand a pending one ongl-sdk: ownerBlockstream, repositorygreenlight, workflowrelease.yml(the workflow that starts the run, notpython.yml), environmentpypi.-SNAPSHOTbuilds stop. The last one is0.5.1-08c004da-SNAPSHOT; releases are the only Maven artifacts from now on.GitHub's
CARGO_REGISTRY_TOKENandRELEASE_PLZ_TOKENstay unused.🤖 Generated with Claude Code