@sorandomains/owner 0.8.0 → 0.10.0

package/dist/funding-user.js

@@ -0,0 +1,262 @@
+import { Address, Contract, Operation, Transaction, TransactionBuilder, authorizeEntry, rpc, nativeToScVal, xdr, } from "@stellar/stellar-sdk";
+import { FundingReader } from "./funding-reader.js";
+import { signContractAuthorization } from "./contract-wallet.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");
+            if (i.claimant.startsWith("C")) {
+                const capability = await this.read(request.quote.registrar, "contract_claim_version", [], request.quote.issuedLedger);
+                if (capability.value !== 1)
+                    throw new FundingError("This namespace needs a Registrar upgrade before contract wallets can claim", "unavailable");
+            }
+            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 authorization. C wallets supply their own signature
+     * format; the service enforces __check_auth before the relayer signs. */
+    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, "identity", "signing wallet");
+        const contractWallet = typeof signer === "object" && "signAuthorization" in signer ? signer : undefined;
+        if (request.quote.actor.startsWith("C") !== !!contractWallet)
+            throw new FundingError("Use the selected wallet's G signer or C authorization adapter", "authorization");
+        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 = contractWallet ? await signContractAuthorization(entry, {
+            account: request.quote.actor, latestLedger: latest.sequence, maxExpirationLedger: request.quote.expiresLedger,
+        }, contractWallet, this.passphrase) : 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

@@ -158,6 +158,10 @@ export declare class SoranOwner {
     claimPolicy(namespace: string): Promise<ClaimConfig | null>;
     nativeClaimFeeToken(namespace: string): Promise<string>;
     private nativeOwnerWrite;
+    /** Current implementation after validating the Registry's native binding. */
+    registrarCodeHash(namespace: string): Promise<string>;
+    /** Owner-authorized, Registry-approved update; never uses the legacy tainting path. */
+    upgradeRegistrar(namespace: string, wasmHash: string, options?: NativeWriteOptions): Promise<Submitted>;
     configureClaims(namespace: string, settings: ClaimSettings, options?: NativeWriteOptions): Promise<Submitted & {
         config: ClaimConfig;
     }>;
@@ -281,3 +285,10 @@ 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";
+export type { ContractWallet } from "./contract-wallet.js";

package/dist/index.js

@@ -401,6 +401,32 @@ export class SoranOwner {
             return sendNative(context, { source, contract: cap.registrar, method, args, sourceInvocation: { contract: cap.registrar, method, args }, maxFeeStroops: context.maxFeeStroops }, options);
         });
     }
