@sorandomains/owner 0.8.0-migration.0 → 0.9.0

package/dist/funding-types.d.ts

@@ -0,0 +1,102 @@
+import { xdr } from "@stellar/stellar-sdk";
+import { type PaymentDestination } from "./payment.js";
+import { type ClaimIntent } from "./native-types.js";
+export declare class FundingError extends Error {
+    readonly kind: "invalid" | "unavailable" | "authorization" | "pending" | "failed";
+    readonly transactionHash: string | null;
+    constructor(message: string, kind?: "invalid" | "unavailable" | "authorization" | "pending" | "failed", transactionHash?: string | null);
+}
+export type SponsoredAction = "claim" | "reverse" | "primary";
+export type FundingConfiguration = {
+    registry: string;
+    nativeAsset: string;
+    lookup: string;
+    primary: string;
+    governance: string;
+    paused: boolean;
+    revision: bigint;
+};
+export type FundingPosition = {
+    namespace: string;
+    ownerEpoch: bigint;
+    controller: string;
+    balance: bigint;
+    spentTotal: bigint;
+    utcDay: bigint;
+    spentToday: bigint;
+    policyRevision: bigint;
+    status: "paused" | "active" | "closed";
+};
+export type SponsorPolicy = {
+    claimCap: bigint;
+    reverseCap: bigint;
+    primaryCap: bigint;
+    dailyCap: bigint;
+    totalCap: bigint;
+    claimsPerWallet: bigint;
+    identityPerDay: number;
+    relayer: string;
+    quoteLifetime: number;
+    validUntil: bigint;
+};
+export type SponsorQuote = {
+    network: string;
+    funding: string;
+    configRevision: bigint;
+    fundId: string;
+    policyRevision: bigint;
+    action: SponsoredAction;
+    actor: string;
+    nonce: bigint;
+    quoteId: string;
+    intentHash: string;
+    registrar: string;
+    resolver: string;
+    relayer: string;
+    charge: bigint;
+    issuedLedger: number;
+    expiresLedger: number;
+};
+export type SponsoredIdentityIntent = {
+    name: string;
+    actor: string;
+    routingId: bigint | null;
+    generation: bigint;
+    destination: PaymentDestination;
+    previous: string | null;
+};
+export type SponsorReceipt = {
+    quoteId: string;
+    intentHash: string;
+    actor: string;
+    nonce: bigint;
+    action: SponsoredAction;
+    charge: bigint;
+    relayer: string;
+    balance: bigint;
+    ledger: number;
+};
+export type SponsorActorState = {
+    nonce: bigint;
+    claims: bigint;
+    utcDay: bigint;
+    identityToday: number;
+    lastReceipt: SponsorReceipt | null;
+};
+export declare const fundingConfigurationFromNative: (v: unknown) => FundingConfiguration;
+export declare const fundingPositionFromNative: (v: unknown) => FundingPosition;
+export declare const sponsorPolicyFromNative: (v: unknown) => SponsorPolicy;
+export declare const sponsorQuoteFromNative: (v: unknown) => SponsorQuote;
+export declare const sponsoredIdentityFromNative: (v: unknown) => SponsoredIdentityIntent;
+export declare const sponsorReceiptFromNative: (v: unknown) => SponsorReceipt;
+export declare const sponsorActorFromNative: (v: unknown) => SponsorActorState;
+export declare const sponsoredActionToScVal: (v: SponsoredAction) => xdr.ScVal;
+export declare function sponsorPolicyToScVal(v: SponsorPolicy): xdr.ScVal;
+export declare function sponsorQuoteToScVal(v: SponsorQuote): xdr.ScVal;
+export declare const sponsoredIdentityToScVal: (v: SponsoredIdentityIntent) => xdr.ScVal;
+export declare function sponsorIntentHash(action: SponsoredAction, intent: ClaimIntent | SponsoredIdentityIntent): string;
+export declare function fundingPositionId(namespace: string, ownerEpoch: bigint): string;
+/** Canonical XDR is used for transport; JSON bigint coercion is never accepted. */
+export declare const encodeSponsorQuote: (v: SponsorQuote) => string;
+export declare function decodeSponsorQuote(encoded: string): SponsorQuote;
+export declare const FUNDING_ERRORS: Record<number, string>;

