@sorandomains/owner 0.12.1 → 0.13.0

package/README.md

@@ -12,7 +12,7 @@ Lookup is the read entry point in `@sorandomains/lookup` 0.10.0 or later.
 
 Version 0.12.1 rejects simulated transactions whose source, operation, contract, method, arguments or authorization differ from the requested legacy account-signed write. Unexpected authorizers and nested calls are rejected before signing.
 
-Releases older than 0.11.0 (and any built against Lookup 0.6.0 to 0.9.0) default to the retired 5 and 6 September 2026 testnet stacks; upgrade rather than pinning a retired Registry. See [Older versions and retired stacks](../../README.md#older-versions-and-retired-stacks).
+Releases older than 0.11.0 (and any built against Lookup 0.6.0 to 0.9.0) default to the retired 5 and 6 September 2026 testnet stacks; upgrade rather than pinning a retired Registry. See [Older versions and retired stacks](../README.md#older-versions-and-retired-stacks).
 
 Ownership, issuer, holder and treasury inputs remain G/C account or contract
 addresses. Muxed M addresses are payment destinations only: issue the name to its
@@ -119,7 +119,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 |
 |---|---|

package/dist/funding-owner.d.ts

@@ -1,5 +1,5 @@
 import { FundingReader, type FundingOptions } from "./funding-reader.js";
-import { type SponsorPolicy } from "./funding-types.js";
+import { type SponsorPolicy, type StoragePlan, type UpkeepPolicy, type ExecutionPolicy } from "./funding-types.js";
 import { type NativeSigner, type NativeWriteOptions } from "./native-transport.js";
 /** Direct owner operations work even when the sponsorship service is offline. */
 export declare class SoranFunding extends FundingReader {
@@ -42,4 +42,45 @@ export declare class SoranFunding extends FundingReader {
         ledger: number;
         value: unknown;
     }>;
+    activateStorage(namespace: string, plan: StoragePlan, retention: number, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    private upkeepController;
+    configureUpkeep(id: string, policy: UpkeepPolicy, deposit: bigint, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    depositUpkeep(id: string, amount: bigint, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    pauseUpkeep(id: string, paused: boolean, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    withdrawUpkeep(id: string, amount: bigint, recipient: string, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    configureExecution(id: string, policy: ExecutionPolicy, deposit: bigint, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    depositExecution(id: string, amount: bigint, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
+    withdrawExecution(id: string, amount: bigint, recipient: string, maxPayoutFee: bigint, options?: NativeWriteOptions): Promise<{
+        hash: string;
+        ledger: number;
+        value: unknown;
+    }>;
 }

package/dist/funding-owner.js

@@ -1,6 +1,6 @@
 import { Asset } from "@stellar/stellar-sdk";
 import { FundingReader } from "./funding-reader.js";
-import { FundingError, sponsorPolicyToScVal, } from "./funding-types.js";
+import { FundingError, sponsorPolicyToScVal, storagePlanToScVal, upkeepPolicyToScVal, executionPolicyToScVal, } from "./funding-types.js";
 import { address, namespaceNode, sc, unhex } from "./native-codec.js";
 import { sendNative, } from "./native-transport.js";
 /** Direct owner operations work even when the sponsorship service is offline. */
@@ -94,4 +94,91 @@ export class SoranFunding extends FundingReader {
     async close(id, options = {}) {
         return this.write("close_fund", [sc.bytes(unhex(id))], await this.controller(id), options);
     }
+    async activateStorage(namespace, plan, retention, options = {}) {
+        await this.upkeepConfiguration();
+        if (!Number.isSafeInteger(retention) || retention < 1)
+            throw new FundingError("Invalid retention");
+        const node = sc.bytes(namespaceNode(namespace));
+        const owner = address((await this.read(this.registryId, "owner_of", [node])).value, "identity", "namespace owner");
+        return this.write("upkeep_activate", [node, storagePlanToScVal(plan), sc.u32(retention)], owner, options);
+    }
+    async upkeepController(id) {
+        await this.upkeepConfiguration();
+        const p = await this.upkeepPosition(id);
+        if (!p)
+            throw new FundingError("Prepay namespace storage first");
+        return p.controller;
+    }
+    async configureUpkeep(id, policy, deposit, options = {}) {
+        if (deposit < 0n)
+            throw new FundingError("Invalid deposit");
+        const owner = await this.upkeepController(id);
+        return this.write("upkeep_configure", [sc.bytes(unhex(id)), upkeepPolicyToScVal(policy), sc.i128(deposit)], owner, options, deposit > 0n
+            ? [
+                {
+                    contract: Asset.native().contractId(this.passphrase),
+                    method: "transfer",
+                    args: [
+                        sc.address(owner),
+                        sc.address(this.fundingId),
+                        sc.i128(deposit),
+                    ],
+                },
+            ]
+            : []);
+    }
+    async depositUpkeep(id, amount, options = {}) {
+        if (amount <= 0n)
+            throw new FundingError("Deposit must be positive");
+        const owner = await this.upkeepController(id);
+        return this.write("upkeep_deposit", [sc.bytes(unhex(id)), sc.i128(amount)], owner, options, [
+            {
+                contract: Asset.native().contractId(this.passphrase),
+                method: "transfer",
+                args: [
+                    sc.address(owner),
+                    sc.address(this.fundingId),
+                    sc.i128(amount),
+                ],
+            },
+        ]);
+    }
+    async pauseUpkeep(id, paused, options = {}) {
+        return this.write("upkeep_pause", [sc.bytes(unhex(id)), sc.bool(paused)], await this.upkeepController(id), options);
+    }
+    async withdrawUpkeep(id, amount, recipient, options = {}) {
+        if (amount <= 0n || recipient === this.fundingId)
+            throw new FundingError("Invalid withdrawal");
+        return this.write("upkeep_withdraw", [
+            sc.bytes(unhex(id)),
+            sc.address(address(recipient, "identity", "recipient")),
+            sc.i128(amount),
+        ], await this.upkeepController(id), options);
+    }
+    async configureExecution(id, policy, deposit, options = {}) {
+        if (deposit < 0n)
+            throw new FundingError("Invalid execution deposit");
+        const c = await this.executionConfiguration();
+        if (policy.wallet !== c.wallet)
+            throw new FundingError("Execution wallet differs from the approved deployment", "authorization");
+        const owner = await this.upkeepController(id);
+        return this.write("execution_configure", [sc.bytes(unhex(id)), executionPolicyToScVal(policy), sc.i128(deposit)], owner, options, deposit > 0n ? [{ contract: Asset.native().contractId(this.passphrase), method: "transfer", args: [sc.address(owner), sc.address(c.wallet), sc.i128(deposit)] }] : []);
+    }
+    async depositExecution(id, amount, options = {}) {
+        if (amount <= 0n)
+            throw new FundingError("Execution deposit must be positive");
+        const owner = await this.upkeepController(id), a = await this.executionApproval(id), c = await this.executionConfiguration();
+        if (!a || a.policy.wallet !== c.wallet)
+            throw new FundingError("Review prepaid execution terms first", "authorization");
+        return this.write("execution_deposit", [sc.bytes(unhex(id)), sc.i128(amount)], owner, options, [{ contract: Asset.native().contractId(this.passphrase), method: "transfer", args: [sc.address(owner), sc.address(c.wallet), sc.i128(amount)] }]);
+    }
+    async withdrawExecution(id, amount, recipient, maxPayoutFee, options = {}) {
+        if (amount <= 0n || maxPayoutFee < 100n || maxPayoutFee > 4294967295n)
+            throw new FundingError("Invalid prepaid withdrawal or payout fee ceiling");
+        address(recipient, "account", "withdrawal recipient");
+        const a = await this.executionApproval(id);
+        if (!a || recipient === a.policy.wallet || amount + maxPayoutFee > a.depositedTotal)
+            throw new FundingError("Invalid execution withdrawal");
+        return this.write("execution_withdraw_request", [sc.bytes(unhex(id)), sc.address(recipient), sc.i128(amount), sc.i128(maxPayoutFee)], await this.upkeepController(id), options);
+    }
 }

package/dist/funding-reader.d.ts

@@ -1,5 +1,5 @@
 import { rpc, xdr } from "@stellar/stellar-sdk";
-import { type SponsorQuote } from "./funding-types.js";
+import { type SponsorQuote, type StoragePlan, type UpkeepQuote, type ExecutionQuote } from "./funding-types.js";
 export type FundingOptions = {
     fundingId: string;
     registryId: string;
@@ -40,4 +40,32 @@ export declare class FundingReader {
     policy(id: string): Promise<import("./funding-types.js").SponsorPolicy | null>;
     actorState(id: string, actor: string): Promise<import("./funding-types.js").SponsorActorState>;
     validateQuote(quote: SponsorQuote): Promise<void>;
+    upkeepConfiguration(): Promise<{
+        registry: string;
+        nativeAsset: string;
+        lookup: string;
+        primary: string;
+        governance: string;
+        paused: boolean;
+        revision: bigint;
+        ledger: number;
+    }>;
+    isUpkeepEnrolled(namespace: string): Promise<boolean>;
+    currentUpkeep(namespace: string): Promise<{
+        id: string;
+        position: import("./funding-types.js").UpkeepPosition | null;
+    }>;
+    upkeepPosition(id: string): Promise<import("./funding-types.js").UpkeepPosition | null>;
+    upkeepPolicy(id: string): Promise<import("./funding-types.js").UpkeepPolicy | null>;
+    storagePlan(namespace: string): Promise<StoragePlan>;
+    upkeepCoverage(id: string, plan: StoragePlan): Promise<number[]>;
+    validateUpkeepQuote(q: UpkeepQuote): Promise<void>;
+    executionConfiguration(): Promise<{
+        version: 2;
+        wallet: string;
+    }>;
+    executionApproval(id: string): Promise<import("./funding-types.js").ExecutionApproval | null>;
+    executionWithdrawal(id: string, nonce: bigint): Promise<import("./funding-types.js").ExecutionWithdrawal | null>;
+    executionWithdrawalNonce(id: string): Promise<bigint>;
+    validateExecutionQuote(q: ExecutionQuote): Promise<void>;
 }

package/dist/funding-reader.js

@@ -1,6 +1,6 @@
 import { Account, Asset, Contract, Networks, StrKey, TransactionBuilder, hash, rpc, scValToNative, } from "@stellar/stellar-sdk";
 import { address, hex, namespaceNode, sc, unhex, utf8, } from "./native-codec.js";
-import { FundingError, fundingConfigurationFromNative, fundingPositionFromNative, fundingPositionId, sponsorActorFromNative, sponsorPolicyFromNative, sponsorQuoteToScVal, } from "./funding-types.js";
+import { FundingError, fundingConfigurationFromNative, fundingPositionFromNative, fundingPositionId, sponsorActorFromNative, sponsorPolicyFromNative, sponsorQuoteToScVal, upkeepPositionId, upkeepPositionFromNative, upkeepPolicyFromNative, storagePlanToScVal, upkeepQuoteToScVal, executionApprovalFromNative, executionWithdrawalFromNative, executionQuoteToScVal, } from "./funding-types.js";
 export class FundingReader {
     fundingId;
     registryId;
@@ -18,9 +18,16 @@ export class FundingReader {
         if (this.passphrase !== Networks.TESTNET)
             throw new FundingError("Funding V1 is currently restricted to testnet");
         this.networkId = hex(hash(utf8(this.passphrase)));
-        this.server =
-            options.server ??
-                new rpc.Server(options.rpcUrl ?? "https://soroban-testnet.stellar.org");
+        if (options.server) {
+            // A supplied client retains its caller-reviewed transport configuration.
+            this.server = options.server;
+        }
+        else {
+            this.server = new rpc.Server(options.rpcUrl ?? "https://soroban-testnet.stellar.org");
+            // SDK 17 ignores the constructor's timeout option. Bound the HTTP client
+            // actually used by simulation and ledger requests, as the API RPC factory does.
+            this.server.httpClient.defaults.timeout = 15_000;
+        }
     }
     async read(contract, method, args, minimumLedger = 1) {
         const source = new Account(StrKey.encodeEd25519PublicKey(new Uint8Array(32)), "0");
@@ -42,6 +49,11 @@ export class FundingReader {
             result.latestLedger < minimumLedger)
             throw new FundingError("Cannot verify funding contract state: " +
                 ("error" in result ? result.error : "missing or stale response"), "unavailable");
+        const data = result.transactionData.build();
+        if (data.ext.type !== "v0" &&
+            (data.ext.type !== "resourceExt" ||
+                data.ext.value.archivedSorobanEntries.length > 0))
+            throw new FundingError("Cannot verify live funding state: archived entries require explicit restoration", "unavailable");
         return {
             value: scValToNative(result.result.retval),
             ledger: result.latestLedger,
@@ -99,4 +111,107 @@ export class FundingReader {
         await this.configuration();
         await this.read(this.fundingId, "quote_status", [sponsorQuoteToScVal(quote)], quote.issuedLedger);
     }
+    async upkeepConfiguration() {
+        const config = await this.configuration();
+        if ((await this.read(this.fundingId, "upkeep_version", [], config.ledger))
+            .value !== 1)
+            throw new FundingError("Owner-funded storage is not installed on this deployment", "unavailable");
+        return config;
+    }
+    async isUpkeepEnrolled(namespace) {
+        await this.upkeepConfiguration();
+        const r = await this.read(this.fundingId, "upkeep_enrolled", [sc.bytes(namespaceNode(namespace))]);
+        if (typeof r.value !== "boolean")
+            throw new FundingError("Namespace storage billing boundary is unavailable", "unavailable");
+        return r.value;
+    }
+    async currentUpkeep(namespace) {
+        await this.upkeepConfiguration();
+        const node = hex(namespaceNode(namespace));
+        const epoch = await this.read(this.registryId, "owner_epoch", [
+            sc.bytes(unhex(node)),
+        ]);
+        if (typeof epoch.value !== "bigint" || epoch.value < 1n)
+            throw new FundingError("Namespace ownership epoch unavailable", "unavailable");
+        const id = upkeepPositionId(node, epoch.value);
+        return { id, position: await this.upkeepPosition(id) };
+    }
+    async upkeepPosition(id) {
+        const r = await this.read(this.fundingId, "upkeep_position", [
+            sc.bytes(unhex(id)),
+        ]);
+        if (r.value === null || r.value === undefined)
+            return null;
+        const p = upkeepPositionFromNative(r.value);
+        if (upkeepPositionId(p.namespace, p.ownerEpoch) !== id)
+            throw new FundingError("Upkeep ownership epoch does not match", "unavailable");
+        return p;
+    }
+    async upkeepPolicy(id) {
+        const r = await this.read(this.fundingId, "upkeep_policy", [
+            sc.bytes(unhex(id)),
+        ]);
+        return r.value === null || r.value === undefined
+            ? null
+            : upkeepPolicyFromNative(r.value);
+    }
+    async storagePlan(namespace) {
+        await this.upkeepConfiguration();
+        const pair = (await this.read(this.registryId, "native_contracts", [
+            sc.bytes(namespaceNode(namespace)),
+        ])).value;
+        if (!Array.isArray(pair) || pair.length !== 2)
+            throw new FundingError("Native namespace pair unavailable", "unavailable");
+        const plan = {
+            registrar: address(pair[0], "contract", "Registrar"),
+            resolver: address(pair[1], "contract", "Resolver"),
+            registrarKeys: [],
+            resolverKeys: [],
+        };
+        for (const c of [plan.registrar, plan.resolver])
+            if ((await this.read(c, "storage_upkeep_version", [])).value !== 1)
+                throw new FundingError("Namespace storage upgrade required", "unavailable");
+        return plan;
+    }
+    async upkeepCoverage(id, plan) {
+        const r = await this.read(this.fundingId, "upkeep_coverage", [
+            sc.bytes(unhex(id)),
+            storagePlanToScVal(plan),
+        ]);
+        if (!Array.isArray(r.value) ||
+            r.value.some((v) => !Number.isSafeInteger(v) || v < 0))
+            throw new FundingError("Invalid storage coverage response", "unavailable");
+        return r.value;
+    }
+    async validateUpkeepQuote(q) {
+        if (q.funding !== this.fundingId || q.network !== this.networkId)
+            throw new FundingError("Upkeep quote belongs to another deployment", "authorization");
+        await this.upkeepConfiguration();
+        await this.read(this.fundingId, "upkeep_quote_status", [upkeepQuoteToScVal(q)], q.issuedLedger);
+    }
+    async executionConfiguration() {
+        await this.upkeepConfiguration();
+        if ((await this.read(this.fundingId, "execution_version", [])).value !== 2)
+            throw new FundingError("Prepaid execution contract upgrade required", "unavailable");
+        return { version: 2, wallet: address((await this.read(this.fundingId, "execution_wallet", [])).value, "account", "custodial execution wallet") };
+    }
+    async executionApproval(id) {
+        const value = (await this.read(this.fundingId, "execution_approval", [sc.bytes(unhex(id))])).value;
+        return value == null ? null : executionApprovalFromNative(value);
+    }
+    async executionWithdrawal(id, nonce) {
+        const value = (await this.read(this.fundingId, "execution_withdrawal", [sc.bytes(unhex(id)), sc.u64(nonce)])).value;
+        return value == null ? null : executionWithdrawalFromNative(value);
+    }
+    async executionWithdrawalNonce(id) {
+        const value = (await this.read(this.fundingId, "execution_withdrawal_nonce", [sc.bytes(unhex(id))])).value;
+        if (typeof value !== "bigint" || value < 0n)
+            throw new FundingError("Invalid withdrawal cursor", "unavailable");
+        return value;
+    }
+    async validateExecutionQuote(q) {
+        if (q.funding !== this.fundingId || q.network !== this.networkId)
+            throw new FundingError("Execution quote belongs to another deployment", "authorization");
+        await this.read(this.fundingId, "execution_quote_status", [executionQuoteToScVal(q)], q.issuedLedger);
+    }
 }

package/dist/funding-types.d.ts

@@ -102,3 +102,91 @@ export declare function fundingPositionId(namespace: string, ownerEpoch: bigint)
 export declare const encodeSponsorQuote: (v: SponsorQuote) => string;
 export declare function decodeSponsorQuote(encoded: string): SponsorQuote;
 export declare const FUNDING_ERRORS: Record<number, string>;
+/** Owner-funded namespace retention. Kept separate from registration coverage. */
+export type StoragePlan = {
+    registrar: string;
+    resolver: string;
+    registrarKeys: xdr.ScVal[];
+    resolverKeys: xdr.ScVal[];
+};
+export type UpkeepPolicy = {
+    relayer: string;
+    renewalCap: bigint;
+    dailyCap: bigint;
+    totalCap: bigint;
+    retention: number;
+    renewBefore: number;
+    quoteLifetime: number;
+    validUntil: bigint;
+};
+export type UpkeepReceipt = {
+    quoteHash: string;
+    quoteId: string;
+    nonce: bigint;
+    charge: bigint;
+    balance: bigint;
+    ledger: number;
+    coveredUntil: number;
+};
+export type UpkeepPosition = Omit<FundingPosition, "status"> & {
+    status: "paused" | "active" | "closed";
+    nonce: bigint;
+    lastReceipt: UpkeepReceipt | null;
+};
+export type UpkeepQuote = {
+    network: string;
+    funding: string;
+    configRevision: bigint;
+    fundId: string;
+    policyRevision: bigint;
+    nonce: bigint;
+    quoteId: string;
+    plan: StoragePlan;
+    charge: bigint;
+    issuedLedger: number;
+    expiresLedger: number;
+};
+export type ExecutionPolicy = {
+    wallet: string;
+    limits: UpkeepPolicy;
+    serviceFeeCap: bigint;
+    termsVersion: 2;
+    serviceFeeBps: 500;
+    payFailedFees: true;
+};
+export type ExecutionApproval = {
+    policy: ExecutionPolicy;
+    depositedTotal: bigint;
+    depositNonce: bigint;
+};
+export type ExecutionQuote = Omit<UpkeepQuote, "charge"> & {
+    maxNetworkFee: bigint;
+};
+export type ExecutionReceipt = {
+    quoteHash: string;
+    quoteId: string;
+    nonce: bigint;
+    ledger: number;
+    coveredUntil: number;
+};
+export type ExecutionWithdrawal = {
+    controller: string;
+    recipient: string;
+    amount: bigint;
+    maxNetworkFee: bigint;
+    nonce: bigint;
+};
+export declare function executionPolicyToScVal(p: ExecutionPolicy): xdr.ScVal;
+export declare function executionApprovalFromNative(value: unknown): ExecutionApproval;
+export declare const executionReceiptFromNative: (value: unknown) => ExecutionReceipt;
+export declare const executionReceiptToScVal: (value: ExecutionReceipt) => xdr.ScVal;
+export declare const executionWithdrawalFromNative: (value: unknown) => ExecutionWithdrawal;
+export declare const upkeepPositionFromNative: (v: unknown) => UpkeepPosition;
+export declare const upkeepPolicyFromNative: (v: unknown) => UpkeepPolicy;
+export declare const upkeepReceiptToScVal: (v: UpkeepReceipt) => xdr.ScVal;
+export declare const upkeepReceiptFromNative: (v: unknown) => UpkeepReceipt;
+export declare function upkeepPositionId(namespace: string, epoch: bigint): string;
+export declare function upkeepPolicyToScVal(p: UpkeepPolicy): xdr.ScVal;
+export declare function storagePlanToScVal(p: StoragePlan): xdr.ScVal;
+export declare function upkeepQuoteToScVal(q: UpkeepQuote): xdr.ScVal;
+export declare function executionQuoteToScVal(q: ExecutionQuote): xdr.ScVal;

package/dist/funding-types.js

@@ -277,3 +277,164 @@ export const FUNDING_ERRORS = {
     30: "Name state changed",
     31: "Upgrade does not match",
 };
+const UPKEEP_POLICY = model({
+    relayer: G,
+    renewalCap: MONEY,
+    dailyCap: MONEY,
+    totalCap: MONEY,
+    retention: U32,
+    renewBefore: U32,
+    quoteLifetime: U32,
+    validUntil: U64,
+});
+const EXECUTION_POLICY = model({ wallet: G, limits: UPKEEP_POLICY, serviceFeeCap: MONEY, termsVersion: U32, serviceFeeBps: U32, payFailedFees: BOOL });
+const EXECUTION_APPROVAL = model({ policy: EXECUTION_POLICY, depositedTotal: MONEY, depositNonce: U64 });
+const EXECUTION_RECEIPT = model({ quoteHash: HEX, quoteId: HEX, nonce: U64, ledger: U32, coveredUntil: U32 });
+const EXECUTION_WITHDRAWAL = model({ controller: ID, recipient: G, amount: MONEY, maxNetworkFee: MONEY, nonce: U64 });
+function validateExecutionPolicy(p) {
+    upkeepPolicyToScVal(p.limits);
+    if (p.termsVersion !== 2 || p.serviceFeeBps !== 500 || p.payFailedFees !== true || p.wallet !== p.limits.relayer ||
+        p.serviceFeeCap < 0n || p.serviceFeeCap > p.limits.renewalCap)
+        throw new FundingError("Explicit prepaid custody, failed fees and capped 5% approval are required");
+}
+export function executionPolicyToScVal(p) {
+    const encoded = EXECUTION_POLICY.encode(p);
+    validateExecutionPolicy(p);
+    return encoded;
+}
+export function executionApprovalFromNative(value) {
+    const a = EXECUTION_APPROVAL.decode(value);
+    validateExecutionPolicy(a.policy);
+    return a;
+}
+export const executionReceiptFromNative = (value) => EXECUTION_RECEIPT.decode(value);
+export const executionReceiptToScVal = (value) => EXECUTION_RECEIPT.encode(value);
+export const executionWithdrawalFromNative = (value) => EXECUTION_WITHDRAWAL.decode(value);
+const UPKEEP_RECEIPT = model({
+    quoteHash: HEX,
+    quoteId: HEX,
+    nonce: U64,
+    charge: MONEY,
+    balance: MONEY,
+    ledger: U32,
+    coveredUntil: U32,
+});
+const UPKEEP_LAST = {
+    encode(v) {
+        return xdr.ScVal.scvVec(v === null
+            ? [sc.symbol("Empty")]
+            : [sc.symbol("Recorded"), UPKEEP_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 UPKEEP_RECEIPT.decode(v[1]);
+        throw new FundingError("Malformed upkeep receipt");
+    },
+};
+const UPKEEP_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" }),
+    nonce: U64,
+    lastReceipt: UPKEEP_LAST,
+});
+export const upkeepPositionFromNative = (v) => UPKEEP_POSITION.decode(v);
+export const upkeepPolicyFromNative = (v) => UPKEEP_POLICY.decode(v);
+export const upkeepReceiptToScVal = (v) => UPKEEP_RECEIPT.encode(v);
+export const upkeepReceiptFromNative = (v) => UPKEEP_RECEIPT.decode(v);
+export function upkeepPositionId(namespace, epoch) {
+    return hex(hash(xdr.ScVal.scvVec([
+        sc.symbol("upkeep_v1"),
+        HEX.encode(namespace),
+        U64.encode(epoch),
+    ]).toXDR()));
+}
+export function upkeepPolicyToScVal(p) {
+    const encoded = UPKEEP_POLICY.encode(p);
+    if (p.renewalCap <= 0n ||
+        p.dailyCap < p.renewalCap ||
+        p.totalCap < p.dailyCap ||
+        p.retention < 1 ||
+        p.renewBefore < 1 ||
+        p.renewBefore >= p.retention ||
+        p.quoteLifetime < 1 ||
+        p.quoteLifetime > 120 ||
+        p.validUntil <= 0n)
+        throw new FundingError("Invalid upkeep spending limits or retention");
+    return encoded;
+}
+export function storagePlanToScVal(p) {
+    exactObject(p, ["registrar", "resolver", "registrarKeys", "resolverKeys"], "storage plan");
+    const keys = (v) => {
+        if (!Array.isArray(v) || v.length > 32)
+            throw new FundingError("At most 32 storage keys per contract");
+        const seen = new Set();
+        for (const key of v) {
+            if (!(key instanceof xdr.ScVal))
+                throw new FundingError("Storage keys must be canonical ScVal values");
+            const raw = key.toXDR("base64");
+            if (seen.has(raw))
+                throw new FundingError("Duplicate storage key");
+            seen.add(raw);
+        }
+        return xdr.ScVal.scvVec(v);
+    };
+    const encoded = struct({
+        registrar: C.encode(p.registrar),
+        resolver: C.encode(p.resolver),
+        registrar_keys: keys(p.registrarKeys),
+        resolver_keys: keys(p.resolverKeys),
+    });
+    if (p.registrar === p.resolver || encoded.toXDR().length > 16384)
+        throw new FundingError("Invalid storage plan routes or size");
+    return encoded;
+}
+export function upkeepQuoteToScVal(q) {
+    exactObject(q, [
+        "network",
+        "funding",
+        "configRevision",
+        "fundId",
+        "policyRevision",
+        "nonce",
+        "quoteId",
+        "plan",
+        "charge",
+        "issuedLedger",
+        "expiresLedger",
+    ], "upkeep quote");
+    if (q.charge <= 0n ||
+        q.expiresLedger <= q.issuedLedger ||
+        q.expiresLedger - q.issuedLedger > 120)
+        throw new FundingError("Invalid upkeep quote charge or lifetime");
+    return struct({
+        network: HEX.encode(q.network),
+        funding: C.encode(q.funding),
+        config_revision: U64.encode(q.configRevision),
+        fund_id: HEX.encode(q.fundId),
+        policy_revision: U64.encode(q.policyRevision),
+        nonce: U64.encode(q.nonce),
+        quote_id: HEX.encode(q.quoteId),
+        plan: storagePlanToScVal(q.plan),
+        charge: MONEY.encode(q.charge),
+        issued_ledger: U32.encode(q.issuedLedger),
+        expires_ledger: U32.encode(q.expiresLedger),
+    });
+}
+export function executionQuoteToScVal(q) {
+    exactObject(q, ["network", "funding", "configRevision", "fundId", "policyRevision", "nonce", "quoteId", "plan", "maxNetworkFee", "issuedLedger", "expiresLedger"], "prepaid execution quote");
+    if (q.maxNetworkFee <= 0n || q.expiresLedger <= q.issuedLedger || q.expiresLedger - q.issuedLedger > 120)
+        throw new FundingError("Invalid prepaid execution budget or lifetime");
+    return struct({ network: HEX.encode(q.network), funding: C.encode(q.funding), config_revision: U64.encode(q.configRevision),
+        fund_id: HEX.encode(q.fundId), policy_revision: U64.encode(q.policyRevision), nonce: U64.encode(q.nonce),
+        quote_id: HEX.encode(q.quoteId), plan: storagePlanToScVal(q.plan), max_network_fee: MONEY.encode(q.maxNetworkFee),
+        issued_ledger: U32.encode(q.issuedLedger), expires_ledger: U32.encode(q.expiresLedger) });
+}

package/dist/native-codec.js

@@ -1,6 +1,6 @@
 /** Local successor-ABI helpers. No deployed defaults are changed by this module. */
 import { Address, StrKey, hash, nativeToScVal, xdr } from "@stellar/stellar-sdk";
-import { decodeMuxedAddress, paymentMemoToScVal, validatePaymentDestination } from "./payment.js";
+import { isMuxedPaymentAddress, decodeMuxedAddress, paymentMemoToScVal, validatePaymentDestination } from "./payment.js";
 export const NATIVE_REGISTRAR_ERRORS = { 1: "AlreadyInitialized", 2: "NotInitialized", 3: "NameTaken", 4: "NameNotFound", 5: "NotReclaimable", 6: "NotTransferable", 7: "AlreadyPermanent", 8: "BatchTooLarge", 9: "NotNamespaceOwner", 10: "BadLabel", 11: "PermanentName", 12: "FiniteTermPolicy", 13: "PermanentlyLocked", 14: "NameExpired", 15: "NoPendingTransfer", 16: "TransferExpired", 17: "StaleTransfer", 18: "InvalidPolicy", 19: "ExpiryOverflow", 20: "InvalidRegistry", 21: "InvalidClaimConfig", 22: "ClaimsNotConfigured", 23: "ClaimsPaused", 24: "StaleClaimPolicy", 25: "ClaimIntentMismatch", 26: "ClaimIntentExpired", 27: "ReservedName", 28: "NameNotReserved", 29: "PublicIssuanceRequired", 30: "WalletClaimLimit", 31: "InvalidEligibility", 32: "ApprovalAllowanceReached", 33: "ApprovalRateReached", 34: "RequestIdConflict", 35: "CounterOverflow", 36: "InvalidNativeBinding", 37: "UnsupportedClaimant", 38: "DuplicateLabel", 39: "RenewalTooEarly", 40: "RenewalLeaseLimit", 41: "DestinationInitializationFailed", 42: "FeeSettlementFailed", 43: "MigrationInProgress", 44: "MigrationAlreadyStarted", 45: "MigrationNotActive", 46: "MigrationMismatch", 47: "MigrationDuplicate", 48: "MigrationIncomplete", 49: "MigrationUnavailable", 50: "MigrationUnsupported", 51: "PermanentLockDisabled", 52: "InvalidRenewalGrace", 53: "SubnameCreationDisabled", 54: "SubnamesSuspended", 55: "SubnameGenerationMismatch", 56: "SubnameIndexUnavailable" };
 export class NativeClaimError extends Error {
     kind;
@@ -86,7 +86,7 @@ export function struct(fields) {
 }
 export function paymentDestinationToScVal(raw) {
     const payment = validatePaymentDestination(raw);
-    if (StrKey.isValidMed25519PublicKey(payment.address)) {
+    if (isMuxedPaymentAddress(payment.address)) {
         const value = decodeMuxedAddress(payment.address);
         return xdr.ScVal.scvVec([sc.symbol("Muxed"), struct({ account: sc.address(value.account), id: sc.u64(BigInt(value.id)) })]);
     }

package/dist/native-transport.d.ts

@@ -54,6 +54,8 @@ export type NativeWriteOptions = {
     /** Persist the public recovery reference before wallet signing/broadcast. Rejecting stops submission. */
     onPrepared?: (prepared: NativePrepared) => void | Promise<void>;
 };
+/** Protocol 29 can fold restoration into an otherwise successful simulation. */
+export declare function refuseNativeRestoration(tx: Transaction): void;
 export declare function prepareNative(context: NativeContext, plan: NativeAuthorizationPlan, options?: NativeWriteOptions): Promise<{
     transaction: Transaction;
     prepared: NativePrepared;

package/dist/native-transport.js

@@ -66,6 +66,15 @@ export async function requireNative(context, namespace) {
         throw new NativeClaimError(`namespace has no supported native claim interface (${capability.reason})`, "unsupported");
     return capability;
 }
+/** Protocol 29 can fold restoration into an otherwise successful simulation. */
+export function refuseNativeRestoration(tx) {
+    const envelope = tx.toEnvelope();
+    if (envelope.type !== "envelopeTypeTx" || envelope.value.tx.ext.type !== "sorobanData")
+        return;
+    const ext = envelope.value.tx.ext.value.ext;
+    if (ext.type !== "v0" && (ext.type !== "resourceExt" || ext.value.archivedSorobanEntries.length > 0))
+        throw new NativeClaimError("This operation would restore archived storage. Review restoration separately before continuing.", "unavailable");
+}
 export async function prepareNative(context, plan, options = {}) {
     const source = address(await context.signer.publicKey(), "account", "transaction signer");
     if (source !== plan.source)
@@ -97,6 +106,7 @@ export async function prepareNative(context, plan, options = {}) {
         const auth = (op.auth ?? []).map(entry => entry.credentials.type === "sorobanCredentialsSourceAccount" ? entry : signed);
         transaction = TransactionBuilder.cloneFrom(transaction, { networkPassphrase: context.passphrase }).clearOperations().addOperation(Operation.invokeHostFunction({ func: op.func, auth })).build();
         transaction = rpc.assembleTransaction(transaction, await simulate(transaction)).build();
+        refuseNativeRestoration(transaction);
         validateNativeTransaction(transaction, plan);
     }
     const op = transaction.operations[0];

package/dist/native-upgrades.d.ts

@@ -23,12 +23,12 @@ export type ContractUpgradeStatus = {
  */
 export declare const CONTRACT_RELEASES: {
     readonly registrar: {
-        readonly latest: "4d6d18625f4d890028acb794b24871c5c93f96dc15d94cf3d52cbf9713b07fb1";
-        readonly superseded: readonly ["42dc5f8b40932617d3f2667e1d26dad3e5e9a62c63de1fde7c016cb67a86c420", "5c8ae72ea7370ccf19af52b9bbc0007362be94464651ccdf68a2bb1f478b6f2c", "61ded153e6311075c1087c5639a5410222e23f7cade239ed2c946150af94b1c5", "26e03cd1d7fbfa46fe442406fb1b88022ec8cd8bd9123bed570f971fce596a14"];
+        readonly latest: "13195f1ed62cee15a30fab0d69da09f8537f2c5b62dfb9bbe70d9f3a5a90e498";
+        readonly superseded: readonly ["a7b618ac95f5f0b76d4489a9e88d1ce4691611b0d7c53d2d2f8b74b7526e284a", "8e84a35643c6e9c54d161c44102d229e18b50ad16394afea6d73031e21188ede", "4d6d18625f4d890028acb794b24871c5c93f96dc15d94cf3d52cbf9713b07fb1", "42dc5f8b40932617d3f2667e1d26dad3e5e9a62c63de1fde7c016cb67a86c420", "5c8ae72ea7370ccf19af52b9bbc0007362be94464651ccdf68a2bb1f478b6f2c", "61ded153e6311075c1087c5639a5410222e23f7cade239ed2c946150af94b1c5", "26e03cd1d7fbfa46fe442406fb1b88022ec8cd8bd9123bed570f971fce596a14"];
     };
     readonly resolver: {
-        readonly latest: "941bf87f26cb817f3c6a52a326de855cca8a1dc4477e62a38ec4ffa5c7f43806";
-        readonly superseded: readonly ["cb927ffa19d6b1f3f0b0187048d885e200adb6de3fddd11ee3cfeb59df9c5c48", "351bf4e056b179b578fe2a4ea46f937bfafccc6538c7357ea70021b7038d91ea", "c6dfcd7bbf35943a13406888678334d0938d0fea54939906b00c2dc37b4a9a71", "5e7b4fb8d310d67ed6966a155e748d60be771422b3e8c34bbc14485f98525574"];
+        readonly latest: "a77bb9ef08d383691092c71ce6291e2f5ab600320c5afd5686713cc54cbfd95c";
+        readonly superseded: readonly ["4ab266de682a38208464e74d52692829ac344ece14f48c4249c3455e6b62a27b", "743559d763d81bf2debe8b70650a2a6dc50d6f5da4cbc0aeccedd3f5559442a7", "218cb1f7f90bd21f81ad4fe8b86f66478c3804b7355257cdc7e37d55d7edd5fb", "941bf87f26cb817f3c6a52a326de855cca8a1dc4477e62a38ec4ffa5c7f43806", "cb927ffa19d6b1f3f0b0187048d885e200adb6de3fddd11ee3cfeb59df9c5c48", "351bf4e056b179b578fe2a4ea46f937bfafccc6538c7357ea70021b7038d91ea", "c6dfcd7bbf35943a13406888678334d0938d0fea54939906b00c2dc37b4a9a71", "5e7b4fb8d310d67ed6966a155e748d60be771422b3e8c34bbc14485f98525574"];
     };
 };
 /**

package/dist/native-upgrades.js

@@ -11,8 +11,11 @@ import { expectedNativeCode } from "./native-code-policy.js";
  */
 export const CONTRACT_RELEASES = {
     registrar: {
-        latest: "4d6d18625f4d890028acb794b24871c5c93f96dc15d94cf3d52cbf9713b07fb1",
+        latest: "13195f1ed62cee15a30fab0d69da09f8537f2c5b62dfb9bbe70d9f3a5a90e498",
         superseded: [
+            "a7b618ac95f5f0b76d4489a9e88d1ce4691611b0d7c53d2d2f8b74b7526e284a",
+            "8e84a35643c6e9c54d161c44102d229e18b50ad16394afea6d73031e21188ede",
+            "4d6d18625f4d890028acb794b24871c5c93f96dc15d94cf3d52cbf9713b07fb1",
             "42dc5f8b40932617d3f2667e1d26dad3e5e9a62c63de1fde7c016cb67a86c420",
             "5c8ae72ea7370ccf19af52b9bbc0007362be94464651ccdf68a2bb1f478b6f2c",
             "61ded153e6311075c1087c5639a5410222e23f7cade239ed2c946150af94b1c5",
@@ -20,8 +23,12 @@ export const CONTRACT_RELEASES = {
         ],
     },
     resolver: {
-        latest: "941bf87f26cb817f3c6a52a326de855cca8a1dc4477e62a38ec4ffa5c7f43806",
+        latest: "a77bb9ef08d383691092c71ce6291e2f5ab600320c5afd5686713cc54cbfd95c",
         superseded: [
+            "4ab266de682a38208464e74d52692829ac344ece14f48c4249c3455e6b62a27b",
+            "743559d763d81bf2debe8b70650a2a6dc50d6f5da4cbc0aeccedd3f5559442a7",
+            "218cb1f7f90bd21f81ad4fe8b86f66478c3804b7355257cdc7e37d55d7edd5fb",
+            "941bf87f26cb817f3c6a52a326de855cca8a1dc4477e62a38ec4ffa5c7f43806",
             "cb927ffa19d6b1f3f0b0187048d885e200adb6de3fddd11ee3cfeb59df9c5c48",
             "351bf4e056b179b578fe2a4ea46f937bfafccc6538c7357ea70021b7038d91ea",
             "c6dfcd7bbf35943a13406888678334d0938d0fea54939906b00c2dc37b4a9a71",

package/dist/payment.d.ts

@@ -18,6 +18,8 @@ export type PaymentDestination = {
     address: string;
     memo: PaymentMemo;
 };
+/** M and W are destinations, never standalone signing identities. */
+export declare function isMuxedPaymentAddress(address: string): boolean;
 /** Reject invalid data without normalizing meaningful memo bytes. */
 export declare function validatePaymentDestination(value: unknown): PaymentDestination;
 export declare function encodePaymentRecord(value: PaymentDestination): string;
@@ -31,7 +33,7 @@ export declare function decodeMuxedAddress(address: string): {
     account: string;
     id: string;
 };
-/** Encode only canonical G + exact decimal u64; numbers are never accepted. */
+/** Encode a G or C base and exact decimal u64; numbers are never accepted. */
 export declare function encodeMuxedAddress(account: string, id: string): string;
 /** Strict additive on-chain destination enum; v1 payment structs stay separate. */
 export declare function destinationFromNative(raw: unknown): PaymentDestination;

package/dist/payment.js

@@ -4,6 +4,10 @@ import { StrKey, nativeToScVal, xdr } from "@stellar/stellar-sdk";
 export const PAYMENT_RECORD_KEY = "payment";
 const MAX_U64 = 18446744073709551615n;
 const utf8 = (value) => new TextEncoder().encode(value);
+/** M and W are destinations, never standalone signing identities. */
+export function isMuxedPaymentAddress(address) {
+    return StrKey.isValidMed25519PublicKey(address) || StrKey.isValidMuxedContract(address);
+}
 /** Reject invalid data without normalizing meaningful memo bytes. */
 export function validatePaymentDestination(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -11,15 +15,15 @@ export function validatePaymentDestination(value) {
     const p = value;
     if (Object.keys(p).sort().join(",") !== "address,memo")
         throw new Error("unexpected payment fields");
-    if (typeof p.address !== "string" || (!StrKey.isValidEd25519PublicKey(p.address) && !StrKey.isValidContract(p.address) && !StrKey.isValidMed25519PublicKey(p.address)))
-        throw new Error("payment address must be a valid G, C or M address");
+    if (typeof p.address !== "string" || (!StrKey.isValidEd25519PublicKey(p.address) && !StrKey.isValidContract(p.address) && !isMuxedPaymentAddress(p.address)))
+        throw new Error("payment address must be a valid G, C, M or W address");
     if (!p.memo || typeof p.memo !== "object" || Array.isArray(p.memo))
         throw new Error("invalid memo");
     const m = p.memo;
     if (m.type === "none") {
         if (Object.keys(m).join(",") !== "type")
             throw new Error("none memo cannot have a value");
-        if (StrKey.isValidMed25519PublicKey(p.address))
+        if (isMuxedPaymentAddress(p.address))
             decodeMuxedAddress(p.address);
         return { address: p.address, memo: { type: "none" } };
     }
@@ -47,7 +51,7 @@ export function validatePaymentDestination(value) {
 }
 export function encodePaymentRecord(value) {
     const p = validatePaymentDestination(value);
-    if (StrKey.isValidMed25519PublicKey(p.address)) {
+    if (isMuxedPaymentAddress(p.address)) {
         const muxed = decodeMuxedAddress(p.address);
         return `2|${muxed.account}|muxed|${muxed.id}`;
     }
@@ -108,30 +112,32 @@ export function paymentFromNative(raw) {
 }
 /** Decode a full muxed destination without treating its operation ID as a memo. */
 export function decodeMuxedAddress(address) {
-    if (typeof address !== "string" || !StrKey.isValidMed25519PublicKey(address))
-        throw new Error("invalid muxed M address");
-    const raw = StrKey.decodeMed25519PublicKey(address);
-    if (raw.length !== 40 || StrKey.encodeMed25519PublicKey(raw) !== address)
+    if (typeof address !== "string" || !isMuxedPaymentAddress(address))
+        throw new Error("invalid muxed M or W address");
+    const contract = StrKey.isValidMuxedContract(address);
+    const raw = contract ? StrKey.decodeMuxedContract(address) : StrKey.decodeMed25519PublicKey(address);
+    if (raw.length !== 40 || (contract ? StrKey.encodeMuxedContract(raw) : StrKey.encodeMed25519PublicKey(raw)) !== address)
         throw new Error("noncanonical muxed address");
     let id = 0n;
     for (const byte of raw.subarray(32))
         id = (id << 8n) | BigInt(byte);
-    return { account: StrKey.encodeEd25519PublicKey(raw.subarray(0, 32)), id: id.toString() };
+    return { account: contract ? StrKey.encodeContract(raw.subarray(0, 32)) : StrKey.encodeEd25519PublicKey(raw.subarray(0, 32)), id: id.toString() };
 }
-/** Encode only canonical G + exact decimal u64; numbers are never accepted. */
+/** Encode a G or C base and exact decimal u64; numbers are never accepted. */
 export function encodeMuxedAddress(account, id) {
-    if (typeof account !== "string" || !StrKey.isValidEd25519PublicKey(account))
-        throw new Error("muxed base must be a G account");
+    if (typeof account !== "string" || (!StrKey.isValidEd25519PublicKey(account) && !StrKey.isValidContract(account)))
+        throw new Error("muxed base must be a G account or C contract");
     if (typeof id !== "string" || !/^(0|[1-9][0-9]{0,19})$/.test(id) || BigInt(id) > MAX_U64)
         throw new Error("muxed ID must be canonical decimal u64");
     const raw = new Uint8Array(40);
-    raw.set(StrKey.decodeEd25519PublicKey(account));
+    const contract = StrKey.isValidContract(account);
+    raw.set(contract ? StrKey.decodeContract(account) : StrKey.decodeEd25519PublicKey(account));
     let value = BigInt(id);
     for (let i = 39; i >= 32; i--) {
         raw[i] = Number(value & 255n);
         value >>= 8n;
     }
-    return StrKey.encodeMed25519PublicKey(raw);
+    return contract ? StrKey.encodeMuxedContract(raw) : StrKey.encodeMed25519PublicKey(raw);
 }
 /** Strict additive on-chain destination enum; v1 payment structs stay separate. */
 export function destinationFromNative(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorandomains/owner",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "Run your Soran namespace on Stellar: configure claims, issue names and manage namespace policies.",
   "type": "module",
   "engines": {
@@ -16,7 +16,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/hardening.test.mts test/error-codes.test.mts test/nested-authorization.test.mts test/native-*.test.mts && node --import tsx --test test/funding.test.mts test/funding-history.test.mts test/funding-bounds.test.mts && node --import tsx --test test/multichain.test.mts && node --import tsx --test test/subnames.test.mts",
+    "test": "node --import tsx test/decode-failure.test.mts && node --import tsx --test test/integration.test.mts test/hardening.test.mts test/error-codes.test.mts test/nested-authorization.test.mts test/native-*.test.mts && node --import tsx --test test/funding.test.mts test/funding-history.test.mts test/funding-bounds.test.mts test/funding-upkeep.test.mts test/funding-prepaid.test.mts && node --import tsx --test test/multichain.test.mts && node --import tsx --test test/subnames.test.mts",
     "test:hardening": "node --import tsx --test test/hardening.test.mts"
   },
   "license": "MIT",
@@ -38,10 +38,10 @@
     "issuance"
   ],
   "peerDependencies": {
-    "@stellar/stellar-sdk": ">=17 <18"
+    "@stellar/stellar-sdk": ">=17.4.0 <18"
   },
   "devDependencies": {
-    "@stellar/stellar-sdk": "^17.0.1",
+    "@stellar/stellar-sdk": "17.4.0",
     "@types/node": "^26.6.3",
     "esbuild": "^0.28.2",
     "tsx": "^4.19.2",