@sorandomains/holder 0.1.0 → 0.2.0

package/README.md

@@ -28,11 +28,12 @@ await me.setProfile("alice.nova", {  // the standard keys every wallet reads
 | --- | --- |
 | `setRecord` | Point your name's explicit resolver record at any address (generation-gated — stops resolving the moment the name changes hands) |
 | `setAddress` | Re-point the built-in (Registrar) resolution target |
-| `setText` / `setProfile` | Publish text records; `setProfile` writes the standard `PROFILE_KEYS` (one transaction per key) |
+| `setText` / `setProfile` / `clearText` | Publish text records; `setProfile` writes the standard `PROFILE_KEYS` (one transaction per key); records are overwrite-only on chain — `clearText` retracts by writing the empty value standard readers treat as unset |
 | `setReverse` / `clearReverse` | Claim your address→name reverse record — the contract refuses names that don't already resolve to you (`ForwardMismatch`) |
 | `setPrimary` / `clearPrimary` | Your one cross-namespace display name, re-verified on chain at every read |
 | `proposeNameTransfer` / `acceptNameTransfer` / `cancelNameTransfer` | Two-step, accept-to-move name transfers (policy-gated) |
 | `pendingNameTransfer` | Read the pending proposal |
+| `registrarOf` / `resolverOf` | Discover the namespace's attested Registrar / resolver pointer |
 
 Everything is holder-authorized **on chain** — the Resolver checks you hold
 the name right now, reverse and primary claims are authorized by the address

package/dist/index.d.ts

@@ -158,6 +158,11 @@ export declare class SoranHolder {
      * and the contract enforces that the name's forward record already
      * resolves to you (ForwardMismatch otherwise): a reverse claim on a name
      * that doesn't point back at you is spoofing, and the chain refuses it.
+     *
+     * NOTE the forward proof must be the RESOLVER's OWN record — the
+     * Registrar's built-in target (which `lookup.resolve` also honors for
+     * fresh names) does not count. On a freshly issued name, call
+     * `setRecord(name, yourAddress)` first, then `setReverse(name)`.
      */
     setReverse(name: string): Promise<Submitted>;
     /** Remove your reverse record on a namespace's resolver. */

package/dist/index.js

@@ -30,7 +30,7 @@
  * before signing. Operations on one instance are serialized so concurrent
  * calls cannot race the account sequence number.
  */
-import { Account, Address, BASE_FEE, Contract, Keypair, Networks, Operation, TransactionBuilder, hash, nativeToScVal, rpc, scValToNative, xdr, } from "@stellar/stellar-sdk";
+import { Account, Address, BASE_FEE, Contract, Keypair, Networks, Operation, TransactionBuilder, hash, nativeToScVal, rpc, scValToNative, } from "@stellar/stellar-sdk";
 // ---------------------------------------------------------------------------
 // Deployments
 // ---------------------------------------------------------------------------
@@ -167,6 +167,11 @@ function concatBytes(...parts) {
     }
     return out;
 }
+/** Browser-safe hex (SDK17: hash()/XDR bytes are Uint8Array, whose toString()
+ *  ignores a radix — and this package forbids a bare `Buffer` in the bundle). */
+function toHex(b) {
+    return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+}
 function namehash(namespace) {
     const labelHash = new Uint8Array(hash(utf8(namespace)));
     return new Uint8Array(hash(concatBytes(new Uint8Array(32), labelHash)));
@@ -322,12 +327,26 @@ export class SoranHolder {
      * and the contract enforces that the name's forward record already
      * resolves to you (ForwardMismatch otherwise): a reverse claim on a name
      * that doesn't point back at you is spoofing, and the chain refuses it.
+     *
+     * NOTE the forward proof must be the RESOLVER's OWN record — the
+     * Registrar's built-in target (which `lookup.resolve` also honors for
+     * fresh names) does not count. On a freshly issued name, call
+     * `setRecord(name, yourAddress)` first, then `setReverse(name)`.
      */
     async setReverse(name) {
         const { namespace } = parseName(name);
         const resolverId = await this.resolverOf(namespace);
         const pub = await this.signer.publicKey();
-        const r = await this.invoke(resolverId, "set_reverse", [addrArg(pub), nativeToScVal(name.toLowerCase(), { type: "string" })], RESOLVER_ERRORS);
+        let r;
+        try {
+            r = await this.invoke(resolverId, "set_reverse", [addrArg(pub), nativeToScVal(name.toLowerCase(), { type: "string" })], RESOLVER_ERRORS);
+        }
+        catch (e) {
+            if (e instanceof HolderError && e.codeName === "ForwardMismatch") {
+                throw new HolderError(`${e.message} — the resolver only accepts its OWN forward record as proof; if this name still resolves via the Registrar's built-in target, call setRecord(name, yourAddress) first, then retry setReverse`, e.contractId, e.fn, e.code, e.codeName, e.txHash);
+            }
+            throw e;
+        }
         return { hash: r.hash, ledger: r.ledger };
     }
     /** Remove your reverse record on a namespace's resolver. */
@@ -473,12 +492,12 @@ export class SoranHolder {
     assertSatisfiableAuth(prepared, pub, contractId, fn) {
         const op = prepared.operations[0];
         for (const entry of op?.auth ?? []) {
-            const cred = entry.credentials();
-            if (cred.switch() !== xdr.SorobanCredentialsType.sorobanCredentialsAddress())
+            const cred = entry.credentials;
+            if (cred.type !== "sorobanCredentialsAddress")
                 continue;
             let required;
             try {
-                required = Address.fromScAddress(cred.address().address()).toString();
+                required = Address.fromScAddress(cred.address.address).toString();
             }
             catch {
                 continue;
@@ -509,21 +528,24 @@ export class SoranHolder {
             .setTimeout(this.timeoutSecs)
             .build();
         let tx = build(await this.sourceAccount(pub, fn));
-        let sim = await this.server.simulateTransaction(tx);
+        // (SDK17/P28) useUpgradedAuth=false keeps legacy V1 SorobanCredentials rather
+        // than CAP-71 address-bound V2 — valid against P27 (pre-vote) and P28 (post),
+        // and keeps assertSatisfiableAuth's `sorobanCredentialsAddress` check exact.
+        let sim = await this.server.simulateTransaction(tx, undefined, undefined, false);
         for (let round = 0; rpc.Api.isSimulationRestore(sim); round++) {
             if (round >= 2) {
                 throw new HolderError(`${fn}: entries still need restoring after ${round} restore transactions — retry later`, contractId, fn);
             }
             await this.restore(sim, pub);
             tx = build(await this.sourceAccount(pub, fn));
-            sim = await this.server.simulateTransaction(tx);
+            sim = await this.server.simulateTransaction(tx, undefined, undefined, false);
         }
         if (rpc.Api.isSimulationError(sim)) {
             throw typedError(contractId, fn, sim.error, errNames);
         }
         const prepared = rpc.assembleTransaction(tx, sim).build();
         this.assertSatisfiableAuth(prepared, pub, contractId, fn);
-        const txHash = prepared.hash().toString("hex");
+        const txHash = toHex(prepared.hash()); // (SDK17) hash() is Uint8Array
         const signed = await this.signEnvelope(prepared.toXDR());
         const envelope = TransactionBuilder.fromXDR(signed, this.passphrase);
         let sent;
@@ -595,18 +617,18 @@ export class SoranHolder {
         try {
             const meta = got.resultMetaXdr;
             const diags = got.diagnosticEventsXdr ??
-                (meta && meta.switch() === 3
-                    ? (meta.v3().sorobanMeta()?.diagnosticEvents() ?? [])
-                    : meta && meta.switch() === 4
-                        ? meta.v4().diagnosticEvents()
+                (meta && meta.type === "v3"
+                    ? (meta.value.sorobanMeta?.diagnosticEvents ?? [])
+                    : meta && meta.type === "v4"
+                        ? meta.value.diagnosticEvents
                         : []);
             outer: for (const d of diags) {
-                const body = d.event().body().v0();
-                for (const v of [...body.topics(), body.data()]) {
-                    if (v.switch() === xdr.ScValType.scvError()) {
-                        const err = v.error();
-                        if (err.switch() === xdr.ScErrorType.sceContract()) {
-                            code = err.contractCode();
+                const body = d.event.body.value;
+                for (const v of [...body.topics, body.data]) {
+                    if (v.type === "scvError") {
+                        const err = v.error;
+                        if (err.type === "sceContract") {
+                            code = err.contractCode;
                             break outer;
                         }
                     }
@@ -618,7 +640,7 @@ export class SoranHolder {
         }
         let resultCode = `tx status ${got.status}`;
         try {
-            resultCode = got.resultXdr?.result().switch().name ?? resultCode;
+            resultCode = got.resultXdr?.result.type ?? resultCode;
         }
         catch {
             /* keep plain status */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorandomains/holder",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Manage your own Soran name on Stellar — records, profile, reverse, primary, and transfers, signed by your key.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,10 +39,10 @@
     "reverse-lookup"
   ],
   "peerDependencies": {
-    "@stellar/stellar-sdk": ">=13 <17"
+    "@stellar/stellar-sdk": ">=17 <18"
   },
   "devDependencies": {
-    "@stellar/stellar-sdk": "^16.2.0",
+    "@stellar/stellar-sdk": "^17.0.1",
     "@types/node": "^22.20.1",
     "esbuild": "^0.25.0",
     "tsx": "^4.19.2",