From 4ce6195cf896a4da1b61e6263df8eff55aa7d91c Mon Sep 17 00:00:00 2001 From: Nic-dorman Date: Tue, 20 Oct 2026 10:04:18 +0100 Subject: [PATCH] release: antd 0.16.0 Bump antd to 0.16.0 (Cargo.toml + Cargo.lock). While pointers and manifests were unreleased, the docs, doc comments and a few messages said "the antd release after 0.15.0", "the first antd release with pointers (after 0.15.0)" and so on, because nobody knew the version yet. They now say "antd 0.16.0 or later" (or "added in antd 0.16.0"): READMEs, quickstarts, tutorials, llms*.txt, skill.md, SDK doc comments, the ant-dev opt-in note and the Dart CHANGELOG. Unchanged on purpose: the byte-range notes that name 0.15.0 (that support did ship in 0.15.0) and generated proto comments. Co-Authored-By: Claude Opus 5.5 --- README.md | 4 ++-- ant-dev/src/ant_dev/cmd_example.py | 6 +++--- antd-cpp/README.md | 6 +++--- antd-cpp/include/antd/client.hpp | 8 ++++---- antd-cpp/include/antd/errors.hpp | 2 +- antd-csharp/Antd.Sdk/IAntdClient.Manifests.cs | 2 +- antd-csharp/Antd.Sdk/IAntdClient.cs | 2 +- antd-csharp/Examples/Example09Manifests.cs | 2 +- antd-csharp/Examples/Program.cs | 2 +- antd-csharp/README.md | 8 ++++---- antd-dart/CHANGELOG.md | 6 +++--- antd-dart/README.md | 4 ++-- antd-dart/lib/src/client.dart | 10 +++++----- antd-dart/lib/src/grpc_client.dart | 6 +++--- antd-elixir/README.md | 6 +++--- antd-elixir/examples/09_manifests.exs | 2 +- antd-elixir/lib/antd/client.ex | 6 +++--- antd-go/README.md | 4 ++-- antd-go/manifest.go | 12 ++++++------ antd-go/pointers.go | 2 +- antd-java/README.md | 4 ++-- .../src/main/java/com/autonomi/antd/AntdClient.java | 2 +- antd-js/README.md | 4 ++-- antd-js/examples/09-manifests.ts | 2 +- antd-js/src/manifests.ts | 2 +- antd-js/src/rest-client.ts | 6 +++--- antd-kotlin/README.md | 6 +++--- .../com/autonomi/examples/Example09Manifests.kt | 4 ++-- .../src/main/kotlin/com/autonomi/examples/Main.kt | 2 +- .../main/kotlin/com/autonomi/sdk/AntdGrpcClient.kt | 2 +- .../main/kotlin/com/autonomi/sdk/AntdRestClient.kt | 4 ++-- .../src/main/kotlin/com/autonomi/sdk/Exceptions.kt | 2 +- .../src/main/kotlin/com/autonomi/sdk/IAntdClient.kt | 4 ++-- antd-lua/README.md | 4 ++-- antd-lua/src/antd/client.lua | 2 +- antd-lua/src/antd/manifests.lua | 2 +- antd-mcp/README.md | 2 +- antd-php/README.md | 4 ++-- antd-php/src/ManifestMethods.php | 2 +- antd-py/README.md | 4 ++-- antd-py/src/antd/_grpc.py | 2 +- antd-py/src/antd/_rest.py | 8 ++++---- antd-ruby/README.md | 6 +++--- antd-ruby/lib/antd/client.rb | 4 ++-- antd-ruby/lib/antd/errors.rb | 2 +- antd-ruby/lib/antd/grpc_manifests.rb | 6 +++--- antd-ruby/lib/antd/manifests.rb | 6 +++--- antd-rust/README.md | 4 ++-- antd-rust/src/errors.rs | 2 +- antd-rust/src/manifests.rs | 8 ++++---- antd-swift/README.md | 6 +++--- antd-swift/Sources/AntdExamples/Main.swift | 2 +- antd-swift/Sources/AntdSdk/AntdClientProtocol.swift | 4 ++-- antd-swift/Sources/AntdSdk/Manifests.swift | 2 +- .../Tests/AntdSdkTests/LiveManifestTests.swift | 4 ++-- antd-zig/README.md | 4 ++-- antd-zig/src/antd.zig | 4 ++-- antd/Cargo.lock | 2 +- antd/Cargo.toml | 2 +- antd/openapi.yaml | 4 ++-- docs/architecture.md | 4 ++-- docs/quickstart-cpp.md | 4 ++-- docs/quickstart-csharp.md | 4 ++-- docs/quickstart-dart.md | 4 ++-- docs/quickstart-elixir.md | 4 ++-- docs/quickstart-java.md | 4 ++-- docs/quickstart-kotlin.md | 4 ++-- docs/quickstart-lua.md | 4 ++-- docs/quickstart-php.md | 4 ++-- docs/quickstart-python.md | 4 ++-- docs/quickstart-ruby.md | 4 ++-- docs/quickstart-rust.md | 4 ++-- docs/quickstart-swift.md | 4 ++-- docs/quickstart-zig.md | 4 ++-- docs/tutorial-manifests.md | 2 +- docs/tutorial-pointers.md | 2 +- llms-full.txt | 6 +++--- llms.txt | 4 ++-- skill.md | 4 ++-- 79 files changed, 160 insertions(+), 160 deletions(-) diff --git a/README.md b/README.md index 828a3466..f16e85df 100644 --- a/README.md +++ b/README.md @@ -432,7 +432,7 @@ Data, chunks and files are immutable: new content gets a new address. Pointers a ### Pointers -A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's address, or another pointer) can be changed by the owner. Publish the pointer's address once, then move it to each new version. Pointers need the first antd release with pointers (after 0.15.0). +A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's address, or another pointer) can be changed by the owner. Publish the pointer's address once, then move it to each new version. Pointers need antd 0.16.0 or later (the first release with pointers). - **antd holds the owner keys.** Create one with `ant pointer keygen --output ` (the Autonomi `ant` CLI) and start antd with `--pointer-keys ` (env `ANTD_POINTER_KEYS_DIR`); it loads them at startup. Requests name a pointer by its address, never by a key. Without the flag, pointers can be read but not written. A pointer key cannot be rotated: see [SECURITY.md](SECURITY.md). - **Every write pays.** A create, update or transfer costs about the price of one chunk, from the daemon wallet or an external signer (`pointer_prepare` / `pointer_finalize`). Every attempt pays again, so the SDKs never retry a paid pointer write. Reads (`get`, `resolve`, `finality`, `controller`, `keys`) are free. @@ -463,7 +463,7 @@ The MCP server has 10 pointer tools: the reads are free, `pointer_create`, `poin ### Manifests -A manifest describes a set of files as one `.ant` document, or as one `ant://manifest/` link when it is small enough. Each entry has an optional path and size and either a public file's address or an embedded DataMap (a private file: the manifest is then its key). Share the link and the receiver can decode it, learn what is in the set and download each file with the existing download calls. Manifests need the antd release after 0.15.0. +A manifest describes a set of files as one `.ant` document, or as one `ant://manifest/` link when it is small enough. Each entry has an optional path and size and either a public file's address or an embedded DataMap (a private file: the manifest is then its key). Share the link and the receiver can decode it, learn what is in the set and download each file with the existing download calls. Manifests need antd 0.16.0 or later. - **Nothing is uploaded or paid for.** Upload the files first, then build from the addresses and DataMaps the uploads returned. Build and decode read the network only to resolve DataMaps, so they can time out; retrying is safe. The daemon needs no wallet for them. - **Three calls**, in every SDK: `build_manifest`, `decode_manifest` (raw `.ant` bytes) and `decode_manifest_link` (a manifest link, file link or bare address), cased per language. `resolve` also reads each entry's DataMap from the network to report its `exact_size`. REST carries the `.ant` bytes as base64; the SDKs always take and return raw bytes. diff --git a/ant-dev/src/ant_dev/cmd_example.py b/ant-dev/src/ant_dev/cmd_example.py index b0c1ee9a..5cb39c99 100644 --- a/ant-dev/src/ant_dev/cmd_example.py +++ b/ant-dev/src/ant_dev/cmd_example.py @@ -255,12 +255,12 @@ def _venv_python() -> str: # Examples that `all` skips. Run them by name instead. The pointers example # pays from the daemon wallet on every run and needs a never-written owner # address in ANTD_POINTER_OWNER (a pointer is created once per owner). The -# manifests example needs an antd with the manifest API (the release after -# 0.15.0) and each run pays for two small public uploads. +# manifests example needs antd 0.16.0 or later (the manifest API) and each +# run pays for two small public uploads. OPT_IN_EXAMPLES: dict[str, str] = { "pointers": "needs ANTD_POINTER_OWNER set to an unused owner address whose " "key antd holds; each run pays", - "manifests": "needs the antd release after 0.15.0 (manifest API); each run " + "manifests": "needs antd 0.16.0 or later (manifest API); each run " "pays for two small uploads", } diff --git a/antd-cpp/README.md b/antd-cpp/README.md index dfa1b54f..3f8d91b7 100644 --- a/antd-cpp/README.md +++ b/antd-cpp/README.md @@ -267,8 +267,8 @@ On `Client`, `AsyncClient` (as `std::future`s) and `GrpcClient`. See [Pointers]( ## Pointers -A pointer is a small, owner-signed, mutable reference (needs the antd release -after 0.15.0, the first with pointers). Its address is derived from its +A pointer is a small, owner-signed, mutable reference (needs antd 0.16.0 or +later, the first release with pointers). Its address is derived from its owner's key and never changes. What it points at (a chunk, such as a public file's data map, or another pointer) can be updated by the owner, and the owner can hand the pointer over to another pointer for good. The daemon signs @@ -451,7 +451,7 @@ A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link, that describes a set of files: each with an optional path and size, and either an embedded DataMap (a private upload; the manifest is its key) or a public DataMap address. The daemon builds and decodes them, so the format is never -re-implemented here. Needs the antd release after 0.15.0. +re-implemented here. Needs antd 0.16.0 or later. **Nothing is uploaded or paid for.** Upload the files first (`data_put`, `file_put_public`, ...), then describe them. The daemon reads the network diff --git a/antd-cpp/include/antd/client.hpp b/antd-cpp/include/antd/client.hpp index 8df7dc45..be831a68 100644 --- a/antd-cpp/include/antd/client.hpp +++ b/antd-cpp/include/antd/client.hpp @@ -201,8 +201,8 @@ class Client { // --- Manifests --- // - // `.ant` manifests and `ant://` links (ADR-0006; needs the antd release - // after 0.15.0). Nothing is uploaded or paid for. The `.ant` bytes are + // `.ant` manifests and `ant://` links (ADR-0006; needs antd 0.16.0 + // or later). Nothing is uploaded or paid for. The `.ant` bytes are // raw bytes here; the client handles REST's base64. See manifests.hpp for // the types. @@ -298,8 +298,8 @@ class Client { // --- Pointers --- // - // Owner-signed, paid, mutable references (antd with the pointer API, - // after 0.15.0). The daemon signs with owner keys it loaded at startup + // Owner-signed, paid, mutable references (antd 0.16.0 or + // later). The daemon signs with owner keys it loaded at startup // (`antd --pointer-keys`); a write names the pointer by its address // (`owner`), and an owner the daemon holds no key for is a // BadRequestError. diff --git a/antd-cpp/include/antd/errors.hpp b/antd-cpp/include/antd/errors.hpp index c7d0516c..51e1da72 100644 --- a/antd-cpp/include/antd/errors.hpp +++ b/antd-cpp/include/antd/errors.hpp @@ -385,7 +385,7 @@ inline void throw_for_error_code(std::string_view code, const std::string& messa if (code == "CLOSE_GROUP_SHORTFALL") throw CloseGroupShortfallError(message, retryable); } -/// Metadata key the daemon (with the pointer API, after 0.15.0) sets on gRPC +/// Metadata key the daemon (0.16.0 or later) sets on gRPC /// statuses whose code is shared with older errors, carrying the REST `code`. inline constexpr std::string_view kErrorCodeMetadataKey = "x-antd-error-code"; diff --git a/antd-csharp/Antd.Sdk/IAntdClient.Manifests.cs b/antd-csharp/Antd.Sdk/IAntdClient.Manifests.cs index 46cf1441..b8906258 100644 --- a/antd-csharp/Antd.Sdk/IAntdClient.Manifests.cs +++ b/antd-csharp/Antd.Sdk/IAntdClient.Manifests.cs @@ -2,7 +2,7 @@ namespace Antd.Sdk; public partial interface IAntdClient { - // Manifests (the antd release after 0.15.0, the first with the manifest + // Manifests (antd 0.16.0 or later, the first release with the manifest // API): ADR-0006 `.ant` files and `ant://` links. // // Nothing is uploaded or paid for. Build and a resolving decode read diff --git a/antd-csharp/Antd.Sdk/IAntdClient.cs b/antd-csharp/Antd.Sdk/IAntdClient.cs index 945890cb..f377e786 100644 --- a/antd-csharp/Antd.Sdk/IAntdClient.cs +++ b/antd-csharp/Antd.Sdk/IAntdClient.cs @@ -112,7 +112,7 @@ public partial interface IAntdClient : IDisposable, IAsyncDisposable /// Task FinalizeMerkleUploadAsync(string uploadId, string winnerPoolHash); - // Pointers (antd with the pointer API, after 0.15.0). + // Pointers (antd 0.16.0 or later). // // Every write (create, update, transfer, finalize) pays, about the price // of one chunk, and every attempt pays again: the SDK never retries them, diff --git a/antd-csharp/Examples/Example09Manifests.cs b/antd-csharp/Examples/Example09Manifests.cs index 280f41c0..691a9051 100644 --- a/antd-csharp/Examples/Example09Manifests.cs +++ b/antd-csharp/Examples/Example09Manifests.cs @@ -14,7 +14,7 @@ partial class Program /// size. /// /// Building and decoding upload and pay for nothing; only the two uploads - /// pay. Needs the antd release after 0.15.0 and a wallet; + /// pay. Needs antd 0.16.0 or later and a wallet; /// ANTD_BASE_URL overrides the daemon URL (default /// http://localhost:8082). Run explicitly (dotnet run -- 9); "all" /// leaves it out, so it still runs against older daemons. diff --git a/antd-csharp/Examples/Program.cs b/antd-csharp/Examples/Program.cs index 29d2c4e1..21aa585d 100644 --- a/antd-csharp/Examples/Program.cs +++ b/antd-csharp/Examples/Program.cs @@ -31,7 +31,7 @@ static async Task Main(string[] args) await Example06_PrivateData(); await Example07_ExternalSigner(); break; - // Not part of "all": it needs the antd release after 0.15.0. + // Not part of "all": it needs antd 0.16.0 or later. case "9" or "manifests": await Example09_Manifests(); break; default: Console.WriteLine($"Unknown example: {example}. Use 1-9, 'pointers', 'manifests' or 'all'."); diff --git a/antd-csharp/README.md b/antd-csharp/README.md index 44c0bacd..91302bba 100644 --- a/antd-csharp/README.md +++ b/antd-csharp/README.md @@ -10,7 +10,7 @@ dotnet add package Autonomi.Antd ## Compatibility -This package talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Targets .NET 8. Tested against antd 0.12.x; the pointer methods need the antd release after 0.15.0, the first with pointers. The gRPC transport uses `Grpc.Net.Client`, which is a package dependency, so both transports work out of the box. For a daemon-less client see [`Autonomi.Ffi`](https://www.nuget.org/packages/Autonomi.Ffi). +This package talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Targets .NET 8. Tested against antd 0.12.x; the pointer methods need antd 0.16.0 or later, the first release with pointers. The gRPC transport uses `Grpc.Net.Client`, which is a package dependency, so both transports work out of the box. For a daemon-less client see [`Autonomi.Ffi`](https://www.nuget.org/packages/Autonomi.Ffi). ## Prerequisites @@ -257,7 +257,7 @@ See `Examples/FinalizeRetry.cs` (`FinalizeWithRetryAsync`, used by example 7) an ## Manifests -A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link when it is small enough, that describes a set of files. Each entry has an optional path and size, and either an embedded DataMap (the manifest is then the key to a private file) or a public file's DataMap address. The daemon builds and decodes manifests with ant-core, so the format, content addresses, link encoding and portable path rules are never re-implemented here. The manifest methods need the antd release after 0.15.0. +A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link when it is small enough, that describes a set of files. Each entry has an optional path and size, and either an embedded DataMap (the manifest is then the key to a private file) or a public file's DataMap address. The daemon builds and decodes manifests with ant-core, so the format, content addresses, link encoding and portable path rules are never re-implemented here. The manifest methods need antd 0.16.0 or later. **Nothing is uploaded or paid for.** Building and decoding are free. The daemon reads the network only to resolve DataMaps (the root-embedding policy on build, and `resolve` on decode), so a call can time out; it is safe to retry. @@ -316,7 +316,7 @@ dotnet run -- all # Run all of the above # Pointers: run explicitly; "all" leaves it out, because every write pays. ANTD_POINTER_OWNER=
dotnet run -- 8 # or: dotnet run -- pointers -dotnet run -- 9 # Manifests (or: dotnet run -- manifests; needs the antd release after 0.15.0) +dotnet run -- 9 # Manifests (or: dotnet run -- manifests; needs antd 0.16.0 or later) ``` Example 8 uploads two pieces of public data, creates a pointer at the first, updates it to the second, resolves and reads it, and prints its finality. It needs an antd started with `--pointer-keys` and a wallet; `ANTD_BASE_URL` overrides the daemon URL (default `http://localhost:8082`). Without `ANTD_POINTER_OWNER` it prints a note and skips. A rerun with the same owner skips the create and only updates. @@ -328,7 +328,7 @@ ant dev example data -l csharp ant dev example all -l csharp ``` -Example 9 (`dotnet run -- 9`, or `dotnet run -- manifests`) uploads two pieces of public data, builds a manifest of them with paths `notes/one.txt` and `notes/two.txt`, prints its link and entries, and decodes the link with `resolve` to print each entry's exact size. Only the two uploads pay. It is left out of "all" because it needs the antd release after 0.15.0; `ANTD_BASE_URL` overrides the daemon URL (default `http://localhost:8082`). +Example 9 (`dotnet run -- 9`, or `dotnet run -- manifests`) uploads two pieces of public data, builds a manifest of them with paths `notes/one.txt` and `notes/two.txt`, prints its link and entries, and decodes the link with `resolve` to print each entry's exact size. Only the two uploads pay. It is left out of "all" because it needs antd 0.16.0 or later; `ANTD_BASE_URL` overrides the daemon URL (default `http://localhost:8082`). ## Project Structure diff --git a/antd-dart/CHANGELOG.md b/antd-dart/CHANGELOG.md index c64ae96e..7ac6d13e 100644 --- a/antd-dart/CHANGELOG.md +++ b/antd-dart/CHANGELOG.md @@ -2,8 +2,8 @@ ## Unreleased -- Pointers, on both `AntdClient` and `GrpcAntdClient` (needs the antd - release after 0.15.0): `pointerKeys`, `pointerCreate`, `pointerUpdate`, +- Pointers, on both `AntdClient` and `GrpcAntdClient` (needs antd 0.16.0 + or later): `pointerKeys`, `pointerCreate`, `pointerUpdate`, `pointerTransfer`, `pointerGet`, `pointerResolve`, `pointerFinality`, `pointerController`, and `pointerPrepare` / `pointerFinalize` for an external signer. Every write pays and every attempt pays again; the SDK @@ -25,7 +25,7 @@ the status code, on every call. - gRPC stubs regenerated with `pointers.proto`. `example/09_pointers.dart`. - Manifests (ADR-0006 `.ant` files and `ant://` links), on both `AntdClient` - and `GrpcAntdClient` (needs the antd release after 0.15.0): + and `GrpcAntdClient` (needs antd 0.16.0 or later): `buildManifest(entries, {name, torrentInfoHashes, embedRoots})`, `decodeManifest(bytes, {resolve})` and `decodeManifestLink(link, {resolve})`. Nothing is uploaded or paid for. New models diff --git a/antd-dart/README.md b/antd-dart/README.md index 21ee9650..b2210c02 100644 --- a/antd-dart/README.md +++ b/antd-dart/README.md @@ -19,7 +19,7 @@ dependencies: ## Compatibility -This package talks to a running antd daemon; it does not join the network itself. Dart 3.0+. Tested against antd 0.13.x; the `retryable` field behind `PartialUploadError.retryable` / `retentionKnown` is sent by antd 0.14.0 and later (over REST, partial uploads from older daemons read as retention unknown). The [pointer methods](#pointers) need the antd release after 0.15.0, the first with pointers. Both the REST client (`AntdClient`) and the gRPC client (`GrpcAntdClient`) are included; the gRPC stubs are pre-generated, so `protoc` is only needed if you regenerate them. +This package talks to a running antd daemon; it does not join the network itself. Dart 3.0+. Tested against antd 0.13.x; the `retryable` field behind `PartialUploadError.retryable` / `retentionKnown` is sent by antd 0.14.0 and later (over REST, partial uploads from older daemons read as retention unknown). The [pointer methods](#pointers) need antd 0.16.0 or later, the first release with pointers. Both the REST client (`AntdClient`) and the gRPC client (`GrpcAntdClient`) are included; the gRPC stubs are pre-generated, so `protoc` is only needed if you regenerate them. ## Quick Start @@ -247,7 +247,7 @@ See [`example/09_pointers.dart`](example/09_pointers.dart) for a full round trip ### Manifests -A manifest (ADR-0006) is a `.ant` file that names a set of files: each entry has an optional path and size and either an embedded DataMap (a private upload; the manifest is the key to it) or a public file's DataMap address. A small one also fits in an `ant://manifest/...` link. The daemon builds and decodes them, so you never handle the format yourself. **Nothing is uploaded or paid for:** a manifest describes data that is already stored. The methods need the antd release after 0.15.0, and both `AntdClient` and `GrpcAntdClient` have them. +A manifest (ADR-0006) is a `.ant` file that names a set of files: each entry has an optional path and size and either an embedded DataMap (a private upload; the manifest is the key to it) or a public file's DataMap address. A small one also fits in an `ant://manifest/...` link. The daemon builds and decodes them, so you never handle the format yourself. **Nothing is uploaded or paid for:** a manifest describes data that is already stored. The methods need antd 0.16.0 or later, and both `AntdClient` and `GrpcAntdClient` have them. | Method | Description | |--------|-------------| diff --git a/antd-dart/lib/src/client.dart b/antd-dart/lib/src/client.dart index 0f3e549d..2f4c7ee0 100644 --- a/antd-dart/lib/src/client.dart +++ b/antd-dart/lib/src/client.dart @@ -504,7 +504,7 @@ class AntdClient { /// DataMaps exactly as given. That resolution reads from the network, so /// the call can time out; it is safe to retry. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. Future buildManifest( List entries, { String? name, @@ -533,7 +533,7 @@ class AntdClient { /// out; it is safe to retry. Bytes that are not a manifest throw /// [BadRequestError]. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. Future decodeManifest( Uint8List manifest, { bool resolve = false, @@ -553,7 +553,7 @@ class AntdClient { /// [DecodedManifest.source] `"file_link"`: one public entry with no path. /// See [decodeManifest] for [resolve]. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. Future decodeManifestLink( String link, { bool resolve = false, @@ -691,8 +691,8 @@ class AntdClient { // --- Pointers --- // - // Owner-signed, paid, mutable references (needs an antd with the pointer - // API, the first release after 0.15.0). A pointer's address is derived from + // Owner-signed, paid, mutable references (needs antd 0.16.0 or + // later, the first release with pointers). A pointer's address is derived from // its owner's key and never changes; what it points at can be updated by // the owner, who can also hand it over to another pointer for good. // diff --git a/antd-dart/lib/src/grpc_client.dart b/antd-dart/lib/src/grpc_client.dart index cbd69a4e..2a1a1b59 100644 --- a/antd-dart/lib/src/grpc_client.dart +++ b/antd-dart/lib/src/grpc_client.dart @@ -602,7 +602,7 @@ class GrpcAntdClient { /// [BadRequestError] before anything is sent; the daemon's INVALID_ARGUMENT /// for the rest (naming `entries[i]`) is a [BadRequestError]. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. Future buildManifest( List entries, { String? name, @@ -644,7 +644,7 @@ class GrpcAntdClient { /// Decodes `.ant` bytes. Nothing is uploaded or paid for. See /// [AntdClient.decodeManifest] for [resolve]. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. Future decodeManifest( Uint8List manifest, { bool resolve = false, @@ -660,7 +660,7 @@ class GrpcAntdClient { /// Decodes an `ant://` manifest link, file link or bare 64-hex address. /// See [AntdClient.decodeManifestLink]. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. Future decodeManifestLink( String link, { bool resolve = false, diff --git a/antd-elixir/README.md b/antd-elixir/README.md index d39c3b6a..698786e6 100644 --- a/antd-elixir/README.md +++ b/antd-elixir/README.md @@ -208,8 +208,8 @@ All functions take a `%Antd.Client{}` as the first argument. Each returns `{:ok, ### Pointers -A pointer is a small, owner-signed, mutable reference (needs the antd release -after 0.15.0, the first with pointers). Its address is derived from its +A pointer is a small, owner-signed, mutable reference (needs antd 0.16.0 or +later, the first release with pointers). Its address is derived from its owner's key and never changes. What it points at (a chunk, such as a public file's or public data's address, or another pointer) can be changed by the owner, and the owner can hand the pointer over to another pointer for good. @@ -448,7 +448,7 @@ A manifest (ADR-0006) is one `.ant` file, or an `ant://manifest/` link, that describes a set of files: each entry has an optional path and size and either an embedded DataMap (the key to a private upload) or a public DataMap address. The daemon builds and decodes manifests through ant-core, so the SDK never -re-implements the format. Needs the antd release after 0.15.0. +re-implements the format. Needs antd 0.16.0 or later. **Nothing is uploaded or paid for.** Building and decoding read the network only to resolve DataMaps (the embedding policy on build, `resolve: true` on diff --git a/antd-elixir/examples/09_manifests.exs b/antd-elixir/examples/09_manifests.exs index 96451264..d587592d 100644 --- a/antd-elixir/examples/09_manifests.exs +++ b/antd-elixir/examples/09_manifests.exs @@ -9,7 +9,7 @@ Mix.install([ # daemon builds and decodes it. Building and decoding upload nothing and pay # nothing; only the two uploads below pay. # -# Prerequisite: antd with a wallet (the antd release after 0.15.0, the first +# Prerequisite: antd with a wallet (antd 0.16.0 or later, the first # with manifests). # # ANTD_BASE_URL the daemon's REST URL (default http://localhost:8082) diff --git a/antd-elixir/lib/antd/client.ex b/antd-elixir/lib/antd/client.ex index 03b6a848..cfd659e9 100644 --- a/antd-elixir/lib/antd/client.ex +++ b/antd-elixir/lib/antd/client.ex @@ -645,7 +645,7 @@ defmodule Antd.Client do # # ADR-0006 `.ant` files and `ant://` links that describe a set of files, # each with an optional path and size and either an embedded DataMap or a - # public DataMap address (needs the antd release after 0.15.0). The daemon + # public DataMap address (needs antd 0.16.0 or later). The daemon # builds and decodes them through ant-core. Nothing is uploaded or paid # for; the network is read only to resolve DataMaps (the embedding policy # on build, `resolve` on decode), so a call can time out and is safe to @@ -907,8 +907,8 @@ defmodule Antd.Client do # Pointers # --------------------------------------------------------------------------- # - # Owner-signed, paid, mutable references (needs the antd release after - # 0.15.0, the first with pointers). The daemon signs with owner keys it + # Owner-signed, paid, mutable references (needs antd 0.16.0 or later, + # the first release with pointers). The daemon signs with owner keys it # loaded at startup (`antd --pointer-keys`); a write names the pointer by # its address (`owner`), never by a key. # diff --git a/antd-go/README.md b/antd-go/README.md index 38e761b7..06305aa8 100644 --- a/antd-go/README.md +++ b/antd-go/README.md @@ -152,7 +152,7 @@ The fields are read conservatively: over REST a count that is not a JSON non-neg ### Pointers -A pointer is a small, owner-signed, mutable reference (the antd release after 0.15.0, the first with pointers). Its address is derived from its owner's key and never changes. What it points at (a chunk, such as a public file's data map, or another pointer) can be updated by the owner, and the owner can hand the pointer over to another pointer for good. The daemon signs with owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so writes name the pointer by its address (`owner`) and no key ever crosses the API. +A pointer is a small, owner-signed, mutable reference (antd 0.16.0 or later, the first release with pointers). Its address is derived from its owner's key and never changes. What it points at (a chunk, such as a public file's data map, or another pointer) can be updated by the owner, and the owner can hand the pointer over to another pointer for good. The daemon signs with owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so writes name the pointer by its address (`owner`) and no key ever crosses the API. | Method | Description | |--------|-------------| @@ -171,7 +171,7 @@ Counters are `uint64`; a final state is at `PointerFinalCounter` (2^64−1). Eve ### Manifests -A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link when it fits in 1,500 bytes, that lists a set of files (the antd release after 0.15.0, the first with manifests). Each entry has an optional path and size and either an embedded DataMap (kind `"embedded"`: the manifest is the key to the file) or a public file's DataMap address (kind `"public"`). The daemon builds and decodes manifests through ant-core, so the format, content addresses and portable path rules are never re-implemented here. Nothing is uploaded or paid for: you build from DataMaps and addresses you already hold, and keep or share the bytes or the link yourself. +A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link when it fits in 1,500 bytes, that lists a set of files (antd 0.16.0 or later, the first release with manifests). Each entry has an optional path and size and either an embedded DataMap (kind `"embedded"`: the manifest is the key to the file) or a public file's DataMap address (kind `"public"`). The daemon builds and decodes manifests through ant-core, so the format, content addresses and portable path rules are never re-implemented here. Nothing is uploaded or paid for: you build from DataMaps and addresses you already hold, and keep or share the bytes or the link yourself. | Method | Description | |--------|-------------| diff --git a/antd-go/manifest.go b/antd-go/manifest.go index 862b61dd..3ba791f6 100644 --- a/antd-go/manifest.go +++ b/antd-go/manifest.go @@ -143,7 +143,7 @@ func checkManifestEntries(entries []ManifestEntryInput) error { // BuildManifest builds a `.ant` manifest from DataMaps and public addresses // already in hand, via POST /v1/manifests/build. opts may be nil. // -// Requires the antd release after 0.15.0. +// Requires antd 0.16.0 or later. func (c *Client) BuildManifest(ctx context.Context, entries []ManifestEntryInput, opts *BuildManifestOptions) (*BuiltManifest, error) { if err := checkManifestEntries(entries); err != nil { return nil, err @@ -197,7 +197,7 @@ func (c *Client) BuildManifest(ctx context.Context, entries []ManifestEntryInput // report ExactSize and confirm the DataMap is on the network; content chunks // are not fetched, and one entry's failure is reported in its Error. // -// Requires the antd release after 0.15.0. +// Requires antd 0.16.0 or later. func (c *Client) DecodeManifest(ctx context.Context, manifest []byte, resolve bool) (*DecodedManifest, error) { if len(manifest) == 0 { return nil, badManifestRequest(noDecodeInput) @@ -209,7 +209,7 @@ func (c *Client) DecodeManifest(ctx context.Context, manifest []byte, resolve bo // 64-hex address via POST /v1/manifests/decode. See DecodeManifest for // resolve. // -// Requires the antd release after 0.15.0. +// Requires antd 0.16.0 or later. func (c *Client) DecodeManifestLink(ctx context.Context, link string, resolve bool) (*DecodedManifest, error) { if link == "" { return nil, badManifestRequest(noDecodeInput) @@ -265,7 +265,7 @@ func parseManifestEntries(raw []any) []ManifestEntryInfo { // BuildManifest is the gRPC twin of Client.BuildManifest. opts may be nil. // -// Requires the antd release after 0.15.0. +// Requires antd 0.16.0 or later. func (c *GrpcClient) BuildManifest(ctx context.Context, entries []ManifestEntryInput, opts *BuildManifestOptions) (*BuiltManifest, error) { if err := checkManifestEntries(entries); err != nil { return nil, err @@ -311,7 +311,7 @@ func (c *GrpcClient) BuildManifest(ctx context.Context, entries []ManifestEntryI // DecodeManifest is the gRPC twin of Client.DecodeManifest. // -// Requires the antd release after 0.15.0. +// Requires antd 0.16.0 or later. func (c *GrpcClient) DecodeManifest(ctx context.Context, manifest []byte, resolve bool) (*DecodedManifest, error) { if len(manifest) == 0 { return nil, badManifestRequest(noDecodeInput) @@ -324,7 +324,7 @@ func (c *GrpcClient) DecodeManifest(ctx context.Context, manifest []byte, resolv // DecodeManifestLink is the gRPC twin of Client.DecodeManifestLink. // -// Requires the antd release after 0.15.0. +// Requires antd 0.16.0 or later. func (c *GrpcClient) DecodeManifestLink(ctx context.Context, link string, resolve bool) (*DecodedManifest, error) { if link == "" { return nil, badManifestRequest(noDecodeInput) diff --git a/antd-go/pointers.go b/antd-go/pointers.go index 88c2dff5..f534b70c 100644 --- a/antd-go/pointers.go +++ b/antd-go/pointers.go @@ -7,7 +7,7 @@ import ( "strconv" ) -// Pointers (the antd release after 0.15.0): owner-signed, paid, mutable references. A +// Pointers (antd 0.16.0 or later): owner-signed, paid, mutable references. A // pointer's address is derived from its owner's key and never changes; what // it points at can be updated by the owner, and the owner can hand it over to // another pointer for good (PointerTransfer). diff --git a/antd-java/README.md b/antd-java/README.md index 821db9a9..bb61e207 100644 --- a/antd-java/README.md +++ b/antd-java/README.md @@ -111,7 +111,7 @@ All methods throw `AntdException` (or a typed subclass) on failure. ### Manifests -A manifest (ADR-0006) describes a set of files as one `.ant` document, or as one `ant://manifest/` link when that fits in 1,500 bytes. Each entry has an optional path and size, and either an embedded DataMap (`ManifestEntryInput.ofDataMap(...)`, from `dataPut` or `filePut`) or a public file's DataMap address (`ManifestEntryInput.ofAddress(...)`). The daemon builds and decodes them through ant-core, so the SDK never re-implements the format. The manifest methods need the antd release after 0.15.0. +A manifest (ADR-0006) describes a set of files as one `.ant` document, or as one `ant://manifest/` link when that fits in 1,500 bytes. Each entry has an optional path and size, and either an embedded DataMap (`ManifestEntryInput.ofDataMap(...)`, from `dataPut` or `filePut`) or a public file's DataMap address (`ManifestEntryInput.ofAddress(...)`). The daemon builds and decodes them through ant-core, so the SDK never re-implements the format. The manifest methods need antd 0.16.0 or later. **Nothing is uploaded or paid for.** Building and decoding only read from the network: to resolve shrunk DataMaps when embedding roots (the default), and, with `resolve`, to fetch each entry's DataMap for its exact size. So a call can time out, and retrying it is safe. Store or share the bytes or the link yourself. @@ -154,7 +154,7 @@ ANTD_BASE_URL=http://localhost:8082 ./gradlew :examples:run -PmainClass=com.auto ### Pointers -A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. The pointer methods need the antd release after 0.15.0, the first with pointers. +A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. The pointer methods need antd 0.16.0 or later, the first release with pointers. **Every write pays** (about the price of one chunk), and every attempt pays again. The SDK never retries `pointerCreate`, `pointerUpdate`, `pointerTransfer` or `pointerFinalize`, and you should not retry them automatically either; the one exception is a finalize the daemon says it kept (see `pointerFinalize` below). Reads are free to retry; a read during an update or churn can fail with `CloseGroupShortfallException`. diff --git a/antd-java/src/main/java/com/autonomi/antd/AntdClient.java b/antd-java/src/main/java/com/autonomi/antd/AntdClient.java index 124aad4e..c0e70952 100644 --- a/antd-java/src/main/java/com/autonomi/antd/AntdClient.java +++ b/antd-java/src/main/java/com/autonomi/antd/AntdClient.java @@ -600,7 +600,7 @@ public UploadCostEstimate fileCost(String path, boolean isPublic) { // DataMap address. The daemon builds and decodes them, so callers never // re-implement the format. Nothing is uploaded or paid for; only the // embedding policy and `resolve` read from the network, so these calls can - // time out and are safe to retry. Needs the antd release after 0.15.0. + // time out and are safe to retry. Needs antd 0.16.0 or later. /** * {@link #buildManifest(List, BuildManifestOptions)} with the default diff --git a/antd-js/README.md b/antd-js/README.md index 3f8bd71b..2b66c0e3 100644 --- a/antd-js/README.md +++ b/antd-js/README.md @@ -87,7 +87,7 @@ All methods are `async` and return Promises. ### Manifests -A manifest ([ADR-0006](https://github.com/WithAutonomi/ant-client/blob/main/docs/adr/ADR-0006-file-manifests-and-links.md)) is a `.ant` file, or an `ant://manifest/` link, that describes a set of files: each entry has an optional path and size, and either an embedded DataMap (the manifest is then the key to that file) or a public file's DataMap address. The daemon builds and decodes manifests through ant-core, so the same inputs give the `ant` CLI's exact bytes. Needs the antd release after 0.15.0. See `examples/09-manifests.ts`. +A manifest ([ADR-0006](https://github.com/WithAutonomi/ant-client/blob/main/docs/adr/ADR-0006-file-manifests-and-links.md)) is a `.ant` file, or an `ant://manifest/` link, that describes a set of files: each entry has an optional path and size, and either an embedded DataMap (the manifest is then the key to that file) or a public file's DataMap address. The daemon builds and decodes manifests through ant-core, so the same inputs give the `ant` CLI's exact bytes. Needs antd 0.16.0 or later. See `examples/09-manifests.ts`. **Nothing is uploaded or paid for**, and the daemon needs no wallet. Building (with `embedRoots`) and decoding with `resolve` read from the network, so they can time out; they are safe to retry. @@ -150,7 +150,7 @@ See `finalizeWithRetry` in `examples/finalize-with-retry.ts` (used by `examples/ ### Pointers -A pointer is a small, owner-signed, mutable reference (the antd release after 0.15.0, the first with pointers). Its address is derived from its owner's key and never changes. What it points at (a chunk, such as a public file's data map, or another pointer) can be updated by the owner, and the owner can hand the pointer over to another pointer for good. The daemon signs with owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so writes name the pointer by its address (`owner`) and no key ever crosses the API. See `examples/08-pointers.ts`. +A pointer is a small, owner-signed, mutable reference (antd 0.16.0 or later, the first release with pointers). Its address is derived from its owner's key and never changes. What it points at (a chunk, such as a public file's data map, or another pointer) can be updated by the owner, and the owner can hand the pointer over to another pointer for good. The daemon signs with owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so writes name the pointer by its address (`owner`) and no key ever crosses the API. See `examples/08-pointers.ts`. **Every write pays, and every attempt pays again.** A create, update or transfer costs about the price of one chunk, paid by the daemon wallet. The client never retries a request, and you should not retry `pointerCreate`, `pointerUpdate`, `pointerTransfer` or `pointerFinalize` automatically either. Reads are free to retry: a `CloseGroupShortfallError` on a read usually clears once an update in flight settles. diff --git a/antd-js/examples/09-manifests.ts b/antd-js/examples/09-manifests.ts index 96bdca59..25e7c8f1 100644 --- a/antd-js/examples/09-manifests.ts +++ b/antd-js/examples/09-manifests.ts @@ -7,7 +7,7 @@ * entry's exact size. * * Prerequisites: - * - the antd release after 0.15.0, on a local testnet with a wallet. + * - antd 0.16.0 or later, on a local testnet with a wallet. * - ANTD_BASE_URL (optional): the daemon URL, default http://localhost:8082. * Prefer 127.0.0.1 to localhost on Node 18, which resolves localhost to ::1. * diff --git a/antd-js/src/manifests.ts b/antd-js/src/manifests.ts index 5539bf0e..4ac01c17 100644 --- a/antd-js/src/manifests.ts +++ b/antd-js/src/manifests.ts @@ -1,6 +1,6 @@ import { BadRequestError, InternalError } from "./errors.js"; -// ---- Manifests (the antd release after 0.15.0) ---- +// ---- Manifests (antd 0.16.0 or later) ---- // // An ADR-0006 manifest (a `.ant` file, or an `ant://manifest/` link) describes // a set of files. Each entry has an optional path and size, and either an diff --git a/antd-js/src/rest-client.ts b/antd-js/src/rest-client.ts index 0c59ad5a..8124b653 100644 --- a/antd-js/src/rest-client.ts +++ b/antd-js/src/rest-client.ts @@ -687,7 +687,7 @@ export class RestClient { * is a `BadRequestError` too, its message naming each `entries[i]`. * `options.embedRoots` defaults to `true`. * - * Requires the antd release after 0.15.0. + * Requires antd 0.16.0 or later. */ async buildManifest( entries: ManifestEntryInput[], @@ -705,7 +705,7 @@ export class RestClient { * not fetched, and one entry's failure is reported in its `error` rather * than failing the call. * - * Requires the antd release after 0.15.0. + * Requires antd 0.16.0 or later. */ async decodeManifest( manifest: Uint8Array | Buffer, @@ -722,7 +722,7 @@ export class RestClient { * as one public entry with no path and `source: "file_link"`. See * {@link decodeManifest} for `resolve`. * - * Requires the antd release after 0.15.0. + * Requires antd 0.16.0 or later. */ async decodeManifestLink(link: string, resolve: boolean = false): Promise { const body = manifestLinkDecodeBody(link, resolve); diff --git a/antd-kotlin/README.md b/antd-kotlin/README.md index 681a28ba..907b26f9 100644 --- a/antd-kotlin/README.md +++ b/antd-kotlin/README.md @@ -73,7 +73,7 @@ All methods are `suspend` functions for use with Kotlin coroutines. ## Pointers -A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. An owner the daemon holds no key for is a `BadRequestException`. Addresses are 64 hex characters; the daemon accepts a `0x` prefix but always returns bare lowercase hex, so normalise before comparing. The pointer methods need the antd release after 0.15.0, the first with pointers; both `AntdRestClient` and `AntdGrpcClient` implement them. +A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. An owner the daemon holds no key for is a `BadRequestException`. Addresses are 64 hex characters; the daemon accepts a `0x` prefix but always returns bare lowercase hex, so normalise before comparing. The pointer methods need antd 0.16.0 or later, the first release with pointers; both `AntdRestClient` and `AntdGrpcClient` implement them. **Every write pays** (about the price of one chunk), and every attempt pays again. Neither client retries `pointerCreate`, `pointerUpdate`, `pointerTransfer` or `pointerFinalize`, and you should not wrap them in an automatic retry. Reads are free to retry; a read during an update or churn can throw `CloseGroupShortfallException`. @@ -110,7 +110,7 @@ See `examples/src/main/kotlin/com/autonomi/examples/Example08Pointers.kt` for a ## Manifests -A manifest (ADR-0006) is a `.ant` file that lists a set of files, each with an optional path and size and either an embedded DataMap (a private upload; the manifest is then the key to it) or a public file's DataMap address. A small one also fits in an `ant://manifest/...` link. The daemon builds and reads them, so you never handle the format yourself. **Nothing is uploaded or paid for**: you build a manifest from DataMaps and addresses you already hold (from `dataPut`, `filePutPublic` and so on), then store or share the bytes or the link however you like. The calls are free to retry. `resolve` and the default root embedding read from the network, so they can time out. The manifest methods need the antd release after 0.15.0; both `AntdRestClient` and `AntdGrpcClient` implement them. +A manifest (ADR-0006) is a `.ant` file that lists a set of files, each with an optional path and size and either an embedded DataMap (a private upload; the manifest is then the key to it) or a public file's DataMap address. A small one also fits in an `ant://manifest/...` link. The daemon builds and reads them, so you never handle the format yourself. **Nothing is uploaded or paid for**: you build a manifest from DataMaps and addresses you already hold (from `dataPut`, `filePutPublic` and so on), then store or share the bytes or the link however you like. The calls are free to retry. `resolve` and the default root embedding read from the network, so they can time out. The manifest methods need antd 0.16.0 or later; both `AntdRestClient` and `AntdGrpcClient` implement them. ```kotlin val client = AntdClient.createRest() @@ -226,7 +226,7 @@ Run individual examples: ANTD_POINTER_OWNER= ./gradlew :examples:run --args="8" ``` -Example 9 (manifests) is not part of `all`: it needs the antd release after 0.15.0. It uploads two small public blobs (each pays), then builds and decodes a manifest of them for free. Run it by number; `ANTD_BASE_URL` overrides the daemon URL (default `http://localhost:8082`): +Example 9 (manifests) is not part of `all`: it needs antd 0.16.0 or later. It uploads two small public blobs (each pays), then builds and decodes a manifest of them for free. Run it by number; `ANTD_BASE_URL` overrides the daemon URL (default `http://localhost:8082`): ```bash ./gradlew :examples:run --args="9" diff --git a/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Example09Manifests.kt b/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Example09Manifests.kt index 01eb34cd..c120efb0 100644 --- a/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Example09Manifests.kt +++ b/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Example09Manifests.kt @@ -10,8 +10,8 @@ import com.autonomi.sdk.ManifestEntryInput * decodes its `ant://` link, asking the daemon for each entry's exact size. * * Building and decoding a manifest are free: nothing is uploaded or paid for. - * The two uploads pay, so the daemon needs a wallet. Needs the antd release - * after 0.15.0. `ANTD_BASE_URL` overrides the daemon URL (default + * The two uploads pay, so the daemon needs a wallet. Needs antd 0.16.0 + * or later. `ANTD_BASE_URL` overrides the daemon URL (default * `http://localhost:8082`). * * Not part of `all`; run it explicitly: diff --git a/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Main.kt b/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Main.kt index 528caab2..726dc1a9 100644 --- a/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Main.kt +++ b/antd-kotlin/examples/src/main/kotlin/com/autonomi/examples/Main.kt @@ -18,7 +18,7 @@ fun main(args: Array) = runBlocking { // Pays for every write and needs a never-written owner, so it runs // only when asked for by number, never as part of "all". "8" -> example08Pointers() - // Needs the antd release after 0.15.0, so it runs only when asked for + // Needs antd 0.16.0 or later, so it runs only when asked for // by number, never as part of "all". "9" -> example09Manifests() "all" -> { diff --git a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdGrpcClient.kt b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdGrpcClient.kt index c80d954e..0b6134a9 100644 --- a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdGrpcClient.kt +++ b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdGrpcClient.kt @@ -392,7 +392,7 @@ class AntdGrpcClient internal constructor( // raw `bytes` here. A manifest can be 64 MiB and grpc-java receives 4 MiB // by default, so this stub alone raises both limits to // MAX_MANIFEST_GRPC_MESSAGE (every call made on it carries them); the - // other services keep the defaults. Requires the antd release after 0.15.0. + // other services keep the defaults. Requires antd 0.16.0 or later. internal val manifestStub = ManifestServiceGrpcKt.ManifestServiceCoroutineStub(channel) .withMaxInboundMessageSize(MAX_MANIFEST_GRPC_MESSAGE) diff --git a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdRestClient.kt b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdRestClient.kt index b391c0ed..6965ffaa 100644 --- a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdRestClient.kt +++ b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/AntdRestClient.kt @@ -432,7 +432,7 @@ class AntdRestClient( // // The `.ant` bytes travel as base64 in the JSON (`manifest`); callers only // see raw bytes. Nothing is paid for. See IAntdClient for the contract and - // Manifests.kt for the wire shapes. Requires the antd release after 0.15.0. + // Manifests.kt for the wire shapes. Requires antd 0.16.0 or later. /** `POST /v1/manifests/build`. See [IAntdClient.buildManifest]. */ override suspend fun buildManifest(entries: List, options: BuildManifestOptions): BuiltManifest { @@ -589,7 +589,7 @@ class AntdRestClient( // attempt pays again: this client never retries a create, update, // transfer or finalize, and callers should not either. Reads are free to // retry; a read during an update or churn can throw - // CloseGroupShortfallException. Requires the antd release after 0.15.0, + // CloseGroupShortfallException. Requires antd 0.16.0 or later, // the first with pointers. /** `GET /v1/pointers/keys`: the addresses of the pointers this daemon can write. */ diff --git a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/Exceptions.kt b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/Exceptions.kt index 2f044cf1..3285175d 100644 --- a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/Exceptions.kt +++ b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/Exceptions.kt @@ -202,7 +202,7 @@ internal object ExceptionMapping { private val json = Json { ignoreUnknownKeys = true } /** - * gRPC metadata key the daemon (with the pointer API, after 0.15.0) sets + * gRPC metadata key the daemon (0.16.0 or later) sets * on statuses whose code is shared with older errors, carrying the REST * `code` string. */ diff --git a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/IAntdClient.kt b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/IAntdClient.kt index b303ce35..8626c182 100644 --- a/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/IAntdClient.kt +++ b/antd-kotlin/lib/src/main/kotlin/com/autonomi/sdk/IAntdClient.kt @@ -39,7 +39,7 @@ interface IAntdClient : Closeable { suspend fun fileGet(dataMap: String, destPath: String) suspend fun fileCost(path: String, isPublic: Boolean = true, paymentMode: PaymentMode = PaymentMode.AUTO): UploadCostEstimate - // Manifests (the antd release after 0.15.0) + // Manifests (antd 0.16.0 or later) // // ADR-0006 `.ant` files and `ant://` links, built and read by the daemon. // Nothing is uploaded or paid for; the calls are free to retry. `resolve` @@ -100,7 +100,7 @@ interface IAntdClient : Closeable { suspend fun finalizeUpload(uploadId: String, txHashes: Map): FinalizeUploadResult suspend fun finalizeMerkleUpload(uploadId: String, winnerPoolHash: String): FinalizeMerkleUploadResult - // Pointers (the antd release after 0.15.0, the first with pointers) + // Pointers (antd 0.16.0 or later, the first release with pointers) // // Owner-signed, paid, mutable references. The daemon holds the owner keys // (`antd --pointer-keys`), so a write names the pointer by its address diff --git a/antd-lua/README.md b/antd-lua/README.md index 18184b42..8b03a32f 100644 --- a/antd-lua/README.md +++ b/antd-lua/README.md @@ -133,7 +133,7 @@ All methods return `value, err` following Lua convention. On success `err` is `n ### Manifests -A manifest (ADR-0006) is one `.ant` file, or one `ant://manifest/` link, that describes a set of files: each entry has an optional path and size, and either an embedded DataMap (the manifest is then the key to the file) or a public file's DataMap address. The daemon builds and decodes manifests, so the format never has to be re-implemented here. The manifest methods need an antd with the manifest API (the antd release after 0.15.0). +A manifest (ADR-0006) is one `.ant` file, or one `ant://manifest/` link, that describes a set of files: each entry has an optional path and size, and either an embedded DataMap (the manifest is then the key to the file) or a public file's DataMap address. The daemon builds and decodes manifests, so the format never has to be re-implemented here. The manifest methods need an antd with the manifest API (antd 0.16.0 or later). **Nothing is uploaded or paid for.** Building a manifest and a resolving decode only read from the network (the embedding policy and `resolve` fetch DataMaps), so they can time out, and they are free to retry. To share a manifest, store its bytes yourself, or hand out the link. @@ -186,7 +186,7 @@ A finalize where some chunks stayed unstored after the daemon's retries returns ### Pointers -A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. The pointer methods need an antd with the pointer API (the release after 0.15.0). +A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. The pointer methods need an antd with the pointer API (0.16.0 or later). **Every write pays, and the SDK never retries one.** `pointer_create`, `pointer_update`, `pointer_transfer` and `pointer_finalize` each pay about the price of one chunk, and every attempt pays again. Do not retry them automatically: check the error first. Reads are free to retry; a read during an update or churn can fail with `close_group_shortfall`. diff --git a/antd-lua/src/antd/client.lua b/antd-lua/src/antd/client.lua index 136bae8b..a0146c88 100644 --- a/antd-lua/src/antd/client.lua +++ b/antd-lua/src/antd/client.lua @@ -651,7 +651,7 @@ end -- -- A pointer's owner key lives in the daemon (`antd --pointer-keys`); a write -- names the pointer by its address (`owner`). Needs an antd with the pointer --- API (the release after 0.15.0). +-- API (0.16.0 or later). -- -- Every write (pointer_create, pointer_update, pointer_transfer, -- pointer_finalize) pays, about the price of one chunk, and every attempt diff --git a/antd-lua/src/antd/manifests.lua b/antd-lua/src/antd/manifests.lua index a6c1702c..d5fc5729 100644 --- a/antd-lua/src/antd/manifests.lua +++ b/antd-lua/src/antd/manifests.lua @@ -16,7 +16,7 @@ -- `link`, `name` and the torrent info hashes) read as nil when unset too. -- -- These methods are installed on antd.client's Client by `install`. Needs an --- antd with the manifest API (the antd release after 0.15.0). +-- antd with the manifest API (antd 0.16.0 or later). -- -- @module antd.manifests diff --git a/antd-mcp/README.md b/antd-mcp/README.md index b2b8fe6f..1f060df6 100644 --- a/antd-mcp/README.md +++ b/antd-mcp/README.md @@ -130,7 +130,7 @@ A manifest (a `.ant` file, or an `ant://manifest/` link to one) bundles files th | 30 | `build_manifest(entries, name?, torrent_info_hashes?, embed_roots?)` | Each entry is `{path?, size?, data_map? \| address?}`: give exactly one of `data_map` or `address`. Returns `manifest_base64` (the `.ant` bytes), `link` (null when the manifest exceeds 1,500 bytes; share the file instead) and `entries`. `embed_roots` defaults to true. A bad entry returns `BAD_REQUEST` with a message naming `entries[i]`. | | 31 | `decode_manifest(manifest_base64? \| link?, resolve?)` | Give exactly one of the base64 `.ant` bytes or a `link` (manifest link, file link or bare address). Returns `source` (`manifest` or `file_link`), `name`, the torrent hashes and `entries`. With `resolve=true` it also reads each entry's root from the network to fill in `exact_size`; one entry's failure is in its `error`, not a failed call. | -Unset sizes are `null`, never 0. These tools need an antd daemon with the manifest API (the antd release after 0.15.0) and an [`antd`](https://pypi.org/project/antd/) Python SDK that has `build_manifest`. With an older SDK the server still starts and serves its other tools; it just does not register the manifest tools. +Unset sizes are `null`, never 0. These tools need an antd daemon with the manifest API (antd 0.16.0 or later) and an [`antd`](https://pypi.org/project/antd/) Python SDK that has `build_manifest`. With an older SDK the server still starts and serves its other tools; it just does not register the manifest tools. ### Payment Modes diff --git a/antd-php/README.md b/antd-php/README.md index ab5d2d43..f00339b1 100644 --- a/antd-php/README.md +++ b/antd-php/README.md @@ -100,7 +100,7 @@ pointer) can be changed by the owner, and the owner can hand it over to another good. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`$owner`), never by a key. An owner the daemon holds no key for is a `BadRequestError`. -The pointer methods need the first antd release with pointers (after 0.15.0). +The pointer methods need antd 0.16.0 or later (the first release with pointers). **Every write pays** (about the price of one chunk), and every attempt pays again. The client never retries `pointerCreate`, `pointerUpdate`, `pointerTransfer` or `pointerFinalize`, and you @@ -148,7 +148,7 @@ A manifest (ADR-0006) is one `.ant` file, or an `ant://manifest/` link when it i that describes a set of files. Each entry has an optional path and size and either an embedded DataMap or a public DataMap address. The daemon builds and decodes them, so you never handle the format. An embedded entry carries a private upload's DataMap, the key to that file: anyone with -the manifest or its link can read it. The manifest methods need the antd release after 0.15.0. +the manifest or its link can read it. The manifest methods need antd 0.16.0 or later. **Nothing is uploaded or paid for.** Build a manifest from the DataMaps and addresses your uploads already returned. Building (with root embedding, the default) and a resolving decode diff --git a/antd-php/src/ManifestMethods.php b/antd-php/src/ManifestMethods.php index 753c7b16..90c55759 100644 --- a/antd-php/src/ManifestMethods.php +++ b/antd-php/src/ManifestMethods.php @@ -29,7 +29,7 @@ * size is null, never 0. * * Mixed into {@see AntdClient} (it uses the client's private doJson() and - * doJsonAsync()). Needs the antd release after 0.15.0. + * doJsonAsync()). Needs antd 0.16.0 or later. */ trait ManifestMethods { diff --git a/antd-py/README.md b/antd-py/README.md index ae31a7ad..eb1e1ccf 100644 --- a/antd-py/README.md +++ b/antd-py/README.md @@ -20,7 +20,7 @@ pip install -e ".[all]" ## Compatibility -This package talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Python 3.10+. Tested against antd 0.12.x; `health()` fields such as `version`/`evm_network` need antd 0.4.0 or newer, and the [pointer](#pointers) methods need the antd release after 0.15.0, the first with pointers. For a daemon-less client see the `ant-sdk` package (import `ant_ffi`). Not related to the Ant Design UI library. +This package talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Python 3.10+. Tested against antd 0.12.x; `health()` fields such as `version`/`evm_network` need antd 0.4.0 or newer, and the [pointer](#pointers) methods need antd 0.16.0 or later, the first release with pointers. For a daemon-less client see the `ant-sdk` package (import `ant_ffi`). Not related to the Ant Design UI library. ## Quick Start @@ -113,7 +113,7 @@ python scripts/generate_proto.py #### Manifests -A manifest (ADR-0006) describes a set of files as one `.ant` file, or as an `ant://manifest/` link when it is small enough. Each entry has an optional path and size, and either an embedded DataMap (a private file: the manifest is its key) or a public DataMap address. The daemon builds and decodes manifests through ant-core, so the SDK never handles the format. Every method is on all four clients (sync and async, REST and gRPC) with the same signatures, types and errors, and needs the antd release after 0.15.0, the first with manifests. See `examples/10_manifests.py`. +A manifest (ADR-0006) describes a set of files as one `.ant` file, or as an `ant://manifest/` link when it is small enough. Each entry has an optional path and size, and either an embedded DataMap (a private file: the manifest is its key) or a public DataMap address. The daemon builds and decodes manifests through ant-core, so the SDK never handles the format. Every method is on all four clients (sync and async, REST and gRPC) with the same signatures, types and errors, and needs antd 0.16.0 or later, the first release with manifests. See `examples/10_manifests.py`. **Nothing is uploaded or paid for.** Building and decoding only read the network: on build the default embedding policy resolves shrunk DataMaps, and on decode `resolve=True` fetches each entry's DataMap (never its content). A call can therefore time out, and retrying it is safe. Upload the files first (`data_put_public`, `file_put`, ...) and pass their addresses or DataMaps. diff --git a/antd-py/src/antd/_grpc.py b/antd-py/src/antd/_grpc.py index e2f37f00..03fd50f7 100644 --- a/antd-py/src/antd/_grpc.py +++ b/antd-py/src/antd/_grpc.py @@ -284,7 +284,7 @@ def _build_manifest_request( } -# Trailing-metadata key the daemon (with the pointer API, after 0.15.0) sets on +# Trailing-metadata key the daemon (0.16.0 or later) sets on # statuses whose gRPC code is shared with older errors; the value is the REST # body's ``code``. _ANTD_ERROR_CODE_KEY = "x-antd-error-code" diff --git a/antd-py/src/antd/_rest.py b/antd-py/src/antd/_rest.py index fa272339..d89a328f 100644 --- a/antd-py/src/antd/_rest.py +++ b/antd-py/src/antd/_rest.py @@ -514,8 +514,8 @@ def file_cost(self, path: str, is_public: bool = True, payment_mode: PaymentMode # --- Manifests --- # - # ADR-0006 `.ant` files and `ant://` links (antd with the manifest API, - # the release after 0.15.0). The daemon builds and decodes them through + # ADR-0006 `.ant` files and `ant://` links (antd 0.16.0 or + # later). The daemon builds and decodes them through # ant-core, so callers never handle the format. Nothing is uploaded or # paid for: these calls only read the network (the embedding policy on # build, ``resolve`` on decode), so they can time out and are safe to @@ -726,8 +726,8 @@ def finalize_merkle_upload( # --- Pointers --- # - # Owner-signed, paid, mutable references (antd with the pointer API, - # after 0.15.0). antd signs with owner keys it loaded at startup + # Owner-signed, paid, mutable references (antd 0.16.0 or + # later). antd signs with owner keys it loaded at startup # (``--pointer-keys``); a write names the pointer by its address # (``owner``), and pointer_keys() lists the ones it can write. # diff --git a/antd-ruby/README.md b/antd-ruby/README.md index 427c7243..65811b22 100644 --- a/antd-ruby/README.md +++ b/antd-ruby/README.md @@ -18,7 +18,7 @@ gem install antd ## Compatibility -This gem talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Ruby 3.1+. Tested against antd 0.12.x; the pointer methods need the antd release after 0.15.0, the first with pointers. The REST client has no runtime dependencies; the gRPC transport (`Antd::GrpcClient`) needs the `grpc` gem, which is deliberately not a runtime dependency of this gem — add `gem "grpc"` yourself to use it. +This gem talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Ruby 3.1+. Tested against antd 0.12.x; the pointer methods need antd 0.16.0 or later, the first release with pointers. The REST client has no runtime dependencies; the gRPC transport (`Antd::GrpcClient`) needs the `grpc` gem, which is deliberately not a runtime dependency of this gem — add `gem "grpc"` yourself to use it. ## Quick Start @@ -337,8 +337,8 @@ A manifest (ADR-0006) describes a set of files in one `.ant` file or `ant://` link: each entry has an optional path and size, and either an embedded DataMap (from a private upload; the manifest is then the key to the file) or a public file's DataMap address. The daemon builds and decodes -manifests, so the SDK never handles the format itself. These methods need the -antd release after 0.15.0. +manifests, so the SDK never handles the format itself. These methods need +antd 0.16.0 or later. **Nothing is uploaded or paid for.** Building one from DataMaps and addresses you already hold is free. Embedding roots (on build) and `resolve` (on diff --git a/antd-ruby/lib/antd/client.rb b/antd-ruby/lib/antd/client.rb index cc0e280c..f57cc7e8 100644 --- a/antd-ruby/lib/antd/client.rb +++ b/antd-ruby/lib/antd/client.rb @@ -419,8 +419,8 @@ def finalize_merkle_upload(upload_id, winner_pool_hash, store_data_map: false) # --- Pointers --- # - # Owner-signed, paid, mutable references (antd with the pointer API, the - # release after 0.15.0). The daemon signs with owner keys it loaded at + # Owner-signed, paid, mutable references (antd 0.16.0 or + # later). The daemon signs with owner keys it loaded at # startup (+antd --pointer-keys +), so a write names the # pointer by its address (+owner+); +pointer_keys+ lists the pointers it # can write. diff --git a/antd-ruby/lib/antd/errors.rb b/antd-ruby/lib/antd/errors.rb index ebaf5488..a831aa9c 100644 --- a/antd-ruby/lib/antd/errors.rb +++ b/antd-ruby/lib/antd/errors.rb @@ -282,7 +282,7 @@ def self.parse_partial_upload_message(message) } end - # Metadata key the daemon (with the pointer API, after 0.15.0) sets on gRPC + # Metadata key the daemon (0.16.0 or later) sets on gRPC # statuses whose code is shared with older errors, carrying the REST +code+. ANTD_ERROR_CODE_METADATA = "x-antd-error-code" diff --git a/antd-ruby/lib/antd/grpc_manifests.rb b/antd-ruby/lib/antd/grpc_manifests.rb index ceb4781c..70563baa 100644 --- a/antd-ruby/lib/antd/grpc_manifests.rb +++ b/antd-ruby/lib/antd/grpc_manifests.rb @@ -26,7 +26,7 @@ class GrpcClient # Mirrors +Client#build_manifest+. Nothing is paid for. # - # Needs the antd release after 0.15.0. + # Needs antd 0.16.0 or later. # # @return [BuiltManifest] # @raise [BadRequestError] an entry with both or neither of +data_map+ and @@ -53,7 +53,7 @@ def build_manifest(entries, name: nil, torrent_info_hashes: nil, embed_roots: tr # Mirrors +Client#decode_manifest+. The bytes are sent raw. # - # Needs the antd release after 0.15.0. + # Needs antd 0.16.0 or later. # # @return [DecodedManifest] def decode_manifest(manifest, resolve: false) @@ -64,7 +64,7 @@ def decode_manifest(manifest, resolve: false) # Mirrors +Client#decode_manifest_link+. # - # Needs the antd release after 0.15.0. + # Needs antd 0.16.0 or later. # # @return [DecodedManifest] def decode_manifest_link(link, resolve: false) diff --git a/antd-ruby/lib/antd/manifests.rb b/antd-ruby/lib/antd/manifests.rb index be320822..ca2ea4a4 100644 --- a/antd-ruby/lib/antd/manifests.rb +++ b/antd-ruby/lib/antd/manifests.rb @@ -172,7 +172,7 @@ class Client # skip that fetch (ADR-0006's policy). That reads from the network, so the # call can time out; it is safe to retry. # - # Needs the antd release after 0.15.0. + # Needs antd 0.16.0 or later. # # @param entries [Array] each with exactly one # of +data_map+ or +address+; checked before anything is sent @@ -219,7 +219,7 @@ def build_manifest(entries, name: nil, torrent_info_hashes: nil, embed_roots: tr # are not fetched, and one entry's failure is reported in its +error+, # not as a failed call. Nothing is paid for; safe to retry. # - # Needs the antd release after 0.15.0. + # Needs antd 0.16.0 or later. # # @param manifest [String] the `.ant` bytes # @param resolve [Boolean] @@ -235,7 +235,7 @@ def decode_manifest(manifest, resolve: false) # Decode an `ant://` manifest link, file link or bare 64-hex address # (POST /v1/manifests/decode). See +decode_manifest+ for +resolve+. # - # Needs the antd release after 0.15.0. + # Needs antd 0.16.0 or later. # # @param link [String] # @param resolve [Boolean] diff --git a/antd-rust/README.md b/antd-rust/README.md index 429ae4fd..937c2ee3 100644 --- a/antd-rust/README.md +++ b/antd-rust/README.md @@ -17,7 +17,7 @@ antd-client = "0.3" ## Compatibility -This crate talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Rust 1.82+. The byte-range methods need antd 0.15.0 or later and the pointer and manifest methods need the antd release after 0.15.0, the first with them; the rest of the API works with antd 0.14.x. The gRPC client code is pre-generated and committed, so consumers need neither `protoc` nor the daemon's `.proto` files. For a daemon-less client see the `ant-ffi` crate in this repository. +This crate talks to a running [antd](https://github.com/WithAutonomi/ant-sdk/tree/main/antd) daemon; it does not join the network itself. Rust 1.82+. The byte-range methods need antd 0.15.0 or later and the pointer and manifest methods need antd 0.16.0 or later, the first release with them; the rest of the API works with antd 0.14.x. The gRPC client code is pre-generated and committed, so consumers need neither `protoc` nor the daemon's `.proto` files. For a daemon-less client see the `ant-ffi` crate in this repository. ## Quick Start @@ -135,7 +135,7 @@ each with an optional path and size and either an embedded DataMap (the manifest to the file) or a public file's DataMap address. The daemon builds and decodes manifests through ant-core, so nothing here re-implements the format. Nothing is uploaded or paid for. A build (its root-embedding policy) and a resolving decode read from the network, so they can time out; -retrying them is safe. These methods need the antd release after 0.15.0. +retrying them is safe. These methods need antd 0.16.0 or later. | Method | Description | |--------|-------------| diff --git a/antd-rust/src/errors.rs b/antd-rust/src/errors.rs index c005e7de..7c71a06f 100644 --- a/antd-rust/src/errors.rs +++ b/antd-rust/src/errors.rs @@ -243,7 +243,7 @@ impl From for AntdError { } } -/// Metadata key the daemon (with the pointer API, after 0.15.0) sets on statuses whose gRPC code +/// Metadata key the daemon (0.16.0 or later) sets on statuses whose gRPC code /// is shared with older errors, carrying the REST `code` string. const ANTD_ERROR_CODE_METADATA: &str = "x-antd-error-code"; diff --git a/antd-rust/src/manifests.rs b/antd-rust/src/manifests.rs index f3cfcd95..d521d235 100644 --- a/antd-rust/src/manifests.rs +++ b/antd-rust/src/manifests.rs @@ -11,7 +11,7 @@ //! them as base64 in JSON and gRPC as `bytes`; neither form reaches the //! caller. //! -//! Requires the antd release after 0.15.0. +//! Requires antd 0.16.0 or later. use base64::engine::general_purpose::STANDARD as BASE64; use base64::Engine; @@ -317,7 +317,7 @@ impl Client { /// the rest (hex, paths, sizes) and reports every invalid entry, as /// `entries[i]: ...`, in one [`AntdError::BadRequest`]. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. pub async fn build_manifest( &self, entries: &[ManifestEntryInput], @@ -375,7 +375,7 @@ impl Client { /// manifest are [`AntdError::BadRequest`]; empty bytes are refused before /// anything is sent. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. pub async fn decode_manifest( &self, manifest: &[u8], @@ -396,7 +396,7 @@ impl Client { /// one public entry with no path, with `source` `"file_link"`. See /// [`decode_manifest`](Self::decode_manifest) for `resolve`. /// - /// Requires the antd release after 0.15.0. + /// Requires antd 0.16.0 or later. pub async fn decode_manifest_link( &self, link: &str, diff --git a/antd-swift/README.md b/antd-swift/README.md index dbee392f..66d19450 100644 --- a/antd-swift/README.md +++ b/antd-swift/README.md @@ -86,7 +86,7 @@ All methods are `async throws` for use with Swift concurrency. ## Pointers -A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes. The owner can point it at a new target (a chunk, such as a public upload's address, or another pointer), and can hand it over to another pointer for good with `pointerTransfer`. Both REST and gRPC clients implement the full pointer API (antd with the pointer API, after 0.15.0). +A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes. The owner can point it at a new target (a chunk, such as a public upload's address, or another pointer), and can hand it over to another pointer for good with `pointerTransfer`. Both REST and gRPC clients implement the full pointer API (antd 0.16.0 or later). antd signs with the owner keys it loaded at startup (`antd --pointer-keys`). A write names the pointer by its address (`owner`), never by a key. `pointerKeys()` lists the pointers the daemon can write, and an owner it holds no key for is a `BadRequestError`. @@ -201,7 +201,7 @@ See `finalizeWithRetry` in `Sources/AntdExamples/Main.swift` and the contract in ## Manifests -A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link, that describes a set of files. Each entry has an optional path and size, and either an embedded DataMap (a private upload's) or a public DataMap address. The daemon builds and decodes manifests, so you never handle the format yourself. Both REST and gRPC clients implement the manifest API, which needs the antd release after 0.15.0. +A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link, that describes a set of files. Each entry has an optional path and size, and either an embedded DataMap (a private upload's) or a public DataMap address. The daemon builds and decodes manifests, so you never handle the format yourself. Both REST and gRPC clients implement the manifest API, which needs antd 0.16.0 or later. **Nothing is uploaded or paid for.** The daemon reads the network only to resolve DataMaps: when it embeds roots on build, and for `resolve` on decode. So a call can time out, and it is safe to retry. @@ -256,7 +256,7 @@ ANTD_POINTER_OWNER=
swift run AntdExamples pointers # or: 9 ```bash # Manifests: two public uploads (each pays), then a free build and a -# resolving decode of the link. Needs the antd release after 0.15.0, so it +# resolving decode of the link. Needs antd 0.16.0 or later, so it # runs only when named. ANTD_BASE_URL overrides the daemon URL. swift run AntdExamples manifests # or: 10 ``` diff --git a/antd-swift/Sources/AntdExamples/Main.swift b/antd-swift/Sources/AntdExamples/Main.swift index 897ae648..52b6d07e 100644 --- a/antd-swift/Sources/AntdExamples/Main.swift +++ b/antd-swift/Sources/AntdExamples/Main.swift @@ -14,7 +14,7 @@ // until the full Linux scaffolding lands. // // "10" / "manifests" builds a manifest of two public uploads and decodes its -// link. It needs the antd release after 0.15.0 (the manifest API) and pays +// link. It needs antd 0.16.0 or later (the manifest API) and pays // for the two uploads, so it runs only when named, never under "all". import Foundation diff --git a/antd-swift/Sources/AntdSdk/AntdClientProtocol.swift b/antd-swift/Sources/AntdSdk/AntdClientProtocol.swift index facf5e26..8279c08b 100644 --- a/antd-swift/Sources/AntdSdk/AntdClientProtocol.swift +++ b/antd-swift/Sources/AntdSdk/AntdClientProtocol.swift @@ -29,7 +29,7 @@ public protocol AntdClientProtocol: Sendable { func fileGetPublic(address: String, destPath: String) async throws func fileCost(path: String, isPublic: Bool, paymentMode: PaymentMode) async throws -> UploadCostEstimate - // Manifests (the antd release after 0.15.0) + // Manifests (antd 0.16.0 or later) // // ADR-0006 `.ant` manifests and `ant://` links, built and decoded by the // daemon. Nothing is uploaded or paid for; the root-embedding policy and @@ -114,7 +114,7 @@ public protocol AntdClientProtocol: Sendable { /// or paying again. func finalizeMerkleUpload(uploadId: String, winnerPoolHash: String) async throws -> FinalizeMerkleUploadResult - // Pointers (antd with the pointer API, after 0.15.0) + // Pointers (antd 0.16.0 or later) // // Owner-signed, paid, mutable references. antd signs with the owner keys // it loaded at startup (`--pointer-keys`); a write names the pointer by diff --git a/antd-swift/Sources/AntdSdk/Manifests.swift b/antd-swift/Sources/AntdSdk/Manifests.swift index 6d80c0ce..d80d242e 100644 --- a/antd-swift/Sources/AntdSdk/Manifests.swift +++ b/antd-swift/Sources/AntdSdk/Manifests.swift @@ -15,7 +15,7 @@ import Foundation // carries them as base64 in JSON, gRPC as `bytes`, and the clients convert. // Sizes are `UInt64?`, and an unset size is `nil`, never `0`. // -// Requires the antd release after 0.15.0. +// Requires antd 0.16.0 or later. /// One file for ``AntdClientProtocol/buildManifest(entries:options:)``. Set /// exactly one of ``dataMap`` or ``address``; an entry with both or neither is diff --git a/antd-swift/Tests/AntdSdkTests/LiveManifestTests.swift b/antd-swift/Tests/AntdSdkTests/LiveManifestTests.swift index d7469fce..820d8e1e 100644 --- a/antd-swift/Tests/AntdSdkTests/LiveManifestTests.swift +++ b/antd-swift/Tests/AntdSdkTests/LiveManifestTests.swift @@ -1,8 +1,8 @@ import XCTest @testable import AntdSdk -/// Live manifest build and decode against a running antd (the release after -/// 0.15.0) with a devnet behind it. Nothing is uploaded or paid for: the test +/// Live manifest build and decode against a running antd (0.16.0 or +/// later) with a devnet behind it. Nothing is uploaded or paid for: the test /// builds and decodes manifests of data that is already stored. /// /// The REST test is skipped unless `ANTD_TEST_URL` and diff --git a/antd-zig/README.md b/antd-zig/README.md index de09dff2..ce570808 100644 --- a/antd-zig/README.md +++ b/antd-zig/README.md @@ -121,7 +121,7 @@ All methods return `!T` (error union) using Zig's standard error handling. ### Manifests -A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link, that lists a set of files. Each entry has an optional path and size, and either an embedded DataMap (from `dataPut` or `filePut`, so the manifest is the key to the file) or a public DataMap address (from `dataPutPublic` or `filePutPublic`). The daemon builds and decodes manifests, so you never handle the format yourself. The manifest methods need the antd release after 0.15.0. +A manifest (ADR-0006) is a `.ant` file, or an `ant://manifest/` link, that lists a set of files. Each entry has an optional path and size, and either an embedded DataMap (from `dataPut` or `filePut`, so the manifest is the key to the file) or a public DataMap address (from `dataPutPublic` or `filePutPublic`). The daemon builds and decodes manifests, so you never handle the format yourself. The manifest methods need antd 0.16.0 or later. **Nothing is uploaded or paid for.** Building and decoding cost nothing. `resolve` and the default root embedding read from the network, so a call can time out, and it is safe to retry. @@ -183,7 +183,7 @@ defer result.deinit(allocator); ### Pointers -A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. The pointer methods need the antd release after 0.15.0, the first with pointers. +A pointer is a small, owner-signed, mutable reference. Its address is derived from the owner's key and never changes; what it points at (a chunk, such as a public file's data map, or another pointer) can be changed by the owner. The daemon holds the owner keys, loaded at startup with `antd --pointer-keys ` (files in the format `ant pointer keygen` writes), so every write names the pointer by its address (`owner`), never by a key. The pointer methods need antd 0.16.0 or later, the first release with pointers. **Every write pays, and every attempt pays again.** A create, update or transfer costs about the price of one chunk from the daemon wallet. The SDK never retries a create, update, transfer or finalize, and you should not retry them automatically either. Reads are free to retry; a read during an update or churn can fail with `error.CloseGroupShortfall`. diff --git a/antd-zig/src/antd.zig b/antd-zig/src/antd.zig index f17852e4..b9aa1691 100644 --- a/antd-zig/src/antd.zig +++ b/antd-zig/src/antd.zig @@ -398,7 +398,7 @@ pub const Client = struct { return json_helpers.parseBase64Data(self.allocator, resp); } - // --- Manifests (the antd release after 0.15.0) --- + // --- Manifests (antd 0.16.0 or later) --- // // ADR-0006 `.ant` manifests and `ant://` links: a set of files, each with // an optional path and size and either an embedded DataMap or a public @@ -674,7 +674,7 @@ pub const Client = struct { return json_helpers.parseCostEstimate(self.allocator, resp); } - // --- Pointers (antd with the pointer API, after 0.15.0) --- + // --- Pointers (antd 0.16.0 or later) --- // // A pointer is a small, owner-signed, mutable reference. Its address is // derived from the owner's key and never changes; what it points at can diff --git a/antd/Cargo.lock b/antd/Cargo.lock index 20150505..3ce8fe1e 100644 --- a/antd/Cargo.lock +++ b/antd/Cargo.lock @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "antd" -version = "0.15.0" +version = "0.16.0" dependencies = [ "ant-core", "ant-protocol", diff --git a/antd/Cargo.toml b/antd/Cargo.toml index 978b5501..a8ec4e40 100644 --- a/antd/Cargo.toml +++ b/antd/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "antd" -version = "0.15.0" +version = "0.16.0" edition = "2021" license = "MIT OR Apache-2.0" diff --git a/antd/openapi.yaml b/antd/openapi.yaml index 042dd92d..3f6b827b 100644 --- a/antd/openapi.yaml +++ b/antd/openapi.yaml @@ -639,7 +639,7 @@ paths: operationId: buildManifest summary: Build a .ant manifest from DataMaps and public addresses description: >- - Builds an ADR-0006 manifest (added in the antd release after 0.15.0) through ant-core: + Builds an ADR-0006 manifest (added in antd 0.16.0) through ant-core: validation against the portable path rules, collision checks, sorting by effective name and the deterministic encoding all come from ant-core, so the same inputs give the ant CLI's exact bytes. Nothing @@ -686,7 +686,7 @@ paths: operationId: decodeManifest summary: Decode a .ant manifest, manifest link, file link or address description: >- - Decodes an ADR-0006 manifest (added in the antd release after 0.15.0), enforcing its + Decodes an ADR-0006 manifest (added in antd 0.16.0), enforcing its size (64 MiB), entry (100,000) and depth limits and the portable path rules. Give manifest (base64 .ant bytes) or link (ant://manifest/..., ant://
, or a bare 64-hex address; a file link is reported as diff --git a/docs/architecture.md b/docs/architecture.md index f12b16c6..0ee6ece0 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -89,7 +89,7 @@ Resolve: pointer address ──▶ antd ──▶ current target - antd holds the owner keys, loaded at startup with `--pointer-keys`, and signs every write; requests name a pointer by its address. - Every create, update and transfer pays (about one chunk's price), and every attempt pays again. Reads are free. -- Needs the first antd release with pointers (after 0.15.0). +- Needs antd 0.16.0 or later (the first release with pointers). Use for: a "latest version" address for a site, a release or a config. See [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). @@ -107,7 +107,7 @@ Decode: link or .ant bytes ──▶ antd ──▶ entries: path, kind, - Building and decoding **pay nothing and upload nothing**; upload the files first. They read the network only to resolve DataMaps. - An embedded entry carries a private file's DataMap, so whoever holds the manifest can read it. A public entry only names an address. - A link is recommended at no more than 1,500 bytes. Past that the build returns no link and you share the `.ant` bytes. -- Needs the antd release after 0.15.0. +- Needs antd 0.16.0 or later. Use for: sharing a folder-like set of files as one link, with paths and a name. See [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). diff --git a/docs/quickstart-cpp.md b/docs/quickstart-cpp.md index ce566190..4b109ec7 100644 --- a/docs/quickstart-cpp.md +++ b/docs/quickstart-cpp.md @@ -129,7 +129,7 @@ auto est = client.file_cost("/path/to/file.txt"); ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```cpp const std::string owner = client.pointer_keys().at(0).address; // a pointer antd can write @@ -191,7 +191,7 @@ Exception hierarchy (all inherit from `antd::AntdError`): ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```cpp auto bytes_of = [](std::string s) { return std::vector(s.begin(), s.end()); }; diff --git a/docs/quickstart-csharp.md b/docs/quickstart-csharp.md index b62815d1..54534118 100644 --- a/docs/quickstart-csharp.md +++ b/docs/quickstart-csharp.md @@ -108,7 +108,7 @@ var est = await client.FileCostAsync("/path/to/file.txt"); ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```csharp var owner = (await client.PointerKeysAsync())[0]; // a pointer antd can write @@ -175,7 +175,7 @@ Exception hierarchy: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```csharp var one = await client.DataPutPublicAsync(Encoding.UTF8.GetBytes("note one")); // pays diff --git a/docs/quickstart-dart.md b/docs/quickstart-dart.md index 7f1b1f55..273cd6df 100644 --- a/docs/quickstart-dart.md +++ b/docs/quickstart-dart.md @@ -92,7 +92,7 @@ final est = await client.fileCost('/path/to/file.txt'); ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```dart final owner = (await client.pointerKeys()).first; // a pointer antd can write @@ -150,7 +150,7 @@ Exception hierarchy: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```dart final one = await client.dataPutPublic(Uint8List.fromList(utf8.encode('one'))); // pays diff --git a/docs/quickstart-elixir.md b/docs/quickstart-elixir.md index 36f19f9d..735aef38 100644 --- a/docs/quickstart-elixir.md +++ b/docs/quickstart-elixir.md @@ -101,7 +101,7 @@ IO.puts("File address: #{result.address}") ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```elixir {:ok, [owner | _]} = Antd.Client.pointer_keys(client) # a pointer antd can write @@ -174,7 +174,7 @@ Error codes: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```elixir {:ok, one} = Antd.Client.data_put_public(client, "first file") # pays diff --git a/docs/quickstart-java.md b/docs/quickstart-java.md index 638e99e1..2ce9106a 100644 --- a/docs/quickstart-java.md +++ b/docs/quickstart-java.md @@ -125,7 +125,7 @@ UploadCostEstimate est = client.fileCost("/path/to/file.txt"); ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```java String owner = client.pointerKeys().get(0); // a pointer antd can write @@ -183,7 +183,7 @@ Exception hierarchy (all extend `AntdException`, which extends `RuntimeException ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```java String one = client.dataPutPublic("one".getBytes()).address(); // pays diff --git a/docs/quickstart-kotlin.md b/docs/quickstart-kotlin.md index ef6f139b..64446cfc 100644 --- a/docs/quickstart-kotlin.md +++ b/docs/quickstart-kotlin.md @@ -117,7 +117,7 @@ val est = client.fileCost("/path/to/file.txt") ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```kotlin val owner = client.pointerKeys().first() // a pointer antd can write @@ -175,7 +175,7 @@ Exception hierarchy: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```kotlin val one = client.dataPutPublic("first note".toByteArray()).address // pays diff --git a/docs/quickstart-lua.md b/docs/quickstart-lua.md index 3b9a5093..c5f00233 100644 --- a/docs/quickstart-lua.md +++ b/docs/quickstart-lua.md @@ -104,7 +104,7 @@ if err then error(err) end ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```lua local keys, err = client:pointer_keys() @@ -165,7 +165,7 @@ Error codes: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```lua local one = assert(client:data_put_public("first file")) -- pays diff --git a/docs/quickstart-php.md b/docs/quickstart-php.md index 40056234..9f227f28 100644 --- a/docs/quickstart-php.md +++ b/docs/quickstart-php.md @@ -86,7 +86,7 @@ $est = $client->fileCost("/path/to/file.txt"); ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```php $owner = $client->pointerKeys()[0]; // a pointer antd can write @@ -146,7 +146,7 @@ Exception hierarchy: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```php use Autonomi\Antd\Models\BuildManifestOptions; diff --git a/docs/quickstart-python.md b/docs/quickstart-python.md index de79c6cc..f45faf87 100644 --- a/docs/quickstart-python.md +++ b/docs/quickstart-python.md @@ -88,7 +88,7 @@ est = client.file_cost("/path/to/file.txt") ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```python owner = client.pointer_keys()[0] # a pointer antd can write @@ -170,7 +170,7 @@ Opens a Python REPL with `client` pre-connected and all types imported. ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```python from antd import ManifestEntryInput diff --git a/docs/quickstart-ruby.md b/docs/quickstart-ruby.md index 5c71b49a..9602ce53 100644 --- a/docs/quickstart-ruby.md +++ b/docs/quickstart-ruby.md @@ -87,7 +87,7 @@ est = client.file_cost("/path/to/file.txt") ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```ruby owner = client.pointer_keys.first # a pointer antd can write @@ -143,7 +143,7 @@ Exception hierarchy: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```ruby a = client.data_put_public("one").address # pays diff --git a/docs/quickstart-rust.md b/docs/quickstart-rust.md index 0ec15095..ffdb616e 100644 --- a/docs/quickstart-rust.md +++ b/docs/quickstart-rust.md @@ -103,7 +103,7 @@ let est = client.file_cost("/path/to/file.txt").await?; ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```rust use antd_client::{PaymentMode, PointerKind}; @@ -161,7 +161,7 @@ All variants carry a `message: String` field with details. ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```rust use antd_client::{BuildManifestOptions, ManifestEntryInput, PaymentMode}; diff --git a/docs/quickstart-swift.md b/docs/quickstart-swift.md index e65b3598..9ded3d9f 100644 --- a/docs/quickstart-swift.md +++ b/docs/quickstart-swift.md @@ -124,7 +124,7 @@ let est = try await client.fileCost(path: "/path/to/file.txt") ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```swift let owner = try await client.pointerKeys()[0].address // a pointer antd can write @@ -182,7 +182,7 @@ Error hierarchy: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```swift let one = try await client.dataPutPublic(Data("one".utf8), paymentMode: .auto) // pays diff --git a/docs/quickstart-zig.md b/docs/quickstart-zig.md index 1d693f02..6d9da51b 100644 --- a/docs/quickstart-zig.md +++ b/docs/quickstart-zig.md @@ -132,7 +132,7 @@ defer est.deinit(allocator); ## Pointers -A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs the first antd release with pointers (after 0.15.0). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). +A pointer is an owner-signed address you can move to new data. antd signs with the owner keys it loaded at startup (`antd --pointer-keys `, key files from `ant pointer keygen`), so `owner` is the pointer's address, never a key. Every create, update and transfer pays (about the price of one chunk) and is never retried; reads are free. A transfer hands the pointer over to another pointer for good. Needs antd 0.16.0 or later (the first release with pointers). Walk-through: [Tutorial: Point at a Public File and Update It](tutorial-pointers.md). ```zig const owner = ""; @@ -202,7 +202,7 @@ Error union variants: ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs the antd release after 0.15.0. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). +A manifest describes a set of files as one `ant://manifest/` link, or as a `.ant` file when the link would be too long. Each entry is either a public file's address or an embedded DataMap (the manifest is then the key to a private file), with an optional path. Building and decoding upload and pay for nothing: upload the files first, then describe them. Needs antd 0.16.0 or later. Walk-through: [Tutorial: Share a Set of Files as One Link](tutorial-manifests.md). ```zig const one = try client.dataPutPublic("first file", .auto); // pays diff --git a/docs/tutorial-manifests.md b/docs/tutorial-manifests.md index f8f4593e..81b9813b 100644 --- a/docs/tutorial-manifests.md +++ b/docs/tutorial-manifests.md @@ -8,7 +8,7 @@ Building and decoding a manifest **upload nothing and pay nothing**. Only the fi ## Prerequisites -- The antd release after 0.15.0, the first with manifests, on a local testnet with a wallet (`ant dev start` sets both up). The wallet is needed for the uploads only; the manifest calls need none +- antd 0.16.0 or later, the first release with manifests, on a local testnet with a wallet (`ant dev start` sets both up). The wallet is needed for the uploads only; the manifest calls need none - Python SDK installed (`pip install antd[rest]`), C# SDK built (`dotnet build`), Kotlin SDK built (`./gradlew build`), or Swift SDK built (`swift build`) - Three small files. Make them: diff --git a/docs/tutorial-pointers.md b/docs/tutorial-pointers.md index 7f6fd0c6..e726279d 100644 --- a/docs/tutorial-pointers.md +++ b/docs/tutorial-pointers.md @@ -6,7 +6,7 @@ This tutorial uploads a public file, points a pointer at it, uploads a second ve ## Prerequisites -- The first antd release with pointers (after 0.15.0), on a local testnet with a wallet (`ant dev start` sets both up) +- antd 0.16.0 or later (the first release with pointers), on a local testnet with a wallet (`ant dev start` sets both up) - An owner key loaded into antd (step 1) - Python SDK installed (`pip install antd[rest]`), C# SDK built (`dotnet build`), Kotlin SDK built (`./gradlew build`), or Swift SDK built (`swift build`) diff --git a/llms-full.txt b/llms-full.txt index 17bee7cf..fcd998f4 100644 --- a/llms-full.txt +++ b/llms-full.txt @@ -525,8 +525,8 @@ Pointer error codes: `CLOSE_GROUP_SHORTFALL` (503; reads are free to retry), ### Manifests (ADR-0006) -Stateless build and decode of `.ant` manifests and `ant://` links (needs the -antd release after 0.15.0). A manifest describes a set of files as one +Stateless build and decode of `.ant` manifests and `ant://` links (needs antd +0.16.0 or later). A manifest describes a set of files as one document: each entry has an optional `path` and `size` and either an embedded DataMap (a private file: the manifest is its key) or the address of a public file. The format, content addresses and portable path rules come from @@ -1088,7 +1088,7 @@ func (c *Client) PointerController(ctx context.Context, address string) (*Pointe func (c *Client) PointerPrepare(ctx context.Context, req PointerPrepareRequest) (*PointerPrepareResult, error) func (c *Client) PointerFinalize(ctx context.Context, uploadID string, txHashes map[string]string) (*PointerFinalizeResult, error) -// Manifests (ADR-0006, the antd release after 0.15.0; free; sizes are *uint64, unset is nil; bytes are []byte); same methods on GrpcClient +// Manifests (ADR-0006, antd 0.16.0 or later; free; sizes are *uint64, unset is nil; bytes are []byte); same methods on GrpcClient // BuildManifestOptions{Name, TorrentInfoHashes, KeepShrunkDataMaps}; ManifestEntryInput{Path, Size, DataMap, Address} func (c *Client) BuildManifest(ctx context.Context, entries []ManifestEntryInput, opts *BuildManifestOptions) (*BuiltManifest, error) func (c *Client) DecodeManifest(ctx context.Context, manifest []byte, resolve bool) (*DecodedManifest, error) diff --git a/llms.txt b/llms.txt index 123b2b07..b1ea7816 100644 --- a/llms.txt +++ b/llms.txt @@ -87,7 +87,7 @@ data = client.data_get_public(result.address) ## Pointers -A pointer is a small, owner-signed, mutable reference: its address is derived from the owner's key and never changes, and the owner can point it at new data (a chunk, such as a public file's address, or another pointer). Needs the first antd release with pointers (after 0.15.0). +A pointer is a small, owner-signed, mutable reference: its address is derived from the owner's key and never changes, and the owner can point it at new data (a chunk, such as a public file's address, or another pointer). Needs antd 0.16.0 or later (the first release with pointers). - antd holds the owner keys, loaded at startup from `--pointer-keys ` (env `ANTD_POINTER_KEYS_DIR`; key files from `ant pointer keygen --output `). Requests name a pointer by its address (`owner`), never by a key. - Every create, update and transfer pays (about one chunk's price), and every attempt pays again: never retry them automatically. Reads are free. @@ -117,7 +117,7 @@ A pointer is a small, owner-signed, mutable reference: its address is derived fr ## Manifests -A manifest describes a set of files as one `ant://manifest/` link, or a `.ant` file when the link would pass 1,500 bytes. Each entry has an optional `path` and `size` and either an embedded DataMap (a private file: the manifest is its key) or a public file's address. Needs the antd release after 0.15.0. +A manifest describes a set of files as one `ant://manifest/` link, or a `.ant` file when the link would pass 1,500 bytes. Each entry has an optional `path` and `size` and either an embedded DataMap (a private file: the manifest is its key) or a public file's address. Needs antd 0.16.0 or later. - **Nothing is uploaded or paid for.** Upload the files first (`POST /v1/data`, `POST /v1/data/public`, `POST /v1/files`, `POST /v1/files/public`), then build from the DataMaps and addresses they return. Build and decode read the network only to resolve DataMaps, so they can time out; retrying is safe. - `POST /v1/manifests/build`: `{"name", "embed_roots" (default true), "torrent_info_hashes", "entries": [{"path", "size", "data_map" | "address"}]}` returns `{"manifest": "", "link", "entries"}`. Exactly one of `data_map` or `address` per entry. `link` is omitted when it would pass 1,500 bytes. diff --git a/skill.md b/skill.md index a2240fb0..a5b4000f 100644 --- a/skill.md +++ b/skill.md @@ -134,7 +134,7 @@ print(f"Stored: {result.chunks_stored} chunks " ### Pattern 4: Pointers (Updatable Address) -A pointer's address is derived from its owner key and never changes; the owner moves it to new data. antd holds the owner keys, loaded at startup with `antd --pointer-keys ` (key files from `ant pointer keygen --output `), so calls name the pointer by its address (`owner`). Needs the first antd release with pointers (after 0.15.0). +A pointer's address is derived from its owner key and never changes; the owner moves it to new data. antd holds the owner keys, loaded at startup with `antd --pointer-keys ` (key files from `ant pointer keygen --output `), so calls name the pointer by its address (`owner`). Needs antd 0.16.0 or later (the first release with pointers). ```python owner = client.pointer_keys()[0] # a pointer this daemon can write @@ -163,7 +163,7 @@ Counters are decimal strings on the wire (a final pointer sits at 2^64−1); SDK ### Pattern 5: Manifests (One Link for Several Files) -A manifest describes a set of files as one `.ant` document, or as one `ant://manifest/` link when it is small enough. Each entry has an optional `path` (and `size`) and **exactly one** of an `address` (a public file) or a `data_map` (a private file, embedded: the manifest is then its key). Needs the antd release after 0.15.0. +A manifest describes a set of files as one `.ant` document, or as one `ant://manifest/` link when it is small enough. Each entry has an optional `path` (and `size`) and **exactly one** of an `address` (a public file) or a `data_map` (a private file, embedded: the manifest is then its key). Needs antd 0.16.0 or later. **Nothing is uploaded or paid for.** Build and decode are free and need no wallet, so no confirmation or cost estimate is needed. They read the network only to resolve DataMaps and can time out: retrying is safe. The files must already be uploaded, so get the addresses and DataMaps first: