@sorandomains/owner 0.8.0-migration.0 → 0.9.0

package/README.md

@@ -1,14 +1,14 @@
 # @sorandomains/owner
 
 
-> Native claim testnet deployment verified at ledger 4534629 on 6 September 2026 (12:12 UTC). See the
+> Governed testnet migration sealed at ledger 4604192 on 10 September 2026. See the
 > [release status](https://docs.soran.domains/reference/release-status) for package and service availability.
 
 
-Preview 0.8.0-migration.0 targets Stellar SDK17 (`>=17 <18`). ASCII names
+Version 0.8.0 targets Stellar SDK17 (`>=17 <18`). ASCII names
 and labels are validated before lowercase normalization; Unicode lookalikes are
 rejected. Writes continue to target the owning Registry/Registrar/Resolver. Universal
-Lookup is the read entry point in `@sorandomains/lookup` 0.8.0.
+Lookup is the read entry point in `@sorandomains/lookup` 0.10.0.
 
 Ownership, issuer, holder and treasury inputs remain G/C account or contract
 addresses. Muxed M addresses are payment destinations only: issue the name to its
@@ -91,11 +91,11 @@ Read the [native claim APIs, security boundaries and complete signup flow](https
 
 ## Verified testnet deployment
 
-Verified on 6 September 2026 at ledger **4534629** (12:12 UTC). Network passphrase: `Test SDF Network ; September 2015`.
+See the [deployment manifest](../../deployments/testnet.json) for confirmed code hashes, transaction receipts and verification scope. Network passphrase: `Test SDF Network ; September 2015`.
 
 | Contract | Address |
 |---|---|
-| Registry | `CBSORANPM664QXYMYRZKLQDQE2TXFSK4GBMC6EIRSRTAUZRZCRZRFNMK` |
+| Registry | `CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4` |
 
 Mainnet has no deployment preset. Custom networks must supply their own verified
 addresses. Universal Lookup upgrades remain immediately executable; an address
@@ -121,3 +121,22 @@ The older `maxNativeFeeStroops` option remains supported: when the new option is
 On a governed Registry, native verification reads the exact per-namespace Registrar code pin and its upgrade history. Approved upgrades do not have to match the current factory default. Missing or malformed provenance still prevents signing and receipt confirmation; RPC failure never downgrades verification to a legacy rule.
 
 Historical claim recovery is read-only and binds the original intent to the frozen source Registrar and sealed migration commitments. It never rewrites the intent to a successor Registry or treats an unavailable receipt as permission to submit again. Deployment migration and package publication are separate; check the release status for the active addresses.
+
+
+## Namespace sponsorship
+
+This package supports on-chain funding and sponsored actions on Stellar testnet.
+`SoranFunding` manages an owner's deposit, spending limits, pause controls and withdrawals.
+`SoranSponsorship` builds and checks an exact sponsored action, while `FundingServiceClient`
+requests quotes and recovers transaction outcomes from a compatible service.
+
+The Soran service uses fixed quotes based on live Stellar fee estimates. A successful action
+charges the agreed amount; Soran retains any difference from the actual network fee.
+There is no separate refund transaction or later debit. Failed actions do not debit the
+namespace's funding position. A separate username price remains payable by the claimant.
+
+User authorization remains required. A wallet must support Soroban authorization-entry
+signing; a transaction-only wallet cannot silently switch to a user-paid transaction.
+Always preserve the canonical quote before submission and recover its status after a timeout.
+Funding balances and permissions are verified on chain, and terminal outcomes are checked
+against trusted Stellar RPC/history providers.

package/dist/funding-history.d.ts

@@ -0,0 +1,25 @@
+import { rpc } from "@stellar/stellar-sdk";
+import { type SponsorQuote } from "./funding-types.js";
+/** Receipt evidence is retained for audit; its bytes alone are not a chain-inclusion proof. */
+export type FundingReceipt = {
+    transactionHash: string;
+    envelopeHash: string;
+    envelopeXdr: string;
+    resultXdr: string;
+    ledger: number;
+    observedLedger: number;
+    status: "success" | "failed";
+    provider: "stellar-rpc" | "sdf-testnet-horizon";
+};
+export interface SponsorHistory {
+    find(hash: string, quote: SponsorQuote, latestLedger: number, passphrase: string): Promise<FundingReceipt | null>;
+}
+/** Input must come from the caller's trusted chain provider, never a pasted/API receipt. */
+export declare function verifySponsorHistory(value: unknown, quote: SponsorQuote, expectedHash: string, latestLedger: number, passphrase: string, provider?: FundingReceipt["provider"]): FundingReceipt | null;
+export declare function sponsorRpcReceipt(result: rpc.Api.GetSuccessfulTransactionResponse | rpc.Api.GetFailedTransactionResponse, quote: SponsorQuote, hash: string, passphrase: string): FundingReceipt;
+/** The fixed provider is trusted for canonical inclusion, just as Stellar RPC is. */
+export declare class TestnetSponsorHistory implements SponsorHistory {
+    private request;
+    constructor(request?: typeof fetch);
+    find(hash: string, quote: SponsorQuote, latestLedger: number, passphrase: string): Promise<FundingReceipt | null>;
+}

package/dist/funding-history.js

@@ -0,0 +1,124 @@
+import { Address, FeeBumpTransaction, Networks, Transaction, TransactionBuilder, xdr, hash, } from "@stellar/stellar-sdk";
+import { hex } from "./native-codec.js";
+import { FundingError, sponsorQuoteToScVal, } from "./funding-types.js";
+/** Input must come from the caller's trusted chain provider, never a pasted/API receipt. */
+export function verifySponsorHistory(value, quote, expectedHash, latestLedger, passphrase, provider = "sdf-testnet-horizon") {
+    const r = value;
+    if (passphrase !== Networks.TESTNET ||
+        quote.network !== hex(hash(new TextEncoder().encode(passphrase))) ||
+        !/^[a-f0-9]{64}$/.test(expectedHash) ||
+        !Number.isInteger(latestLedger) ||
+        latestLedger < 1 ||
+        latestLedger > 0xffff_ffff ||
+        !r ||
+        typeof r !== "object" ||
+        typeof r.hash !== "string" ||
+        !Number.isInteger(r.ledger) ||
+        r.ledger < quote.issuedLedger ||
+        r.ledger > latestLedger ||
+        typeof r.successful !== "boolean" ||
+        typeof r.envelope_xdr !== "string" ||
+        r.envelope_xdr.length > 200000 ||
+        typeof r.result_xdr !== "string" ||
+        r.result_xdr.length > 200000)
+        return null;
+    try {
+        const envelope = TransactionBuilder.fromXDR(r.envelope_xdr, passphrase);
+        const tx = envelope instanceof FeeBumpTransaction
+            ? envelope.innerTransaction
+            : envelope;
+        if (!(tx instanceof Transaction) ||
+            hex(envelope.hash()) !== r.hash ||
+            hex(tx.hash()) !== expectedHash)
+            return null;
+        const op = tx.operations[0];
+        if (tx.source !== quote.relayer ||
+            tx.operations.length !== 1 ||
+            op.type !== "invokeHostFunction" ||
+            (op.source && op.source !== quote.relayer) ||
+            op.func.type !== "hostFunctionTypeInvokeContract" ||
+            Address.fromScAddress(op.func.invokeContract.contractAddress).toString() !== quote.funding ||
+            op.func.invokeContract.functionName.toString() !==
+                "sponsor_" + quote.action ||
+            op.func.invokeContract.args[0]?.toXDR("base64") !==
+                sponsorQuoteToScVal(quote).toXDR("base64"))
+            return null;
+        const result = xdr.TransactionResult.fromXDR(r.result_xdr, "base64").result;
+        let outcome;
+        if (envelope instanceof FeeBumpTransaction) {
+            if (result.type !== "txFeeBumpInnerSuccess" &&
+                result.type !== "txFeeBumpInnerFailed")
+                return null;
+            if (hex(result.innerResultPair.transactionHash.value) !== expectedHash)
+                return null;
+            outcome = result.innerResultPair.result.result.type;
+            if ((result.type === "txFeeBumpInnerSuccess") !==
+                (outcome === "txSuccess"))
+                return null;
+        }
+        else
+            outcome = result.type;
+        if (!["txSuccess", "txFailed"].includes(outcome) ||
+            r.successful !== (outcome === "txSuccess"))
+            return null;
+        return {
+            transactionHash: expectedHash,
+            envelopeHash: r.hash,
+            envelopeXdr: r.envelope_xdr,
+            resultXdr: r.result_xdr,
+            ledger: r.ledger,
+            observedLedger: latestLedger,
+            status: r.successful ? "success" : "failed",
+            provider,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function sponsorRpcReceipt(result, quote, hash, passphrase) {
+    try {
+        const envelope = TransactionBuilder.fromXDR(result.envelopeXdr, passphrase);
+        if (![hash, hex(envelope.hash())].includes(result.txHash))
+            throw Error();
+        const receipt = verifySponsorHistory({
+            hash: hex(envelope.hash()),
+            ledger: result.ledger,
+            successful: result.status === "SUCCESS",
+            envelope_xdr: envelope.toXDR(),
+            result_xdr: result.resultXdr.toXDR("base64"),
+        }, quote, hash, result.latestLedger, passphrase, "stellar-rpc");
+        if (receipt)
+            return receipt;
+    }
+    catch {
+        /* malformed or unrelated terminal data stays uncertain */
+    }
+    throw new FundingError("Receipt does not prove the reviewed sponsorship transaction", "pending", hash);
+}
+/** The fixed provider is trusted for canonical inclusion, just as Stellar RPC is. */
+export class TestnetSponsorHistory {
+    request;
+    constructor(request = (input, init) => globalThis.fetch(input, init)) {
+        this.request = request;
+    }
+    async find(hash, quote, latestLedger, passphrase) {
+        if (passphrase !== Networks.TESTNET || !/^[a-f0-9]{64}$/.test(hash))
+            throw new FundingError("Invalid sponsorship history request", "unavailable");
+        const options = {
+            credentials: "omit",
+            redirect: "error",
+            cache: "no-store",
+            signal: AbortSignal.timeout(10000),
+        };
+        const response = await this.request(`https://horizon-testnet.stellar.org/transactions/${hash}`, options);
+        if (response.status === 404)
+            return null;
+        if (!response.ok)
+            throw new FundingError("Sponsorship history unavailable; preserve the quote reference", "unavailable");
+        const body = await response.text();
+        if (body.length > 600000)
+            throw new FundingError("Sponsorship history response is too large", "unavailable");
+        return verifySponsorHistory(JSON.parse(body), quote, hash, latestLedger, passphrase);
+    }
+}

package/dist/funding-owner.d.ts

@@ -0,0 +1,45 @@
+import { FundingReader, type FundingOptions } from "./funding-reader.js";
+import { type SponsorPolicy } from "./funding-types.js";
+import { type NativeSigner, type NativeWriteOptions } from "./native-transport.js";
+/** Direct owner operations work even when the sponsorship service is offline. */
+export declare class SoranFunding extends FundingReader {
+    private context;
+    private tail;
+    constructor(options: FundingOptions & {
+        signer: NativeSigner;
+        maxNetworkFeeStroops: bigint;
+    });
+    private serialize;
+    private write;
+    open(namespace: string, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    private controller;
+    deposit(id: string, amount: bigint, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    setPolicy(id: string, policy: SponsorPolicy, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    setPaused(id: string, paused: boolean, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    withdraw(id: string, amount: bigint, recipient: string, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    close(id: string, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+}

package/dist/funding-owner.js

@@ -0,0 +1,97 @@
+import { Asset } from "@stellar/stellar-sdk";
+import { FundingReader } from "./funding-reader.js";
+import { FundingError, sponsorPolicyToScVal, } from "./funding-types.js";
+import { address, namespaceNode, sc, unhex } from "./native-codec.js";
+import { sendNative, } from "./native-transport.js";
+/** Direct owner operations work even when the sponsorship service is offline. */
+export class SoranFunding extends FundingReader {
+    context;
+    tail = Promise.resolve();
+    constructor(options) {
+        super(options);
+        if (options.maxNetworkFeeStroops <= 0n)
+            throw new FundingError("Choose a positive network fee limit");
+        const context = {
+            registryId: this.registryId,
+            passphrase: this.passphrase,
+            server: this.server,
+            signer: options.signer,
+            fee: "100",
+            timeoutSecs: 60,
+            maxFeeStroops: options.maxNetworkFeeStroops,
+            read: async (c, m, a) => (await this.read(c, m, a)).value,
+            readWithLedger: (c, m, a) => this.read(c, m, a),
+            serialize: (work) => this.serialize(work),
+        };
+        this.context = context;
+    }
+    serialize(work) {
+        const next = this.tail.then(work, work);
+        this.tail = next.catch(() => undefined);
+        return next;
+    }
+    async write(method, args, controller, options, children = []) {
+        const source = address(await this.context.signer.publicKey(), "account", "owner wallet");
+        if (source !== controller)
+            throw new FundingError("Connect the funding position's controller wallet", "authorization");
+        await this.configuration();
+        return this.serialize(() => sendNative(this.context, {
+            source,
+            contract: this.fundingId,
+            method,
+            args,
+            sourceInvocation: {
+                contract: this.fundingId,
+                method,
+                args,
+                children,
+            },
+            maxFeeStroops: this.context.maxFeeStroops,
+        }, options));
+    }
+    async open(namespace, options = {}) {
+        const node = sc.bytes(namespaceNode(namespace));
+        const owner = address((await this.read(this.registryId, "owner_of", [node])).value, "identity", "namespace owner");
+        return this.write("open_fund", [node], owner, options);
+    }
+    async controller(id) {
+        const f = await this.position(id);
+        if (!f)
+            throw new FundingError("Funding position does not exist");
+        return f.controller;
+    }
+    async deposit(id, amount, options = {}) {
+        if (amount <= 0n)
+            throw new FundingError("Deposit must be positive");
+        const controller = await this.controller(id);
+        return this.write("deposit", [sc.bytes(unhex(id)), sc.i128(amount)], controller, options, [
+            {
+                contract: Asset.native().contractId(this.passphrase),
+                method: "transfer",
+                args: [
+                    sc.address(controller),
+                    sc.address(this.fundingId),
+                    sc.i128(amount),
+                ],
+            },
+        ]);
+    }
+    async setPolicy(id, policy, options = {}) {
+        return this.write("set_policy", [sc.bytes(unhex(id)), sponsorPolicyToScVal(policy)], await this.controller(id), options);
+    }
+    async setPaused(id, paused, options = {}) {
+        return this.write("set_paused", [sc.bytes(unhex(id)), sc.bool(paused)], await this.controller(id), options);
+    }
+    async withdraw(id, amount, recipient, options = {}) {
+        if (amount <= 0n || recipient === this.fundingId)
+            throw new FundingError("Invalid withdrawal");
+        return this.write("withdraw", [
+            sc.bytes(unhex(id)),
+            sc.i128(amount),
+            sc.address(address(recipient, "identity", "withdrawal recipient")),
+        ], await this.controller(id), options);
+    }
+    async close(id, options = {}) {
+        return this.write("close_fund", [sc.bytes(unhex(id))], await this.controller(id), options);
+    }
+}

package/dist/funding-reader.d.ts

@@ -0,0 +1,43 @@
+import { rpc, xdr } from "@stellar/stellar-sdk";
+import { type SponsorQuote } from "./funding-types.js";
+export type FundingOptions = {
+    fundingId: string;
+    registryId: string;
+    lookupId: string;
+    primaryId: string;
+    rpcUrl?: string;
+    networkPassphrase?: string;
+    server?: rpc.Server;
+};
+export declare class FundingReader {
+    readonly fundingId: string;
+    readonly registryId: string;
+    readonly lookupId: string;
+    readonly primaryId: string;
+    readonly passphrase: string;
+    readonly server: rpc.Server;
+    readonly networkId: string;
+    constructor(options: FundingOptions);
+    read(contract: string, method: string, args: xdr.ScVal[], minimumLedger?: number): Promise<{
+        value: unknown;
+        ledger: number;
+    }>;
+    configuration(): Promise<{
+        ledger: number;
+        registry: string;
+        nativeAsset: string;
+        lookup: string;
+        primary: string;
+        governance: string;
+        paused: boolean;
+        revision: bigint;
+    }>;
+    currentPosition(namespace: string): Promise<{
+        id: string;
+        position: import("./funding-types.js").FundingPosition | null;
+    }>;
+    position(id: string): Promise<import("./funding-types.js").FundingPosition | null>;
+    policy(id: string): Promise<import("./funding-types.js").SponsorPolicy | null>;
+    actorState(id: string, actor: string): Promise<import("./funding-types.js").SponsorActorState>;
+    validateQuote(quote: SponsorQuote): Promise<void>;
+}

package/dist/funding-reader.js

@@ -0,0 +1,98 @@
+import { Account, Asset, Contract, Networks, StrKey, TransactionBuilder, hash, rpc, scValToNative, } from "@stellar/stellar-sdk";
+import { address, hex, namespaceNode, sc, unhex, utf8, } from "./native-codec.js";
+import { FundingError, fundingConfigurationFromNative, fundingPositionFromNative, fundingPositionId, sponsorActorFromNative, sponsorPolicyFromNative, sponsorQuoteToScVal, } from "./funding-types.js";
+export class FundingReader {
+    fundingId;
+    registryId;
+    lookupId;
+    primaryId;
+    passphrase;
+    server;
+    networkId;
+    constructor(options) {
+        this.fundingId = address(options.fundingId, "contract", "funding deployment");
+        this.registryId = address(options.registryId, "contract", "Registry");
+        this.lookupId = address(options.lookupId, "contract", "Lookup");
+        this.primaryId = address(options.primaryId, "contract", "Primary");
+        this.passphrase = options.networkPassphrase ?? Networks.TESTNET;
+        if (this.passphrase !== Networks.TESTNET)
+            throw new FundingError("Funding V1 is currently restricted to testnet");
+        this.networkId = hex(hash(utf8(this.passphrase)));
+        this.server =
+            options.server ??
+                new rpc.Server(options.rpcUrl ?? "https://soroban-testnet.stellar.org");
+    }
+    async read(contract, method, args, minimumLedger = 1) {
+        const source = new Account(StrKey.encodeEd25519PublicKey(new Uint8Array(32)), "0");
+        const tx = new TransactionBuilder(source, {
+            fee: "100",
+            networkPassphrase: this.passphrase,
+        })
+            .addOperation(new Contract(contract).call(method, ...args))
+            .setTimeout(30)
+            .build();
+        const result = await this.server.simulateTransaction(tx, undefined, undefined, false);
+        if (!rpc.Api.isSimulationSuccess(result) ||
+            !result.result ||
+            !Number.isSafeInteger(result.latestLedger) ||
+            result.latestLedger < minimumLedger)
+            throw new FundingError("Cannot verify funding contract state: " +
+                ("error" in result ? result.error : "missing or stale response"), "unavailable");
+        return {
+            value: scValToNative(result.result.retval),
+            ledger: result.latestLedger,
+        };
+    }
+    async configuration() {
+        const version = await this.read(this.fundingId, "version", []);
+        if (version.value !== 1)
+            throw new FundingError("Unsupported Funding contract version", "unavailable");
+        const r = await this.read(this.fundingId, "configuration", [], version.ledger);
+        const c = fundingConfigurationFromNative(r.value);
+        if (c.registry !== this.registryId ||
+            c.lookup !== this.lookupId ||
+            c.primary !== this.primaryId ||
+            c.nativeAsset !== Asset.native().contractId(this.passphrase))
+            throw new FundingError("Funding contract anchors differ from the configured deployment", "authorization");
+        return { ...c, ledger: r.ledger };
+    }
+    async currentPosition(namespace) {
+        await this.configuration();
+        const node = hex(namespaceNode(namespace));
+        const epoch = await this.read(this.registryId, "owner_epoch", [
+            sc.bytes(unhex(node)),
+        ]);
+        if (typeof epoch.value !== "bigint" || epoch.value < 1n)
+            throw new FundingError("Namespace ownership epoch unavailable", "unavailable");
+        const id = fundingPositionId(node, epoch.value);
+        return { id, position: await this.position(id) };
+    }
+    async position(id) {
+        const r = await this.read(this.fundingId, "fund", [sc.bytes(unhex(id))]);
+        if (r.value === null || r.value === undefined)
+            return null;
+        const position = fundingPositionFromNative(r.value);
+        if (fundingPositionId(position.namespace, position.ownerEpoch) !== id)
+            throw new FundingError("Returned funding position has a different namespace or ownership epoch", "unavailable");
+        return position;
+    }
+    async policy(id) {
+        const r = await this.read(this.fundingId, "policy", [sc.bytes(unhex(id))]);
+        return r.value === null || r.value === undefined
+            ? null
+            : sponsorPolicyFromNative(r.value);
+    }
+    async actorState(id, actor) {
+        const r = await this.read(this.fundingId, "actor_state", [
+            sc.bytes(unhex(id)),
+            sc.address(address(actor, "identity", "actor")),
+        ]);
+        return sponsorActorFromNative(r.value);
+    }
+    async validateQuote(quote) {
+        if (quote.funding !== this.fundingId || quote.network !== this.networkId)
+            throw new FundingError("Quote belongs to another deployment", "authorization");
+        await this.configuration();
+        await this.read(this.fundingId, "quote_status", [sponsorQuoteToScVal(quote)], quote.issuedLedger);
+    }
+}

package/dist/funding-service.d.ts

@@ -0,0 +1,33 @@
+import { type SponsorHistory } from "./funding-history.js";
+import { type ClaimIntent } from "./native-types.js";
+import { type SponsorQuote, type SponsoredAction, type SponsoredIdentityIntent } from "./funding-types.js";
+import { SoranSponsorship } from "./funding-user.js";
+/** HTTP transports offers and status. The contract/RPC checks still authorize spending. */
+export declare class FundingServiceClient {
+    private client;
+    private request;
+    private history;
+    private base;
+    constructor(baseUrl: string, client: SoranSponsorship, request?: typeof fetch, history?: SponsorHistory);
+    private call;
+    quote(action: SponsoredAction, intent: ClaimIntent | SponsoredIdentityIntent, maxSponsorCharge: bigint, proof?: readonly string[]): Promise<{
+        request: {
+            quote: SponsorQuote;
+            intent: ClaimIntent | SponsoredIdentityIntent;
+            proof: readonly string[];
+        };
+        transactionXdr: any;
+    }>;
+    submit(quote: SponsorQuote, authorizedTransactionXdr: string): Promise<{
+        id: string;
+        status: "quoted" | "dispatching" | "pending" | "unknown" | "success" | "failed" | "expired";
+        transactionHash: string | null;
+    }>;
+    status(quote: SponsorQuote): Promise<{
+        id: string;
+        status: "quoted" | "dispatching" | "pending" | "unknown" | "success" | "failed" | "expired";
+        transactionHash: string | null;
+    }>;
+    private id;
+    private result;
+}

package/dist/funding-service.js

@@ -0,0 +1,121 @@
+import { TestnetSponsorHistory, sponsorRpcReceipt, } from "./funding-history.js";
+import { claimIntentToScVal } from "./native-types.js";
+import { FundingError, decodeSponsorQuote, sponsoredIdentityToScVal, sponsorIntentHash, } from "./funding-types.js";
+/** HTTP transports offers and status. The contract/RPC checks still authorize spending. */
+export class FundingServiceClient {
+    client;
+    request;
+    history;
+    base;
+    constructor(baseUrl, client, request = (input, init) => globalThis.fetch(input, init), history = new TestnetSponsorHistory()) {
+        this.client = client;
+        this.request = request;
+        this.history = history;
+        const url = new URL(baseUrl);
+        if (url.username ||
+            url.password ||
+            url.hash ||
+            url.search ||
+            (url.protocol !== "https:" &&
+                !(url.protocol === "http:" &&
+                    ["localhost", "127.0.0.1"].includes(url.hostname))))
+            throw new FundingError("Sponsorship API must use HTTPS or a local development endpoint");
+        this.base = url.toString().replace(/\/$/, "");
+    }
+    async call(path, body) {
+        let r;
+        try {
+            r = await this.request(this.base + path, {
+                method: body === undefined ? "GET" : "POST",
+                headers: body === undefined
+                    ? undefined
+                    : { "content-type": "application/json" },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: AbortSignal.timeout(30000),
+                redirect: "error",
+            });
+        }
+        catch {
+            throw new FundingError("Service response unavailable. Keep your quote reference and recover its status before submitting again.", "unavailable");
+        }
+        const value = (await r.json());
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new FundingError("Invalid service response", "unavailable");
+        if (!r.ok || value.error)
+            throw new FundingError(typeof value.detail === "string"
+                ? value.detail
+                : "Sponsorship request stopped", value.error === "pending" ? "pending" : "unavailable", typeof value.transactionHash === "string"
+                ? value.transactionHash
+                : null);
+        return value;
+    }
+    async quote(action, intent, maxSponsorCharge, proof = []) {
+        const encoded = action === "claim"
+            ? claimIntentToScVal(intent)
+            : sponsoredIdentityToScVal(intent);
+        const offer = await this.call("/v1/sponsorship/quote", {
+            action,
+            intentXdr: encoded.toXDR("base64"),
+            proof,
+        });
+        const quote = decodeSponsorQuote(offer.quoteXdr);
+        if (offer.id !== quote.quoteId ||
+            quote.action !== action ||
+            quote.intentHash !== sponsorIntentHash(action, intent) ||
+            quote.charge > maxSponsorCharge ||
+            typeof offer.transactionXdr !== "string" ||
+            offer.transactionXdr.length > 100000)
+            throw new FundingError("Sponsorship offer differs from the action or charge you reviewed", "authorization");
+        await this.client.validateQuote(quote);
+        return {
+            request: { quote, intent, proof },
+            transactionXdr: offer.transactionXdr,
+        };
+    }
+    async submit(quote, authorizedTransactionXdr) {
+        this.id(quote.quoteId);
+        const result = await this.call("/v1/sponsorship/submit", {
+            quoteId: quote.quoteId,
+            transactionXdr: authorizedTransactionXdr,
+        });
+        return this.result(quote, result);
+    }
+    async status(quote) {
+        this.id(quote.quoteId);
+        return this.result(quote, await this.call(`/v1/sponsorship/status/${quote.quoteId}`));
+    }
+    id(id) {
+        if (!/^[a-f0-9]{64}$/.test(id))
+            throw new FundingError("Invalid quote ID");
+    }
+    async result(quote, value) {
+        if (value.id !== quote.quoteId ||
+            quote.funding !== this.client.fundingId ||
+            quote.network !== this.client.networkId ||
+            ![
+                "quoted",
+                "dispatching",
+                "pending",
+                "unknown",
+                "success",
+                "failed",
+                "expired",
+            ].includes(value.status) ||
+            (value.transactionHash !== null &&
+                !/^[a-f0-9]{64}$/.test(value.transactionHash)))
+            throw new FundingError("Unverifiable sponsorship status; preserve the original quote reference", "unavailable");
+        if (value.status === "success" || value.status === "failed") {
+            if (!value.transactionHash)
+                throw new FundingError("Missing confirmed transaction hash", "unavailable");
+            const result = await this.client.server.getTransaction(value.transactionHash);
+            const receipt = result.status === "SUCCESS" || result.status === "FAILED"
+                ? sponsorRpcReceipt(result, quote, value.transactionHash, this.client.passphrase)
+                : await this.history.find(value.transactionHash, quote, (await this.client.server.getLatestLedger()).sequence, this.client.passphrase);
+            // Fetch independently from a trusted chain provider. API receipt bytes or
+            // a persisted status alone cannot establish canonical inclusion.
+            if (!receipt || receipt.status !== value.status)
+                throw new FundingError("Service outcome is not confirmed by chain history", "pending", value.transactionHash);
+        }
+        return value;
+    }
+}