@sorandomains/owner 0.9.0 → 0.10.0

package/README.md

@@ -91,7 +91,7 @@ Read the [native claim APIs, security boundaries and complete signup flow](https
 
 ## Verified testnet deployment
 
-See the [deployment manifest](../../deployments/testnet.json) for confirmed code hashes, transaction receipts and verification scope. 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 |
 |---|---|
@@ -121,22 +121,3 @@ 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/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-service.d.ts

@@ -1,7 +1,7 @@
 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";
+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;
@@ -18,6 +18,17 @@ export declare class FundingServiceClient {
         };
         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";

package/dist/funding-service.js

@@ -58,6 +58,18 @@ export class FundingServiceClient {
             intentXdr: encoded.toXDR("base64"),
             proof,
         });
+        return this.reviewOffer(offer, action, intent, maxSponsorCharge, proof);
+    }
+    /** Re-estimate with the previous, valid wallet authorization. This never
+     * submits; review the new charge and call authorize again before submit. */
+    async refreshQuote(request, authorizedTransactionXdr, maxSponsorCharge) {
+        this.id(request.quote.quoteId);
+        const offer = await this.call("/v1/sponsorship/requote", {
+            quoteId: request.quote.quoteId, transactionXdr: authorizedTransactionXdr,
+        });
+        return this.reviewOffer(offer, request.quote.action, request.intent, maxSponsorCharge, request.proof ?? []);
+    }
+    async reviewOffer(offer, action, intent, maxSponsorCharge, proof) {
         const quote = decodeSponsorQuote(offer.quoteXdr);
         if (offer.id !== quote.quoteId ||
             quote.action !== action ||

package/dist/funding-user.d.ts

@@ -1,5 +1,6 @@
 import { Transaction, authorizeEntry, xdr } from "@stellar/stellar-sdk";
 import { FundingReader } from "./funding-reader.js";
+import { type ContractWallet } from "./contract-wallet.js";
 import { type SponsorQuote, type SponsoredIdentityIntent } from "./funding-types.js";
 import { type ClaimIntent } from "./native-types.js";
 import { type NativeInvocation } from "./native-auth.js";
@@ -33,6 +34,7 @@ export declare class SoranSponsorship extends FundingReader {
         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>;
+    /** Sign only the caller's authorization. C wallets supply their own signature
+     * format; the service enforces __check_auth before the relayer signs. */
+    authorize(request: SponsorRequest, encoded: string, signer: Parameters<typeof authorizeEntry>[1] | ContractWallet, maxSponsorCharge: bigint, maxNetworkFee: bigint, eligibilityXdr?: string): Promise<string>;
 }

package/dist/funding-user.js

@@ -1,5 +1,6 @@
 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";
@@ -186,6 +187,11 @@ export class SoranSponsorship extends FundingReader {
             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;
@@ -211,17 +217,23 @@ export class SoranSponsorship extends FundingReader {
         validateSponsorTransaction(transaction, plan, sim.latestLedger);
         return { transaction, plan, ledger: sim.latestLedger };
     }
-    /** Sign only the caller's G authorization. Wallet adapters retain custody of keys. */
+    /** 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, "account", "this adapter's signing wallet");
+        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 = await authorizeEntry(entry, signer, request.quote.expiresLedger, this.passphrase);
+        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");

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;
     }>;
@@ -287,3 +291,4 @@ 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));

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.9.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",