package/dist/funding-types.js

@@ -0,0 +1,249 @@
+import { hash, nativeToScVal, scValToNative, xdr } from "@stellar/stellar-sdk";
+import { address, amount, bool, bytes32, exactObject, hex, hex32, label, paymentDestinationToScVal, sc, struct, u32, u64, unhex, } from "./native-codec.js";
+import { destinationFromNative } from "./payment.js";
+import { claimIntentToScVal } from "./native-types.js";
+export class FundingError extends Error {
+    kind;
+    transactionHash;
+    constructor(message, kind = "invalid", transactionHash = null) {
+        super(message);
+        this.kind = kind;
+        this.transactionHash = transactionHash;
+        this.name = "FundingError";
+    }
+}
+const primitive = (validate, encode) => ({ encode: (v) => encode(validate(v)), decode: validate });
+const U64 = primitive((v) => u64(v, "funding u64"), sc.u64), U32 = primitive((v) => u32(v, "funding u32"), sc.u32);
+const MONEY = primitive((v) => amount(v, "funding amount"), sc.i128), BOOL = primitive((v) => bool(v, "funding boolean"), sc.bool);
+const G = primitive((v) => address(v, "account", "funding account"), sc.address), C = primitive((v) => address(v, "contract", "funding contract"), sc.address), ID = primitive((v) => address(v, "identity", "funding controller"), sc.address);
+const HEX = {
+    encode: (v) => sc.bytes(unhex(hex32(v, "funding hash"))),
+    decode: (v) => hex(bytes32(v, "funding hash")),
+};
+function fullName(v) {
+    if (typeof v !== "string")
+        throw new FundingError("name must be a string");
+    const parts = v.split(".");
+    if (parts.length !== 2)
+        throw new FundingError("name must include its namespace");
+    parts.forEach(label);
+    return v;
+}
+const NAME = primitive(fullName, (v) => nativeToScVal(v, { type: "string" }));
+const optional = (c) => ({
+    encode: (v) => (v === null ? xdr.ScVal.scvVoid() : c.encode(v)),
+    decode: (v) => (v === null || v === undefined ? null : c.decode(v)),
+});
+const enumeration = (tags) => ({
+    encode: (v) => {
+        if (typeof v !== "string" || !Object.hasOwn(tags, v))
+            throw new FundingError("unknown funding enum");
+        return xdr.ScVal.scvVec([sc.symbol(tags[v])]);
+    },
+    decode: (v) => {
+        if (!Array.isArray(v) || v.length !== 1)
+            throw new FundingError("malformed funding enum");
+        const pair = Object.entries(tags).find(([, tag]) => tag === v[0]);
+        if (!pair)
+            throw new FundingError("unknown funding enum");
+        return pair[0];
+    },
+});
+const ACTION = enumeration({
+    claim: "Claim",
+    reverse: "Reverse",
+    primary: "Primary",
+});
+const snake = (v) => v.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+function model(fields) {
+    return {
+        encode: (v) => {
+            const r = exactObject(v, Object.keys(fields), "funding input");
+            return struct(Object.fromEntries(Object.entries(fields).map(([k, c]) => [snake(k), c.encode(r[k])])));
+        },
+        decode: (v) => {
+            const r = exactObject(v, Object.keys(fields).map(snake), "funding result");
+            return Object.fromEntries(Object.entries(fields).map(([k, c]) => [k, c.decode(r[snake(k)])]));
+        },
+    };
+}
+const CONFIG = model({
+    registry: C,
+    nativeAsset: C,
+    lookup: C,
+    primary: C,
+    governance: ID,
+    paused: BOOL,
+    revision: U64,
+});
+const POSITION = model({
+    namespace: HEX,
+    ownerEpoch: U64,
+    controller: ID,
+    balance: MONEY,
+    spentTotal: MONEY,
+    utcDay: U64,
+    spentToday: MONEY,
+    policyRevision: U64,
+    status: enumeration({ paused: "Paused", active: "Active", closed: "Closed" }),
+});
+const POLICY = model({
+    claimCap: MONEY,
+    reverseCap: MONEY,
+    primaryCap: MONEY,
+    dailyCap: MONEY,
+    totalCap: MONEY,
+    claimsPerWallet: U64,
+    identityPerDay: U32,
+    relayer: G,
+    quoteLifetime: U32,
+    validUntil: U64,
+});
+const QUOTE = model({
+    network: HEX,
+    funding: C,
+    configRevision: U64,
+    fundId: HEX,
+    policyRevision: U64,
+    action: ACTION,
+    actor: ID,
+    nonce: U64,
+    quoteId: HEX,
+    intentHash: HEX,
+    registrar: C,
+    resolver: C,
+    relayer: G,
+    charge: MONEY,
+    issuedLedger: U32,
+    expiresLedger: U32,
+});
+const DEST = {
+    encode: (v) => paymentDestinationToScVal(v),
+    decode: destinationFromNative,
+};
+const IDENTITY = model({
+    name: NAME,
+    actor: ID,
+    routingId: optional(U64),
+    generation: U64,
+    destination: DEST,
+    previous: optional(NAME),
+});
+const RECEIPT = model({
+    quoteId: HEX,
+    intentHash: HEX,
+    actor: ID,
+    nonce: U64,
+    action: ACTION,
+    charge: MONEY,
+    relayer: G,
+    balance: MONEY,
+    ledger: U32,
+});
+const LAST_RECEIPT = {
+    encode: (v) => xdr.ScVal.scvVec(v === null
+        ? [sc.symbol("Empty")]
+        : [sc.symbol("Recorded"), RECEIPT.encode(v)]),
+    decode: (v) => {
+        if (Array.isArray(v) && v.length === 1 && v[0] === "Empty")
+            return null;
+        if (Array.isArray(v) && v.length === 2 && v[0] === "Recorded")
+            return RECEIPT.decode(v[1]);
+        throw new FundingError("malformed receipt state");
+    },
+};
+const ACTOR = model({
+    nonce: U64,
+    claims: U64,
+    utcDay: U64,
+    identityToday: U32,
+    lastReceipt: LAST_RECEIPT,
+});
+export const fundingConfigurationFromNative = (v) => CONFIG.decode(v);
+export const fundingPositionFromNative = (v) => POSITION.decode(v);
+export const sponsorPolicyFromNative = (v) => POLICY.decode(v);
+export const sponsorQuoteFromNative = (v) => QUOTE.decode(v);
+export const sponsoredIdentityFromNative = (v) => IDENTITY.decode(v);
+export const sponsorReceiptFromNative = (v) => RECEIPT.decode(v);
+export const sponsorActorFromNative = (v) => ACTOR.decode(v);
+export const sponsoredActionToScVal = (v) => ACTION.encode(v);
+export function sponsorPolicyToScVal(v) {
+    const value = POLICY.encode(v);
+    if (v.dailyCap === 0n ||
+        v.totalCap === 0n ||
+        v.dailyCap > v.totalCap ||
+        [v.claimCap, v.reverseCap, v.primaryCap].some((n) => n > v.dailyCap) ||
+        [v.claimCap, v.reverseCap, v.primaryCap].every((n) => n === 0n) ||
+        (v.claimCap > 0n && v.claimsPerWallet === 0n) ||
+        ((v.reverseCap > 0n || v.primaryCap > 0n) && v.identityPerDay === 0) ||
+        v.quoteLifetime < 1 ||
+        v.quoteLifetime > 120 ||
+        v.validUntil === 0n)
+        throw new FundingError("invalid coverage, spending limits or policy lifetime");
+    return value;
+}
+export function sponsorQuoteToScVal(v) {
+    const result = QUOTE.encode(v);
+    if (v.charge === 0n ||
+        v.actor === v.relayer ||
+        v.expiresLedger <= v.issuedLedger ||
+        v.expiresLedger - v.issuedLedger > 120)
+        throw new FundingError("invalid sponsor charge, actor or quote lifetime");
+    return result;
+}
+export const sponsoredIdentityToScVal = (v) => IDENTITY.encode(v);
+export function sponsorIntentHash(action, intent) {
+    const encoded = action === "claim"
+        ? claimIntentToScVal(intent)
+        : sponsoredIdentityToScVal(intent);
+    return hex(hash(xdr.ScVal.scvVec([sc.symbol("sponsor_" + action), encoded]).toXDR()));
+}
+export function fundingPositionId(namespace, ownerEpoch) {
+    return hex(hash(xdr.ScVal.scvVec([
+        sc.symbol("fund_v1"),
+        HEX.encode(namespace),
+        U64.encode(ownerEpoch),
+    ]).toXDR()));
+}
+/** Canonical XDR is used for transport; JSON bigint coercion is never accepted. */
+export const encodeSponsorQuote = (v) => sponsorQuoteToScVal(v).toXDR("base64");
+export function decodeSponsorQuote(encoded) {
+    if (typeof encoded !== "string" || encoded.length > 16_384)
+        throw new FundingError("invalid sponsor quote size");
+    const q = sponsorQuoteFromNative(scValToNative(xdr.ScVal.fromXDR(encoded, "base64")));
+    sponsorQuoteToScVal(q);
+    return q;
+}
+export const FUNDING_ERRORS = {
+    1: "Not initialized",
+    2: "Unsupported network",
+    3: "Invalid configuration",
+    4: "Funding position not found",
+    5: "Funding position already exists",
+    6: "Funding position closed",
+    7: "Namespace ownership changed",
+    8: "Contract state unavailable",
+    9: "Invalid amount",
+    10: "Insufficient sponsorship funds",
+    11: "Invalid spending policy",
+    12: "Spending policy not configured",
+    13: "Sponsorship paused",
+    14: "Quote is stale",
+    15: "Quote expired",
+    16: "Invalid quote",
+    17: "Spending limit reached",
+    18: "Wallet allowance reached",
+    19: "Request already used",
+    20: "Action is not sponsored",
+    21: "Namespace contract changed",
+    22: "Action differs from approval",
+    23: "Action already completed",
+    24: "Name operation failed",
+    25: "Sponsor payment failed",
+    26: "Amount or counter overflow",
+    27: "Re-entry refused",
+    28: "Invalid name",
+    29: "Name inactive",
+    30: "Name state changed",
+    31: "Upgrade does not match",
+};

