Contract storage reference

label_hash = H(label_bytes)                         // Allocator keys
ns_node    = H(zero32 || H(namespace_bytes))         // Registry namespace
name_node  = H(ns_node || H(name_label_bytes))       // Registrar / Resolver name

struct Config {
    allocator: Address,
    reserved_root: BytesN<32>,
    registrar_wasm_hash: BytesN<32>,
    resolver_wasm_hash: BytesN<32>,
}
struct Record {
    owner: Address,
    resolver: Option<Address>,
    registrar_status: RegistrarStatus,
    resolver_status: ResolverStatus,
}
enum RegistrarStatus { Clean, Tainted }
enum ResolverStatus { Clean, Tainted }
struct Pending { to: Address, expires: u64 }

struct Config {
    registry: Address,
    governance: Address,
    window: u64,
    bond: i128,
    token: Address,
    max_claim_age: u64,
    reserved_root: BytesN<32>,
}
struct Claim {
    label: Bytes,
    claimant: Address,
    basis: Vec<Bytes>,
    announced_at: u64,
    state: ClaimState,
    obj_objector: Option<Address>,
    obj_basis: Option<Bytes>,
    obj_bond: i128,
    obj_frozen_at: u64,
    rejected_at: u64,
}
enum ClaimState { Announced, Objected, Awarded, Withdrawn, Rejected }
struct PendingUpgrade { wasm_hash: BytesN<32>, eta: u64 }
struct ClaimFeePolicy { token: Address, amount: i128, recipient: Address }
struct ClaimFeeReceipt {
    claimant: Address,
    amount: i128,
    outcome: FeeOutcome,
    refund_amount: i128,
    treasury_amount: i128,
}
enum FeeOutcome { Held, Awarded, Rejected, Withdrawn, Expired, Stuck }

struct Policy {
    reclaimable: bool,
    transferable: bool,
    tradeable: bool,
    default_term_secs: u64,
    trade_fee_bps: u32,
}
struct Config {
    registry: Address,
    namespace_node: BytesN<32>,
    owner: Address,
    treasury: Address,
    treasury_set_by: Address,
    policy: Policy,
    permanent: bool,
}
struct Name {
    holder: Address,
    address: Address,
    expires_at: u64,
    generation: u64,
}
struct PendingTransfer {
    from: Address,
    to: Address,
    generation: u64,
    expires: u64,
}

struct Config { authority: Address, admin: Address, registry: Address }
struct AddrRec { addr: Address, generation: u64 }
struct TextRec { value: String, generation: u64 }
struct RevRec { node: BytesN<32>, name: String, generation: u64 }
struct Provenance { registry: Address, node: BytesN<32> }

// Return/event types, NOT additional stored structs under a Payment key:
enum PaymentMemo { None, Id(u64), Text(String), Hash(BytesN<32>) }
struct Payment { address: Address, memo: PaymentMemo }
struct MuxedPayment { account: Address, id: u64 }
enum PaymentDestination { Direct(Payment), Muxed(MuxedPayment) }

struct Config { registry: Address }
struct PrimaryRec { name: String, ns_node: BytesN<32>, node: BytesN<32> }

struct Config { registry: Address, governance: Address }
struct LegacyCodeHashes { registrar: BytesN<32>, resolver: BytesN<32> }
struct PendingUpgrade { wasm_hash: BytesN<32>, execute_after: u64 }

extend_to = min(3_000_000, storage.max_ttl())
threshold = min(2_500_000, saturating_sub(extend_to, 1))

import { Address, nativeToScVal, rpc, scValToNative, xdr } from "@stellar/stellar-sdk";
import { Soran, DEPLOYMENTS, parseName } from "@sorandomains/lookup";

const deployment = DEPLOYMENTS.testnet;
const client = new Soran({
  network: "testnet", resolutionMode: "universal",
  resolverCacheTtlMs: 0, timeoutMs: 15000,
});
const server = new rpc.Server(deployment.rpcUrl, { timeout: 20 });
const name = "alice.nova"; // Replace with an issued name.
const { namespace } = parseName(name);
const [metadata, context, nsNode, nameNode] = await Promise.all([
  client.nameMetadata(name), client.namespaceMetadata(namespace),
  client.namehash(namespace), client.node(name),
]);
if (!metadata?.active || !context?.resolver) {
  throw new Error("An active name and current Resolver are required.");
}

const symbol = (value: string) => nativeToScVal(value, { type: "symbol" });
const bytes = (value: Uint8Array) => nativeToScVal(value, { type: "bytes" });
const key = (variant: string, ...args: xdr.ScVal[]) =>
  xdr.ScVal.scvVec([symbol(variant), ...args]);
const persistent = (contract: string, value: xdr.ScVal) =>
  xdr.LedgerKey.contractData(new xdr.LedgerKeyContractData({
    contract: new Address(contract).toScAddress(),
    key: value,
    durability: xdr.ContractDataDurability.persistent,
  }));

const keys = {
  namespace: persistent(deployment.registryId, key("Node", bytes(nsNode))),
  address: persistent(context.resolver, key("Addr", bytes(nameNode))),
  paymentText: persistent(context.resolver, key("Text", bytes(nameNode), symbol("payment"))),
  configured: persistent(context.resolver, key("PaymentConfigured", bytes(nameNode),
    nativeToScVal(metadata.generation, { type: "u64" }))),
};
const result = await server.getLedgerEntries(...Object.values(keys));
const entries = new Map(result.entries.map(entry => [entry.key.toXDR("base64"), entry]));
for (const [label, ledgerKey] of Object.entries(keys)) {
  const entry = entries.get(ledgerKey.toXDR("base64"));
  if (!entry) {
    console.log(label, { status: "Not returned; do not infer ownership or memo safety." });
    continue;
  }
  const data = entry.val;
  if (data.type !== "contractData") {
    throw new Error("Unexpected ledger entry type.");
  }
  console.log(label, {
    rawValue: scValToNative(data.contractData.val),
    liveUntilLedger: entry.liveUntilLedgerSeq,
    lastModifiedLedger: entry.lastModifiedLedgerSeq,
  });
}

import { Contract } from "@stellar/stellar-sdk";

const instanceResult = await server.getLedgerEntries(
  new Contract(deployment.registryId).getFootprint(),
);
const instanceEntry = instanceResult.entries[0];
if (!instanceEntry || instanceEntry.val.type !== "contractData" ||
    instanceEntry.val.contractData.val.type !== "scvContractInstance") {
  throw new Error("Registry instance was not returned.");
}
const instance = instanceEntry.val.contractData.val.instance;
for (const entry of instance.storage ?? []) {
  console.log(scValToNative(entry.key), scValToNative(entry.val));
}