@sorandomains/owner 0.8.0 → 0.10.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.
 
 
 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](../../deploy/testnet/deployment.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

package/dist/contract-wallet.d.ts

@@ -0,0 +1,22 @@
+import { xdr } from "@stellar/stellar-sdk";
+/** The wallet defines its signature format and retains custody of its keys.
+ * Soran supplies the exact reviewed invocation, network, nonce and expiry.
+ * A separate G-account TxSigner submits the resulting transaction.
+ */
+export type ContractWallet = {
+    address: string;
+    signAuthorization(request: {
+        address: string;
+        networkPassphrase: string;
+        authorizationEntryXdr: string;
+        signaturePayload: Uint8Array;
+    }): Promise<xdr.ScVal>;
+};
+export type ContractAuthorization = {
+    account: string;
+    latestLedger: number;
+    maxExpirationLedger: number;
+};
+export declare function validateContractAuthorization(entry: xdr.SorobanAuthorizationEntry, expected: ContractAuthorization, signed: boolean): void;
+/** Invocation scope must be validated by the caller before calling this helper. */
+export declare function signContractAuthorization(unsigned: xdr.SorobanAuthorizationEntry, expected: ContractAuthorization, wallet: ContractWallet, networkPassphrase: string): Promise<xdr.SorobanAuthorizationEntry>;

package/dist/contract-wallet.js

@@ -0,0 +1,55 @@
+import { Address, buildAuthorizationEntryPreimage, hash, xdr } from "@stellar/stellar-sdk";
+import { NativeClaimError, address, u32 } from "./native-codec.js";
+export function validateContractAuthorization(entry, expected, signed) {
+    address(expected.account, "contract", "contract wallet");
+    u32(expected.latestLedger, "latest ledger");
+    u32(expected.maxExpirationLedger, "maximum authorization ledger");
+    if (expected.latestLedger < 1 || expected.maxExpirationLedger <= expected.latestLedger)
+        throw new NativeClaimError("contract authorization ledger window is invalid", "authorization");
+    if (entry.credentials.type !== "sorobanCredentialsAddress" ||
+        Address.fromScAddress(entry.credentials.address.address).toString() !== expected.account)
+        throw new NativeClaimError("authorization does not belong to the selected contract wallet", "authorization");
+    const c = entry.credentials.address;
+    if (signed) {
+        if (c.signatureExpirationLedger <= expected.latestLedger || c.signatureExpirationLedger > expected.maxExpirationLedger ||
+            c.signature.toXDR().length > 16384)
+            throw new NativeClaimError("contract authorization is expired or outside the reviewed limits", "authorization");
+        // A contract can legitimately accept any ScVal, including Void. Only an
+        // enforcing simulation and the host's __check_auth establish validity.
+    }
+    else if (c.signature.type !== "scvVoid" && !(c.signature.type === "scvVec" && !c.signature.vec?.length)) {
+        throw new NativeClaimError("refusing to sign an already signed contract authorization", "authorization");
+    }
+}
+/** Invocation scope must be validated by the caller before calling this helper. */
+export async function signContractAuthorization(unsigned, expected, wallet, networkPassphrase) {
+    validateContractAuthorization(unsigned, expected, false);
+    if (wallet.address !== expected.account || !networkPassphrase)
+        throw new NativeClaimError("contract wallet or network differs from the reviewed authorization", "authorization");
+    // Round-trip before yielding to a wallet. Its callback receives no mutable
+    // invocation objects and can supply only the contract-defined signature.
+    const entry = xdr.SorobanAuthorizationEntry.fromXDR(unsigned.toXDR());
+    const c = entry.credentials;
+    if (c.type !== "sorobanCredentialsAddress")
+        throw new NativeClaimError("missing contract credential");
+    const preimage = buildAuthorizationEntryPreimage(entry, expected.maxExpirationLedger, networkPassphrase);
+    const credentials = new xdr.SorobanAddressCredentials({
+        ...c.address, signatureExpirationLedger: expected.maxExpirationLedger, signature: xdr.ScVal.scvVoid(),
+    });
+    const signingEntry = new xdr.SorobanAuthorizationEntry({
+        credentials: xdr.SorobanCredentials.sorobanCredentialsAddress(credentials), rootInvocation: entry.rootInvocation,
+    });
+    const signature = await wallet.signAuthorization({
+        address: expected.account, networkPassphrase, authorizationEntryXdr: signingEntry.toXDR("base64"),
+        signaturePayload: Uint8Array.from(hash(preimage.toXDR())),
+    });
+    if (wallet.address !== expected.account)
+        throw new NativeClaimError("contract wallet changed while authorizing", "authorization");
+    const signed = new xdr.SorobanAuthorizationEntry({
+        credentials: xdr.SorobanCredentials.sorobanCredentialsAddress(new xdr.SorobanAddressCredentials({
+            ...credentials, signature: xdr.ScVal.fromXDR(signature.toXDR()),
+        })), rootInvocation: entry.rootInvocation,
+    });
+    validateContractAuthorization(signed, expected, true);
+    return signed;
+}

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,44 @@
+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, type SponsorRequest } 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;
+    }>;
+    /** Re-estimate with the previous, valid wallet authorization. This never
+     * submits; review the new charge and call authorize again before submit. */
+    refreshQuote(request: SponsorRequest, authorizedTransactionXdr: string, maxSponsorCharge: bigint): Promise<{
+        request: {
+            quote: SponsorQuote;
+            intent: ClaimIntent | SponsoredIdentityIntent;
+            proof: readonly string[];
+        };
+        transactionXdr: any;
+    }>;
+    private reviewOffer;
+    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;
+}