package/dist/funding-user.d.ts

@@ -0,0 +1,38 @@
+import { Transaction, authorizeEntry, xdr } from "@stellar/stellar-sdk";
+import { FundingReader } from "./funding-reader.js";
+import { type SponsorQuote, type SponsoredIdentityIntent } from "./funding-types.js";
+import { type ClaimIntent } from "./native-types.js";
+import { type NativeInvocation } from "./native-auth.js";
+export type SponsorRequest = {
+    quote: SponsorQuote;
+    intent: ClaimIntent | SponsoredIdentityIntent;
+    proof?: readonly string[];
+};
+export type SponsorPlan = {
+    request: SponsorRequest;
+    method: string;
+    args: xdr.ScVal[];
+    actorInvocation: NativeInvocation;
+    relayerInvocation: NativeInvocation;
+    eligibility?: {
+        account: string;
+        invocation: NativeInvocation;
+        latestLedger: number;
+        maxExpirationLedger: number;
+    };
+    maxNetworkFee: bigint;
+};
+/** Build from the app's reviewed intent and pinned shared contracts, never a remote invocation tree. */
+export declare function sponsorPlan(request: SponsorRequest, lookup: string, primary: string, maxNetworkFee: bigint, eligibilityAccount?: string): SponsorPlan;
+export declare function validateSponsorTransaction(tx: Transaction, p: SponsorPlan, latestLedger: number, signed?: boolean): xdr.SorobanAuthorizationEntry;
+export declare function replaceSponsorAuth(tx: Transaction, auth: xdr.SorobanAuthorizationEntry[], passphrase: string): Transaction;
+export declare class SoranSponsorship extends FundingReader {
+    plan(request: SponsorRequest, maxNetworkFee: bigint): Promise<SponsorPlan>;
+    prepare(request: SponsorRequest, maxNetworkFee: bigint, inclusionFee?: bigint): Promise<{
+        transaction: Transaction;
+        plan: SponsorPlan;
+        ledger: number;
+    }>;
+    /** Sign only the caller's G authorization. Wallet adapters retain custody of keys. */
+    authorize(request: SponsorRequest, encoded: string, signer: Parameters<typeof authorizeEntry>[1], maxSponsorCharge: bigint, maxNetworkFee: bigint, eligibilityXdr?: string): Promise<string>;
+}