+    /** Current implementation after validating the Registry's native binding. */
+    async registrarCodeHash(namespace) {
+        const cap = await requireNative(this.nativeContext(), normalizeLabel(namespace));
+        const instance = await this.server.getContractInstance(cap.registrar);
+        if (instance.executable.type !== "contractExecutableWasm")
+            throw new NativeClaimError("Registrar is not a Wasm contract", "unavailable");
+        return nativeHex(instance.executable.wasmHash.value);
+    }
+    /** Owner-authorized, Registry-approved update; never uses the legacy tainting path. */
+    async upgradeRegistrar(namespace, wasmHash, options = {}) {
+        if (!/^[a-f0-9]{64}$/.test(wasmHash))
+            throw new NativeClaimError("Registrar implementation hash must be lowercase hex32");
+        const bytes = Uint8Array.from(wasmHash.match(/../g), value => parseInt(value, 16));
+        const cap = await requireNative(this.nativeContext(), normalizeLabel(namespace));
+        const [governed, approved, current] = await Promise.all([
+            this.read(cap.registrar, "upgrade_policy_version", []),
+            this.read(this.registryId, "implementation_approved", [nativeSc.u32(0), nativeSc.bytes(bytes)]),
+            this.registrarCodeHash(namespace),
+        ]);
+        if (governed !== 1 || approved !== true)
+            throw new NativeClaimError("This Registrar upgrade is not approved by the Registry", "authorization");
+        if (current === wasmHash)
+            throw new NativeClaimError("This Registrar implementation is already installed");
+        const result = await this.nativeOwnerWrite(namespace, "upgrade", [nativeSc.bytes(bytes)], options);
+        return { hash: result.hash, ledger: result.ledger };
+    }
     async configureClaims(namespace, settings, options = {}) {
         const encoded = claimSettingsToScVal(settings);
         const cap = await requireNative(this.nativeContext(), normalizeLabel(namespace));
@@ -970,3 +996,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";

package/dist/native-allowlist.js

@@ -1,15 +1,15 @@
 import { hash, xdr } from "@stellar/stellar-sdk";
 import { NativeClaimError, address, hex, hex32, sc, unhex } from "./native-codec.js";
 export function claimAllowlistLeaf(context, account) {
-    return hex(hash(xdr.ScVal.scvVec([sc.symbol("allow_v1"), sc.bytes(unhex(context.network)), sc.address(address(context.registry, "contract", "Registry")), sc.bytes(unhex(context.namespace)), sc.address(address(context.registrar, "contract", "Registrar")), sc.address(address(account, "account", "allowlisted claimant"))]).toXDR()));
+    return hex(hash(xdr.ScVal.scvVec([sc.symbol("allow_v1"), sc.bytes(unhex(context.network)), sc.address(address(context.registry, "contract", "Registry")), sc.bytes(unhex(context.namespace)), sc.address(address(context.registrar, "contract", "Registrar")), sc.address(address(account, "identity", "allowlisted claimant"))]).toXDR()));
 }
 export function claimAllowlistParent(left, right) { hex32(left, "left leaf"); hex32(right, "right leaf"); const [first, second] = left < right ? [left, right] : [right, left]; const bytes = new Uint8Array(65); bytes[0] = 1; bytes.set(unhex(first), 1); bytes.set(unhex(second), 33); return hex(hash(bytes)); }
 /** A complete list is required to generate a replacement root. Keep/distribute the returned proof bundle. */
 export function buildClaimAllowlist(context, accounts) {
     if (!Array.isArray(accounts) || accounts.length === 0 || accounts.length > 65536)
-        throw new NativeClaimError("allowlist requires 1–65536 distinct G accounts");
+        throw new NativeClaimError("allowlist requires 1–65536 distinct G or C accounts");
     const unique = new Set();
-    const entries = accounts.map(account => { address(account, "account", "allowlisted claimant"); if (unique.has(account))
+    const entries = accounts.map(account => { address(account, "identity", "allowlisted claimant"); if (unique.has(account))
         throw new NativeClaimError("duplicate allowlist account"); unique.add(account); return { account, leaf: claimAllowlistLeaf(context, account), proof: [] }; }).sort((a, b) => a.leaf.localeCompare(b.leaf));
     let layer = entries.map((entry, index) => ({ hash: entry.leaf, indices: [index] }));
     while (layer.length > 1) {

package/dist/native-auth.d.ts

@@ -1,4 +1,5 @@
 import { Transaction, authorizeEntry, xdr } from "@stellar/stellar-sdk";
+import { type ContractAuthorization } from "./contract-wallet.js";
 export type NativeInvocation = {
     contract: string;
     method: string;
@@ -8,6 +9,8 @@ export type NativeInvocation = {
 /** Derive this plan locally from a validated intent, never from a remote envelope. */
 export type NativeAuthorizationPlan = {
     source: string;
+    /** When present, this contract wallet authorizes the holder invocation. */
+    actor?: ContractAuthorization;
     contract: string;
     method: string;
     args: xdr.ScVal[];
@@ -27,5 +30,5 @@ export type EligibilitySigner = Parameters<typeof authorizeEntry>[1];
 /** Signs only the expected admission entry. This helper never signs a transaction. */
 export declare function signEligibilityAuthorization(unsignedEntry: xdr.SorobanAuthorizationEntry, expected: NonNullable<NativeAuthorizationPlan["eligibility"]>, signer: EligibilitySigner, expirationLedger: number, networkPassphrase: string): Promise<xdr.SorobanAuthorizationEntry>;
 /** Exact local intent and native role scope; does not relax ordinary SDK authorization. */
-export declare function validateNativeTransaction(tx: Transaction, plan: NativeAuthorizationPlan, requireEligibilitySigned?: boolean): void;
+export declare function validateNativeTransaction(tx: Transaction, plan: NativeAuthorizationPlan, requireEligibilitySigned?: boolean, requireActorSigned?: boolean): void;
 export declare function assertSignedBodyUnchanged(prepared: Transaction, signedXdr: string, passphrase: string): Transaction;

package/dist/native-auth.js

@@ -1,5 +1,6 @@
 import { Address, Transaction, TransactionBuilder, authorizeEntry, xdr } from "@stellar/stellar-sdk";
 import { NativeClaimError, address, hex, u32 } from "./native-codec.js";
+import { validateContractAuthorization } from "./contract-wallet.js";
 export function authorizedInvocation(value) {
     return new xdr.SorobanAuthorizedInvocation({
         function: xdr.SorobanAuthorizedFunction.sorobanAuthorizedFunctionTypeContractFn(new xdr.InvokeContractArgs({
@@ -44,7 +45,7 @@ export async function signEligibilityAuthorization(unsignedEntry, expected, sign
     return signed;
 }
 /** Exact local intent and native role scope; does not relax ordinary SDK authorization. */
-export function validateNativeTransaction(tx, plan, requireEligibilitySigned = true) {
+export function validateNativeTransaction(tx, plan, requireEligibilitySigned = true, requireActorSigned = true) {
     address(plan.source, "account", "claim transaction source");
     if (tx.source !== plan.source)
         throw new NativeClaimError(`native transaction source ${tx.source} differs from reviewed source ${plan.source}`, "authorization");
@@ -64,12 +65,21 @@ export function validateNativeTransaction(tx, plan, requireEligibilitySigned = t
     if (entries.length !== (plan.eligibility ? 2 : 1))
         throw new NativeClaimError("unexpected native authorization count", "authorization");
     const sources = entries.filter(entry => entry.credentials.type === "sorobanCredentialsSourceAccount");
-    if (sources.length !== 1 || !sameInvocation(sources[0].rootInvocation, plan.sourceInvocation))
+    if (plan.actor) {
+        const actors = entries.filter(entry => entry.credentials.type === "sorobanCredentialsAddress" &&
+            Address.fromScAddress(entry.credentials.address.address).toString() === plan.actor.account);
+        if (sources.length || actors.length !== 1 || !sameInvocation(actors[0].rootInvocation, plan.sourceInvocation))
+            throw new NativeClaimError("contract wallet authorization differs from exact reviewed intent", "authorization");
+        validateContractAuthorization(actors[0], plan.actor, requireActorSigned);
+    }
+    else if (sources.length !== 1 || !sameInvocation(sources[0].rootInvocation, plan.sourceInvocation)) {
         throw new NativeClaimError("holder or owner authorization differs from exact reviewed intent", "authorization");
+    }
     if (plan.eligibility) {
-        if (plan.eligibility.account === plan.source)
-            throw new NativeClaimError("eligibility account must be separate from claimant", "authorization");
-        const separate = entries.filter(entry => entry.credentials.type !== "sorobanCredentialsSourceAccount");
+        if (plan.eligibility.account === plan.source || plan.eligibility.account === plan.actor?.account)
+            throw new NativeClaimError("eligibility account must be separate from claimant and transaction source", "authorization");
+        const separate = entries.filter(entry => entry.credentials.type === "sorobanCredentialsAddress" &&
+            Address.fromScAddress(entry.credentials.address.address).toString() === plan.eligibility.account);
         if (separate.length !== 1)
             throw new NativeClaimError("unexpected second authorizer", "authorization");
         validateEligibilityAuthorization(separate[0], plan.eligibility, requireEligibilitySigned);

package/dist/native-types.js

@@ -33,16 +33,16 @@ function model(fields) { return { encode: v => { const value = exactObject(v, Ob
 const SETTINGS = model({ mode: enumeration({ manual: "Manual", public: "Public" }), enabled: BOOL, admission: ADMISSION, feeToken: CONTRACT, feeAmount: AMOUNT, feeRecipient: ACCOUNT, walletLimit: U64, approvalAllowance: U64, approvalRateLimit: U64, approvalWindowSecs: U64, approvalTtlSecs: U64 });
 const CONFIG = model({ settings: SETTINGS, ownerEpoch: U64, policyVersion: U64, grantEpoch: U64 });
 const CONTEXT = model({ network: HEX, registry: CONTRACT, registrar: CONTRACT, namespace: HEX, requestId: HEX, validAfter: U64, deadline: U64 });
-const CLAIM = model({ context: CONTEXT, label: LABEL, claimant: ACCOUNT, destination: DESTINATION, resolver: CONTRACT, expectedGeneration: optional(U64), expectedExpiry: optional(U64), termSecs: U64, ownerEpoch: U64, policyVersion: U64, grantEpoch: U64, feeToken: CONTRACT, feeAmount: AMOUNT, feeRecipient: ACCOUNT });
-const RESERVED = model({ context: CONTEXT, label: LABEL, holder: ACCOUNT, destination: DESTINATION, resolver: CONTRACT, expectedGeneration: optional(U64), expectedExpiry: optional(U64), termSecs: U64, ownerEpoch: U64, policyVersion: U64 });
-const TRANSFER = model({ context: CONTEXT, label: LABEL, from: IDENTITY, to: ACCOUNT, expectedGeneration: U64, expectedExpiry: U64, proposalExpires: U64, destination: DESTINATION, resolver: CONTRACT });
-const RENEW = model({ context: CONTEXT, label: LABEL, holder: ACCOUNT, expectedGeneration: U64, expectedExpiry: U64, termSecs: U64, minNewExpiry: U64, maxNewExpiry: U64 });
+const CLAIM = model({ context: CONTEXT, label: LABEL, claimant: IDENTITY, destination: DESTINATION, resolver: CONTRACT, expectedGeneration: optional(U64), expectedExpiry: optional(U64), termSecs: U64, ownerEpoch: U64, policyVersion: U64, grantEpoch: U64, feeToken: CONTRACT, feeAmount: AMOUNT, feeRecipient: ACCOUNT });
+const RESERVED = model({ context: CONTEXT, label: LABEL, holder: IDENTITY, destination: DESTINATION, resolver: CONTRACT, expectedGeneration: optional(U64), expectedExpiry: optional(U64), termSecs: U64, ownerEpoch: U64, policyVersion: U64 });
+const TRANSFER = model({ context: CONTEXT, label: LABEL, from: IDENTITY, to: IDENTITY, expectedGeneration: U64, expectedExpiry: U64, proposalExpires: U64, destination: DESTINATION, resolver: CONTRACT });
+const RENEW = model({ context: CONTEXT, label: LABEL, holder: IDENTITY, expectedGeneration: U64, expectedExpiry: U64, termSecs: U64, minNewExpiry: U64, maxNewExpiry: U64 });
 const USAGE = model({ publicClaims: U64, reservedIssues: U64 }), APPROVAL_USAGE = model({ total: U64, windowUsed: U64, windowEnds: U64 });
 const CONFIG_STATE = { encode: v => v === null ? xdr.ScVal.scvVec([sc.symbol("Unconfigured")]) : xdr.ScVal.scvVec([sc.symbol("Configured"), CONFIG.encode(v)]), decode: v => { if (!Array.isArray(v))
         throw new NativeClaimError("invalid claim config state"); if (v.length === 1 && v[0] === "Unconfigured")
         return null; if (v.length === 2 && v[0] === "Configured")
         return CONFIG.decode(v[1]); throw new NativeClaimError("invalid claim config state"); } };
-const QUOTE = model({ network: HEX, registry: CONTRACT, registrar: CONTRACT, namespace: HEX, resolver: CONTRACT, label: LABEL, node: HEX, claimant: ACCOUNT, config: CONFIG_STATE, ownerEpoch: U64, policyVersion: U64, available: BOOL, reserved: BOOL, generation: optional(U64), expiresAt: optional(U64), termSecs: U64, now: U64, usage: USAGE, approvalUsage: APPROVAL_USAGE });
+const QUOTE = model({ network: HEX, registry: CONTRACT, registrar: CONTRACT, namespace: HEX, resolver: CONTRACT, label: LABEL, node: HEX, claimant: IDENTITY, config: CONFIG_STATE, ownerEpoch: U64, policyVersion: U64, available: BOOL, reserved: BOOL, generation: optional(U64), expiresAt: optional(U64), termSecs: U64, now: U64, usage: USAGE, approvalUsage: APPROVAL_USAGE });
 const RECEIPT = model({ operation: enumeration({ claim: "Claim", reserved: "Reserved", transfer: "Transfer", renew: "Renew" }), intentHash: HEX, node: HEX, holder: IDENTITY, generation: U64, expiresAt: U64, feeAmount: AMOUNT, feeToken: CONTRACT, feeRecipient: optional(ACCOUNT), ledger: U32, timestamp: U64 });
 const PREVIEW = model({ node: HEX, holder: IDENTITY, generation: U64, expiresAt: U64, active: BOOL, destination: DESTINATION });
 export function claimSettingsToScVal(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorandomains/owner",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Run your Soran namespace on Stellar: configure claims, issue names and manage namespace policies.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,7 @@
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "tsc",
     "check:browser": "esbuild dist/index.js --bundle --platform=browser --external:@stellar/stellar-sdk --outfile=browser-check.js --legal-comments=none --log-level=error && node -e \"const fs=require('fs');const s=fs.readFileSync('browser-check.js','utf8');fs.unlinkSync('browser-check.js');if(/\\bBuffer\\b/.test(s)){console.error('FAIL: bare Buffer reference in browser bundle');process.exit(1)}console.log('browser bundle clean')\"",
-    "test": "node --import tsx test/decode-failure.test.mts && node --import tsx --test test/integration.test.mts test/native-*.test.mts"
+    "test": "node --import tsx test/decode-failure.test.mts && node --import tsx --test test/integration.test.mts test/native-*.test.mts && node --import tsx --test test/funding.test.mts test/funding-history.test.mts"
   },
   "license": "MIT",
   "repository": {