package/dist/funding-user.js

@@ -0,0 +1,250 @@
+import { Address, Contract, Operation, Transaction, TransactionBuilder, authorizeEntry, rpc, nativeToScVal, xdr, } from "@stellar/stellar-sdk";
+import { FundingReader } from "./funding-reader.js";
+import { FundingError, sponsorIntentHash, sponsorQuoteToScVal, sponsoredIdentityToScVal, } from "./funding-types.js";
+import { claimIntentToScVal, claimLabelToScVal, claimQuoteFromNative, } from "./native-types.js";
+import { address, paymentDestinationToScVal, sc, unhex, } from "./native-codec.js";
+import { authorizedInvocation, validateEligibilityAuthorization, } from "./native-auth.js";
+/** Build from the app's reviewed intent and pinned shared contracts, never a remote invocation tree. */
+export function sponsorPlan(request, lookup, primary, maxNetworkFee, eligibilityAccount) {
+    const { quote: q, intent } = request;
+    const method = "sponsor_" + q.action;
+    if (q.intentHash !== sponsorIntentHash(q.action, intent) ||
+        maxNetworkFee <= 0n)
+        throw new FundingError("Quote differs from the requested action", "authorization");
+    let args, target;
+    if (q.action === "claim") {
+        const i = intent, encoded = claimIntentToScVal(i), proof = request.proof ?? [];
+        if (i.claimant !== q.actor ||
+            i.resolver !== q.resolver ||
+            i.context.registrar !== q.registrar ||
+            i.context.network !== q.network ||
+            proof.length > 64)
+            throw new FundingError("Claim route or actor differs from quote", "authorization");
+        args = [
+            sponsorQuoteToScVal(q),
+            encoded,
+            xdr.ScVal.scvVec(proof.map((p) => sc.bytes(unhex(p)))),
+        ];
+        const children = [];
+        if (i.feeAmount > 0n)
+            children.push({
+                contract: i.feeToken,
+                method: "transfer",
+                args: [
+                    sc.address(i.claimant),
+                    sc.address(i.feeRecipient),
+                    sc.i128(i.feeAmount),
+                ],
+            });
+        children.push({
+            contract: i.resolver,
+            method: "initialize_destination",
+            args: [
+                claimLabelToScVal(i.label),
+                sc.address(i.claimant),
+                sc.u64(i.expectedGeneration === null ? 0n : i.expectedGeneration + 1n),
+                paymentDestinationToScVal(i.destination),
+            ],
+        });
+        target = {
+            contract: q.registrar,
+            method: "claim",
+            args: [encoded],
+            children,
+        };
+    }
+    else {
+        const i = intent;
+        if (i.actor !== q.actor || request.proof?.length)
+            throw new FundingError("Identity actor or proof differs from action");
+        args = [sponsorQuoteToScVal(q), sponsoredIdentityToScVal(i)];
+        const reverse = q.action === "reverse";
+        target =
+            i.routingId === null
+                ? {
+                    contract: reverse ? q.resolver : primary,
+                    method: reverse ? "set_reverse" : "set_primary",
+                    args: [
+                        sc.address(i.actor),
+                        nativeToScVal(i.name, { type: "string" }),
+                    ],
+                }
+                : {
+                    contract: lookup,
+                    method: reverse ? "set_reverse_muxed" : "set_primary_muxed",
+                    args: [
+                        sc.address(i.actor),
+                        sc.u64(i.routingId),
+                        nativeToScVal(i.name, { type: "string" }),
+                    ],
+                };
+    }
+    const plan = {
+        request,
+        method,
+        args,
+        actorInvocation: { contract: q.funding, method, args, children: [target] },
+        relayerInvocation: { contract: q.funding, method, args },
+        maxNetworkFee,
+    };
+    if (eligibilityAccount) {
+        if (q.action !== "claim" ||
+            eligibilityAccount === q.actor ||
+            eligibilityAccount === q.relayer)
+            throw new FundingError("Eligibility account must be separate from user and relayer");
+        plan.eligibility = {
+            account: address(eligibilityAccount, "account", "eligibility"),
+            invocation: {
+                contract: q.registrar,
+                method: "claim",
+                args: [claimIntentToScVal(intent)],
+            },
+            latestLedger: q.issuedLedger,
+            maxExpirationLedger: q.expiresLedger,
+        };
+    }
+    return plan;
+}
+function same(a, b) {
+    return a.toXDR("base64") === authorizedInvocation(b).toXDR("base64");
+}
+export function validateSponsorTransaction(tx, p, latestLedger, signed = false) {
+    const q = p.request.quote;
+    if (tx.source !== q.relayer ||
+        tx.operations.length !== 1 ||
+        tx.memo.type !== "none" ||
+        BigInt(tx.fee) > p.maxNetworkFee ||
+        tx.signatures.length ||
+        latestLedger < q.issuedLedger ||
+        latestLedger >= q.expiresLedger)
+        throw new FundingError("Unapproved source, operation, fee, signature or ledger", "authorization");
+    const op = tx.operations[0];
+    if (op.type !== "invokeHostFunction" ||
+        (op.source && op.source !== q.relayer) ||
+        op.func.type !== "hostFunctionTypeInvokeContract")
+        throw new FundingError("Unexpected sponsored operation");
+    const c = op.func.invokeContract;
+    if (Address.fromScAddress(c.contractAddress).toString() !== q.funding ||
+        c.functionName.toString() !== p.method ||
+        c.args.length !== p.args.length ||
+        c.args.some((v, n) => v.toXDR("base64") !== p.args[n].toXDR("base64")))
+        throw new FundingError("Transaction differs from approved request", "authorization");
+    const auth = op.auth ?? [];
+    if (auth.length !== (p.eligibility ? 3 : 2))
+        throw new FundingError("Unexpected sponsor authorization count", "authorization");
+    const sources = auth.filter((e) => e.credentials.type === "sorobanCredentialsSourceAccount");
+    if (sources.length !== 1 ||
+        !same(sources[0].rootInvocation, p.relayerInvocation))
+        throw new FundingError("Relayer authorization exceeds its approved role", "authorization");
+    const actors = auth.filter((e) => e.credentials.type === "sorobanCredentialsAddress" &&
+        Address.fromScAddress(e.credentials.address.address).toString() ===
+            q.actor);
+    if (actors.length !== 1 || !same(actors[0].rootInvocation, p.actorInvocation))
+        throw new FundingError("User authorization differs from approved action", "authorization");
+    const credential = actors[0].credentials;
+    if (credential.type !== "sorobanCredentialsAddress")
+        throw new FundingError("Missing actor credential");
+    if (signed) {
+        if (credential.address.signatureExpirationLedger <= latestLedger ||
+            credential.address.signatureExpirationLedger > q.expiresLedger ||
+            credential.address.signature.toXDR().length > 16384 ||
+            // G accounts use Stellar's native vector format. C accounts define their
+            // own ScVal signature; enforced simulation must run their __check_auth.
+            (q.actor.startsWith("G") &&
+                (credential.address.signature.type !== "scvVec" ||
+                    !credential.address.signature.vec?.length)))
+            throw new FundingError("User authorization missing or expired", "authorization");
+    }
+    else if (credential.address.signature.type !== "scvVoid" &&
+        !(credential.address.signature.type === "scvVec" &&
+            !credential.address.signature.vec?.length))
+        throw new FundingError("Refusing to re-sign an authorization");
+    if (p.eligibility) {
+        const entries = auth.filter((e) => e.credentials.type === "sorobanCredentialsAddress" &&
+            Address.fromScAddress(e.credentials.address.address).toString() ===
+                p.eligibility.account);
+        if (entries.length !== 1)
+            throw new FundingError("Missing eligibility authorization");
+        validateEligibilityAuthorization(entries[0], { ...p.eligibility, latestLedger }, signed);
+    }
+    return actors[0];
+}
+export function replaceSponsorAuth(tx, auth, passphrase) {
+    const op = tx.operations[0];
+    if (op.type !== "invokeHostFunction")
+        throw new FundingError("Unexpected operation");
+    return TransactionBuilder.cloneFrom(tx, { networkPassphrase: passphrase })
+        .clearOperations()
+        .addOperation(Operation.invokeHostFunction({ func: op.func, auth }))
+        .build();
+}
+export class SoranSponsorship extends FundingReader {
+    async plan(request, maxNetworkFee) {
+        await this.validateQuote(request.quote);
+        let eligibility;
+        if (request.quote.action === "claim") {
+            const i = request.intent;
+            if (i.context.registry !== this.registryId)
+                throw new FundingError("Claim Registry differs from deployment");
+            const r = await this.read(request.quote.registrar, "claim_quote", [claimLabelToScVal(i.label), sc.address(i.claimant)], request.quote.issuedLedger);
+            const admission = claimQuoteFromNative(r.value).config?.settings
+                .admission;
+            if (admission?.type === "approval")
+                eligibility = admission.account;
+        }
+        return sponsorPlan(request, this.lookupId, this.primaryId, maxNetworkFee, eligibility);
+    }
+    async prepare(request, maxNetworkFee, inclusionFee = 100n) {
+        if (inclusionFee < 100n || inclusionFee > maxNetworkFee || inclusionFee > 0xffffffffn)
+            throw new FundingError("Invalid network inclusion fee");
+        const plan = await this.plan(request, maxNetworkFee);
+        const raw = new TransactionBuilder(await this.server.getAccount(request.quote.relayer), { fee: inclusionFee.toString(), networkPassphrase: this.passphrase })
+            .addOperation(new Contract(this.fundingId).call(plan.method, ...plan.args))
+            .setTimeout(60)
+            .build();
+        const sim = await this.server.simulateTransaction(raw, undefined, undefined, false);
+        if (rpc.Api.isSimulationRestore(sim))
+            throw new FundingError("Separate storage restoration is required; sponsorship is unavailable", "unavailable");
+        if (!rpc.Api.isSimulationSuccess(sim) || !sim.result)
+            throw new FundingError("Sponsored simulation failed", "unavailable");
+        const transaction = rpc.assembleTransaction(raw, sim).build();
+        validateSponsorTransaction(transaction, plan, sim.latestLedger);
+        return { transaction, plan, ledger: sim.latestLedger };
+    }
+    /** Sign only the caller's G authorization. Wallet adapters retain custody of keys. */
+    async authorize(request, encoded, signer, maxSponsorCharge, maxNetworkFee, eligibilityXdr) {
+        if (request.quote.charge > maxSponsorCharge)
+            throw new FundingError("Sponsor charge exceeds the reviewed amount");
+        address(request.quote.actor, "account", "this adapter's signing wallet");
+        const plan = await this.plan(request, maxNetworkFee), parsed = TransactionBuilder.fromXDR(encoded, this.passphrase);
+        if (!(parsed instanceof Transaction))
+            throw new FundingError("Fee-bump envelopes are not supported by this transport");
+        const latest = await this.server.getLatestLedger();
+        const entry = validateSponsorTransaction(parsed, plan, latest.sequence);
+        const signed = await authorizeEntry(entry, signer, request.quote.expiresLedger, this.passphrase);
+        const op = parsed.operations[0];
+        if (op.type !== "invokeHostFunction")
+            throw new FundingError("Unexpected operation");
+        const auth = (op.auth ?? []).map((e) => e.credentials.type === "sorobanCredentialsAddress" &&
+            Address.fromScAddress(e.credentials.address.address).toString() ===
+                request.quote.actor
+            ? signed
+            : e);
+        if (plan.eligibility) {
+            if (!eligibilityXdr || eligibilityXdr.length > 32768)
+                throw new FundingError("This claim requires the app's eligibility authorization");
+            const approval = xdr.SorobanAuthorizationEntry.fromXDR(eligibilityXdr, "base64");
+            validateEligibilityAuthorization(approval, {
+                ...plan.eligibility,
+                latestLedger: latest.sequence,
+            });
+            const at = auth.findIndex((e) => e.credentials.type === "sorobanCredentialsAddress" &&
+                Address.fromScAddress(e.credentials.address.address).toString() ===
+                    plan.eligibility.account);
+            auth[at] = approval;
+        }
+        const tx = replaceSponsorAuth(parsed, auth, this.passphrase);
+        validateSponsorTransaction(tx, plan, latest.sequence, true);
+        return tx.toXDR();
+    }
+}

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export declare const DEPLOYMENTS: {
     readonly testnet: {
         readonly rpcUrl: "https://soroban-testnet.stellar.org";
         readonly passphrase: string;
-        readonly registryId: "CBSORANPM664QXYMYRZKLQDQE2TXFSK4GBMC6EIRSRTAUZRZCRZRFNMK";
+        readonly registryId: "CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4";
     };
 };
 /** Explicit historical deployment access. Names in different Registries are separate identities; never a fallback. */
@@ -281,3 +281,9 @@ export declare class SoranOwner {
      */
     private decodeFailure;
 }
+export * from "./funding-types.js";
+export { FundingReader, type FundingOptions } from "./funding-reader.js";
+export { SoranFunding } from "./funding-owner.js";
+export { SoranSponsorship, sponsorPlan, validateSponsorTransaction, type SponsorRequest, type SponsorPlan } from "./funding-user.js";
+export { FundingServiceClient } from "./funding-service.js";
+export { TestnetSponsorHistory, type SponsorHistory, type FundingReceipt } from "./funding-history.js";

package/dist/index.js

@@ -100,9 +100,9 @@ export const DEPLOYMENTS = {
     testnet: {
         rpcUrl: "https://soroban-testnet.stellar.org",
         passphrase: Networks.TESTNET,
-        // The immutable Registry. The Registrar for a namespace is discovered on
+        // The governed Registry. The Registrar for a namespace is discovered on
         // chain via `registrar_of(node)` — never configured by hand.
-        registryId: "CBSORANPM664QXYMYRZKLQDQE2TXFSK4GBMC6EIRSRTAUZRZCRZRFNMK",
+        registryId: "CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4",
     },
 };
 /** Explicit historical deployment access. Names in different Registries are separate identities; never a fallback. */
@@ -970,3 +970,9 @@ export class SoranOwner {
         return new OwnerError(`${fn} failed at inclusion (${resultCode})`, contractId, fn, null, null, hash);
     }
 }
+export * from "./funding-types.js";
+export { FundingReader } from "./funding-reader.js";
+export { SoranFunding } from "./funding-owner.js";
+export { SoranSponsorship, sponsorPlan, validateSponsorTransaction } from "./funding-user.js";
+export { FundingServiceClient } from "./funding-service.js";
+export { TestnetSponsorHistory } from "./funding-history.js";