@midnames/sdk 1.0.0 → 1.0.1

package/dist/core.d.ts

@@ -2,7 +2,8 @@ import type { PublicDataProvider } from "@midnight-ntwrk/midnight-js-types";
 import { type DomainData } from "../managed/index.js";
 import type { DomainInfo, DomainSettings, DomainProfileData } from "./types.js";
 import { Result } from "./results.js";
-export declare const TESTNET_TLD_ADDRESS = "b00a62ce58c108b86af4670e662fa240844e0206c54009a539c64155d62e6b6a";
+export declare const TESTNET_TLD_ADDRESS: string;
+export declare const PREVIEW_TLD_ADDRESS: string;
 export declare function queryContractStateSafely(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<any>>;
 export declare function resolveDomain(domain: string, options?: {
     provider?: PublicDataProvider;

package/dist/core.js

@@ -2,19 +2,15 @@ import { getNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 import { ShieldedCoinPublicKey } from "@midnight-ntwrk/wallet-sdk-address-format";
 import { ledger } from "./managed/index.js";
 import { formatContractAddress, bytesToHex } from "./utils/address.js";
-import { normalizeDomain, parseFullDomain, DEFAULT_TLD, isTLD } from "./utils/domain.js";
+import { normalizeDomain, parseFullDomain, DEFAULT_TLD, isTLD, domainToKey, keyToDomain } from "./utils/domain.js";
 import { success, failure, wrapAsync } from "./results.js";
 import { NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, } from "./errors.js";
-import { getDefaultProvider } from "./provider.js";
-export const TESTNET_TLD_ADDRESS = "b00a62ce58c108b86af4670e662fa240844e0206c54009a539c64155d62e6b6a";
+import { getDefaultProvider, getNetworkConfig, NETWORK_REGISTRY } from "./provider.js";
+export const TESTNET_TLD_ADDRESS = NETWORK_REGISTRY.preprod.tldAddress;
+export const PREVIEW_TLD_ADDRESS = NETWORK_REGISTRY.preview.tldAddress;
 function getDefaultTldAddress() {
     const currentNetwork = getNetworkId();
-    switch (currentNetwork) {
-        case "preprod":
-            return TESTNET_TLD_ADDRESS;
-        default:
-            throw new Error("Provide an address to use the resolver on a Standalone Network.");
-    }
+    return getNetworkConfig(currentNetwork).tldAddress;
 }
 function getTargetFromLedger(contractLedger) {
     const target = contractLedger.DOMAIN_TARGET;
@@ -61,10 +57,10 @@ async function traverseDomainHierarchy(publicDataProvider, fullDomain, returnFin
                 return failure(contractStateResult.error);
             }
             const contractLedger = ledger(contractStateResult.data.data);
-            if (!contractLedger.domains.member(part)) {
+            if (!contractLedger.domains.member(domainToKey(part).key)) {
                 return failure(new DomainNotFoundError(`${part} in ${fullDomain}`));
             }
-            const domainData = contractLedger.domains.lookup(part);
+            const domainData = contractLedger.domains.lookup(domainToKey(part).key);
             const resolverBytes = domainData.resolver.bytes;
             // Use raw hex for queryContractState (no 0200 prefix)
             currentResolver = bytesToHex(resolverBytes);
@@ -109,10 +105,10 @@ async function getDomainInfoInContract(contractAddress, domainName, options = {}
         if (!contractStateResult.success)
             return failure(contractStateResult.error);
         const contractLedger = ledger(contractStateResult.data.data);
-        if (!contractLedger.domains.member(domainName)) {
+        if (!contractLedger.domains.member(domainToKey(domainName).key)) {
             return failure(new DomainNotFoundError(domainName));
         }
-        const domainData = contractLedger.domains.lookup(domainName);
+        const domainData = contractLedger.domains.lookup(domainToKey(domainName).key);
         const ownerCoinPublicKey = new ShieldedCoinPublicKey(Buffer.from(domainData.owner.bytes));
         const ownerAddress = ShieldedCoinPublicKey.codec
             .encode(getNetworkId(), ownerCoinPublicKey)
@@ -189,7 +185,11 @@ export async function getDomainSettings(fullDomain, options = {}) {
                 return failure(ledgerResult.error);
             return success({
                 coinColor: ledgerResult.data.COIN_COLOR,
-                domainCost: ledgerResult.data.DOMAIN_COST,
+                costs: {
+                    short: ledgerResult.data.COST_SHORT,
+                    medium: ledgerResult.data.COST_MED,
+                    long: ledgerResult.data.COST_LONG,
+                },
             });
         }
         // Normal case: subdomain — resolve via getDomainInfo
@@ -202,7 +202,11 @@ export async function getDomainSettings(fullDomain, options = {}) {
             return failure(ledgerResult.error);
         return success({
             coinColor: ledgerResult.data.COIN_COLOR,
-            domainCost: ledgerResult.data.DOMAIN_COST,
+            costs: {
+                short: ledgerResult.data.COST_SHORT,
+                medium: ledgerResult.data.COST_MED,
+                long: ledgerResult.data.COST_LONG,
+            },
         });
     }
     catch (error) {
@@ -229,7 +233,11 @@ export async function getDomainProfile(fullDomain, options = {}) {
                     fields.set(key, value);
                 const settings = {
                     coinColor: ledgerResult.data.COIN_COLOR,
-                    domainCost: ledgerResult.data.DOMAIN_COST,
+                    costs: {
+                        short: ledgerResult.data.COST_SHORT,
+                        medium: ledgerResult.data.COST_MED,
+                        long: ledgerResult.data.COST_LONG,
+                    },
                 };
                 return success({
                     fullDomain: normalized,
@@ -264,7 +272,7 @@ export async function getSubdomains(fullDomain, options = {}) {
             return failure(ledgerResult.error);
         const subdomains = new Map();
         for (const [name, data] of ledgerResult.data.domains) {
-            subdomains.set(name, data);
+            subdomains.set(keyToDomain(name), data);
         }
         return success(subdomains);
     }

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export * from './utils/domain.js';
 export * from './utils/address.js';
 export * from './core.js';
 export * from './provider.js';
-export * from './operations.js';
+export { buildKvs, insertField, clearField, clearAllFields, addMultipleFields, updateDomainTarget, updateDomainColor, updateDomainCosts, transferDomainOwnership, setDomainResolver, registerDomainFor, buyDomainFor, changeDomainOwner, } from './operations.js';
 export * from './results.js';
 export * from './errors.js';
 export * from './controller-types.js';
+export { resolveImageUrl } from './utils/imageResolver.js';

package/dist/index.js

@@ -3,7 +3,8 @@ export * from './utils/domain.js';
 export * from './utils/address.js';
 export * from './core.js';
 export * from './provider.js';
-export * from './operations.js';
+export { buildKvs, insertField, clearField, clearAllFields, addMultipleFields, updateDomainTarget, updateDomainColor, updateDomainCosts, transferDomainOwnership, setDomainResolver, registerDomainFor, buyDomainFor, changeDomainOwner, } from './operations.js';
 export * from './results.js';
 export * from './errors.js';
 export * from './controller-types.js';
+export { resolveImageUrl } from './utils/imageResolver.js';

package/dist/managed/index.d.ts

@@ -1,2 +1,3 @@
-export * as Leaf from "./managed/leaf/contract";
-export { type DomainData, type Either, type Maybe, type Witnesses, type Ledger, ledger, Contract } from "./managed/leaf/contract";
+export * as Leaf from "./managed/leaf/contract/index.js";
+export { type DomainData, type Either, type Maybe, type Witnesses, type Ledger, ledger, Contract } from "./managed/leaf/contract/index.js";
+export { domainToKey, keyToDomain } from "./utils.js";

package/dist/managed/index.js

@@ -1,16 +1,4 @@
-/* export * as Registry from "./managed/registry/contract/index.cjs";
-export * as Resolver from "./managed/resolver/contract/index.cjs";
-export * as UnifiedDomain from "./managed/unified-domain/contract/index.cjs";
-export * as NS from "./managed/ns/contract/index.cjs";
-export * from "./witnesses.js";
-export { type RegistryRecord } from "./managed/registry/contract/index.cjs";
-export { type ResolutionData } from "./managed/resolver/contract/index.cjs";
-export { type DomainData as UnifiedDomainData } from "./managed/unified-domain/contract/index.cjs";
-export {
-  type DomainData,
-  type DomainReference,
-} from "./managed/ns/contract/index.cjs";
- */
 export * as Leaf from "./managed/leaf/contract/index.js";
 export { ledger, Contract } from "./managed/leaf/contract/index.js";
+export { domainToKey, keyToDomain } from "./utils.js";
 //# sourceMappingURL=index.js.map

package/dist/managed/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAML,MAAM,EACN,QAAQ,EACT,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAML,MAAM,EACN,QAAQ,EACT,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/managed/leaf.compact

@@ -1,4 +1,4 @@
-pragma language_version 0.20;
+pragma language_version >= 0.20;
 /// # Unshielded Nameservice
 ///
 /// Example:
@@ -26,19 +26,19 @@ import CompactStandardLibrary;
 
 // This is sealed. If the domain is sold in the parent contract
 // The new owner should deploy a new resolver.
-export sealed ledger PARENT_DOMAIN: Maybe<Opaque<'string'>>;
+export sealed ledger PARENT_DOMAIN: Maybe<Bytes<32>>;
 export sealed ledger PARENT_RESOLVER: ContractAddress;
-export sealed ledger DOMAIN: Maybe<Opaque<'string'>>;
+export sealed ledger DOMAIN: Maybe<Bytes<32>>;
 
 export ledger DOMAIN_OWNER: ZswapCoinPublicKey;
 // This domain could target either a wallet or a contract
 export ledger DOMAIN_TARGET: Either<ZswapCoinPublicKey, ContractAddress>;
 
 // Map<domain, (owner, resolver)>.
-export ledger domains: Map<Opaque<'string'>, DomainData>;
+export ledger domains: Map<Bytes<32>, DomainData>;
 
 // Set of domains saved here owned by address.
-export ledger domains_owned: Map<ZswapCoinPublicKey, Set<Opaque<'string'>>>;
+export ledger domains_owned: Map<ZswapCoinPublicKey, Set<Bytes<32>>>;
 
 export ledger fields: Map<Opaque<'string'>, Opaque<'string'>>;
 
@@ -51,12 +51,14 @@ struct DomainData {
 
 
 constructor(
-    parent_domain: Maybe<Opaque<'string'>>,
+    parent_domain: Maybe<Bytes<32>>,
     parent_resolver: ContractAddress,
     target: Either<ZswapCoinPublicKey, ContractAddress>,
-    domain: Maybe<Opaque<'string'>>,
+    domain: Maybe<Bytes<32>>,
     coin_color: Bytes<32>,
-    domain_cost: Uint<128>,
+    cost_short: Uint<128>,
+    cost_med: Uint<128>,
+    cost_long: Uint<128>,
     kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
 ) {
     DOMAIN_OWNER = ownPublicKey();
@@ -65,7 +67,9 @@ constructor(
     DOMAIN_TARGET = disclose(target);
     DOMAIN = disclose(domain);
     COIN_COLOR = disclose(coin_color);
-    DOMAIN_COST = disclose(domain_cost);
+    COST_SHORT = disclose(cost_short);
+    COST_MED = disclose(cost_med);
+    COST_LONG = disclose(cost_long);
     for (const kv of kvs) {
         if (disclose(kv) != none<[Opaque<'string'>, Opaque<'string'>]>()) {
             fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
@@ -78,16 +82,20 @@ constructor(
 // ===========================================
 
 export ledger COIN_COLOR: Bytes<32>;
-export ledger DOMAIN_COST: Uint<128>;
+export ledger COST_SHORT: Uint<128>;   // ≤3 chars
+export ledger COST_MED: Uint<128>;     // 4 chars
+export ledger COST_LONG: Uint<128>;    // 5+ chars
 
-export circuit update_color(c: Bytes<32>) : [] {
+export circuit update_color(c: Bytes<32>): [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
     COIN_COLOR = disclose(c);
 }
 
-export circuit update_cost(c: Uint<64>) : [] {
+export circuit update_costs(cost_short: Uint<128>, cost_med: Uint<128>, cost_long: Uint<128>): [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
-    DOMAIN_COST = disclose(c);
+    COST_SHORT = disclose(cost_short);
+    COST_MED = disclose(cost_med);
+    COST_LONG = disclose(cost_long);
 }
 
 export circuit update_target_and_fields(
@@ -104,21 +112,43 @@ export circuit update_target_and_fields(
 
 }
 
-export circuit buy_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'>, resolver: ContractAddress): [] {
+export circuit buy_domain_for(owner: ZswapCoinPublicKey, domain: Bytes<32>, len: Uint<32>, resolver: ContractAddress): [] {
+    assert(len <= 32, "len must be <= 32");
+    assert(len >= 1, "domain name cannot be empty");
+
+    const valid = fold(
+      (acc: Boolean, byte: Uint<8>, i: Uint<8>): Boolean =>
+        acc && (((i as Uint<32>) < len) || (byte == 255)),
+      true, domain,
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
+    );
+    assert(valid, "Invalid domain key padding");
+
     assert(!domains.member(disclose(domain)), "Domain already exists");
 
-    // receiveUnshielded(COIN_COLOR, DOMAIN_COST);
-    // sendUnshielded(COIN_COLOR, DOMAIN_COST, right<ContractAddress, UserAddress>(UserAddress { bytes: DOMAIN_OWNER.bytes }));
+    // pricing: shared color, per-tier cost
+    const d_len = disclose(len);
+    if (d_len <= 3) {
+        receiveUnshielded(COIN_COLOR, COST_SHORT);
+        sendUnshielded(COIN_COLOR, COST_SHORT, right<ContractAddress, UserAddress>(UserAddress { bytes: DOMAIN_OWNER.bytes }));
+    } else if (d_len == 4) {
+        receiveUnshielded(COIN_COLOR, COST_MED);
+        sendUnshielded(COIN_COLOR, COST_MED, right<ContractAddress, UserAddress>(UserAddress { bytes: DOMAIN_OWNER.bytes }));
+    } else {
+        receiveUnshielded(COIN_COLOR, COST_LONG);
+        sendUnshielded(COIN_COLOR, COST_LONG, right<ContractAddress, UserAddress>(UserAddress { bytes: DOMAIN_OWNER.bytes }));
+    }
 
     const d_owner = disclose(owner);
         const domain_data = DomainData {
         d_owner,
         disclose(resolver)
     };
-        domains.insert(disclose(domain), disclose(domain_data));
-        // Track domains owned by address
+    domains.insert(disclose(domain), disclose(domain_data));
+    
+    // Track domains owned by address
     if (!domains_owned.member(d_owner)) {
-        domains_owned.insert(d_owner, default<Set<Opaque<'string'>>>);
+        domains_owned.insert(d_owner, default<Set<Bytes<32>>>);
     }
     domains_owned.lookup(d_owner).insert(disclose(domain));
 }
@@ -142,12 +172,23 @@ export circuit clear_field(k: Opaque<'string'>): [] {
     fields.remove(disclose(k));
 }
 
-export circuit clear_all_fields(domain: Opaque<'string'>): [] {
+export circuit clear_all_fields(): [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
     fields.resetToDefault();
 }
 
-export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'>, resolver: ContractAddress): [] {
+export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Bytes<32>, len: Uint<32>, resolver: ContractAddress): [] {
+    assert(len <= 32, "len must be <= 32");
+    assert(len >= 1, "domain name cannot be empty");
+
+    const valid = fold(
+      (acc: Boolean, byte: Uint<8>, i: Uint<8>): Boolean =>
+        acc && (((i as Uint<32>) < len) || (byte == 255)),
+      true, domain,
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
+    );
+    assert(valid, "Invalid domain key padding");
+
     assert(!domains.member(disclose(domain)), "Domain already exists");
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
 
@@ -161,12 +202,12 @@ export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'st
 
     // Track domains owned by address
     if (!domains_owned.member(d_owner)) {
-        domains_owned.insert(d_owner, default<Set<Opaque<'string'>>>);
+        domains_owned.insert(d_owner, default<Set<Bytes<32>>>);
     }
     domains_owned.lookup(d_owner).insert(disclose(domain));
 }
 
-export circuit set_resolver(domain: Opaque<'string'>, resolver: ContractAddress): [] {
+export circuit set_resolver(domain: Bytes<32>, resolver: ContractAddress): [] {
     assert(domains.member(disclose(domain)), "Domain does not exist");
 
     const current_data = domains.lookup(disclose(domain));
@@ -186,7 +227,7 @@ export circuit update_domain_target(new_target: Either<ZswapCoinPublicKey, Contr
     DOMAIN_TARGET = disclose(new_target);
 }
 
-export circuit transfer_domain(domain: Opaque<'string'>, new_owner: ZswapCoinPublicKey): [] {
+export circuit transfer_domain(domain: Bytes<32>, new_owner: ZswapCoinPublicKey): [] {
     assert(domains.member(disclose(domain)), "Domain does not exist");
 
     const current_data = domains.lookup(disclose(domain));
@@ -202,7 +243,7 @@ export circuit transfer_domain(domain: Opaque<'string'>, new_owner: ZswapCoinPub
     // Update ownership tracking
     domains_owned.lookup(ownPublicKey()).remove(disclose(domain));
     if (!domains_owned.member(disclose(new_owner))) {
-        domains_owned.insert(disclose(new_owner), default<Set<Opaque<'string'>>>);
+        domains_owned.insert(disclose(new_owner), default<Set<Bytes<32>>>);
     }
     domains_owned.lookup(disclose(new_owner)).insert(disclose(domain));
 }
@@ -216,12 +257,12 @@ export circuit change_owner(new_owner: ZswapCoinPublicKey) : [] {
 
 /*
 Read only, but not pure, so let's not use those
-export circuit resolve(domain: Opaque<'string'>): DomainData {
+export circuit resolve(domain: Bytes<32>): DomainData {
     assert(domains.member(disclose(domain)), "Domain does not exist");
     return domains.lookup(disclose(domain));
 }
 
-export circuit get_parent_domain(): Maybe<Opaque<'string'>> {
+export circuit get_parent_domain(): Maybe<Bytes<32>> {
     return PARENT_DOMAIN;
 }
 
@@ -229,7 +270,7 @@ export circuit get_contract_owner(): ZswapCoinPublicKey {
     return DOMAIN_OWNER;
 }
 
-export circuit get_domain(): Maybe<Opaque<'string'>> {
+export circuit get_domain(): Maybe<Bytes<32>> {
     return DOMAIN;
 }
 
@@ -241,7 +282,7 @@ export circuit get_parent_resolver(): ContractAddress {
     return PARENT_RESOLVER;
 }
 
-export circuit addr_owns_domain(addr: ZswapCoinPublicKey, domain: Opaque<'string'>): Boolean {
+export circuit addr_owns_domain(addr: ZswapCoinPublicKey, domain: Bytes<32>): Boolean {
     assert(domains_owned.member(disclose(addr)), "Address does not own domains in this register");
     return domains_owned.lookup(disclose(addr)).member(disclose(domain));
 }

package/dist/managed/managed/leaf/contract/index.d.ts

@@ -13,14 +13,18 @@ export type Witnesses<PS> = {
 
 export type ImpureCircuits<PS> = {
   update_color(context: __compactRuntime.CircuitContext<PS>, c_0: Uint8Array): __compactRuntime.CircuitResults<PS, []>;
-  update_cost(context: __compactRuntime.CircuitContext<PS>, c_0: bigint): __compactRuntime.CircuitResults<PS, []>;
+  update_costs(context: __compactRuntime.CircuitContext<PS>,
+               cost_short_0: bigint,
+               cost_med_0: bigint,
+               cost_long_0: bigint): __compactRuntime.CircuitResults<PS, []>;
   update_target_and_fields(context: __compactRuntime.CircuitContext<PS>,
                            new_target_0: Either<{ bytes: Uint8Array },
                                                 { bytes: Uint8Array }>,
                            kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
   buy_domain_for(context: __compactRuntime.CircuitContext<PS>,
                  owner_0: { bytes: Uint8Array },
-                 domain_0: string,
+                 domain_0: Uint8Array,
+                 len_0: bigint,
                  resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   add_multiple_fields(context: __compactRuntime.CircuitContext<PS>,
                       kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
@@ -28,20 +32,60 @@ export type ImpureCircuits<PS> = {
                k_0: string,
                v_0: string): __compactRuntime.CircuitResults<PS, []>;
   clear_field(context: __compactRuntime.CircuitContext<PS>, k_0: string): __compactRuntime.CircuitResults<PS, []>;
-  clear_all_fields(context: __compactRuntime.CircuitContext<PS>,
-                   domain_0: string): __compactRuntime.CircuitResults<PS, []>;
+  clear_all_fields(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, []>;
   register_domain_for(context: __compactRuntime.CircuitContext<PS>,
                       owner_0: { bytes: Uint8Array },
-                      domain_0: string,
+                      domain_0: Uint8Array,
+                      len_0: bigint,
                       resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   set_resolver(context: __compactRuntime.CircuitContext<PS>,
-               domain_0: string,
+               domain_0: Uint8Array,
                resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   update_domain_target(context: __compactRuntime.CircuitContext<PS>,
                        new_target_0: Either<{ bytes: Uint8Array },
                                             { bytes: Uint8Array }>): __compactRuntime.CircuitResults<PS, []>;
   transfer_domain(context: __compactRuntime.CircuitContext<PS>,
-                  domain_0: string,
+                  domain_0: Uint8Array,
+                  new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  change_owner(context: __compactRuntime.CircuitContext<PS>,
+               new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+}
+
+export type ProvableCircuits<PS> = {
+  update_color(context: __compactRuntime.CircuitContext<PS>, c_0: Uint8Array): __compactRuntime.CircuitResults<PS, []>;
+  update_costs(context: __compactRuntime.CircuitContext<PS>,
+               cost_short_0: bigint,
+               cost_med_0: bigint,
+               cost_long_0: bigint): __compactRuntime.CircuitResults<PS, []>;
+  update_target_and_fields(context: __compactRuntime.CircuitContext<PS>,
+                           new_target_0: Either<{ bytes: Uint8Array },
+                                                { bytes: Uint8Array }>,
+                           kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
+  buy_domain_for(context: __compactRuntime.CircuitContext<PS>,
+                 owner_0: { bytes: Uint8Array },
+                 domain_0: Uint8Array,
+                 len_0: bigint,
+                 resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  add_multiple_fields(context: __compactRuntime.CircuitContext<PS>,
+                      kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
+  insert_field(context: __compactRuntime.CircuitContext<PS>,
+               k_0: string,
+               v_0: string): __compactRuntime.CircuitResults<PS, []>;
+  clear_field(context: __compactRuntime.CircuitContext<PS>, k_0: string): __compactRuntime.CircuitResults<PS, []>;
+  clear_all_fields(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, []>;
+  register_domain_for(context: __compactRuntime.CircuitContext<PS>,
+                      owner_0: { bytes: Uint8Array },
+                      domain_0: Uint8Array,
+                      len_0: bigint,
+                      resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  set_resolver(context: __compactRuntime.CircuitContext<PS>,
+               domain_0: Uint8Array,
+               resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  update_domain_target(context: __compactRuntime.CircuitContext<PS>,
+                       new_target_0: Either<{ bytes: Uint8Array },
+                                            { bytes: Uint8Array }>): __compactRuntime.CircuitResults<PS, []>;
+  transfer_domain(context: __compactRuntime.CircuitContext<PS>,
+                  domain_0: Uint8Array,
                   new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   change_owner(context: __compactRuntime.CircuitContext<PS>,
                new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
@@ -52,14 +96,18 @@ export type PureCircuits = {
 
 export type Circuits<PS> = {
   update_color(context: __compactRuntime.CircuitContext<PS>, c_0: Uint8Array): __compactRuntime.CircuitResults<PS, []>;
-  update_cost(context: __compactRuntime.CircuitContext<PS>, c_0: bigint): __compactRuntime.CircuitResults<PS, []>;
+  update_costs(context: __compactRuntime.CircuitContext<PS>,
+               cost_short_0: bigint,
+               cost_med_0: bigint,
+               cost_long_0: bigint): __compactRuntime.CircuitResults<PS, []>;
   update_target_and_fields(context: __compactRuntime.CircuitContext<PS>,
                            new_target_0: Either<{ bytes: Uint8Array },
                                                 { bytes: Uint8Array }>,
                            kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
   buy_domain_for(context: __compactRuntime.CircuitContext<PS>,
                  owner_0: { bytes: Uint8Array },
-                 domain_0: string,
+                 domain_0: Uint8Array,
+                 len_0: bigint,
                  resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   add_multiple_fields(context: __compactRuntime.CircuitContext<PS>,
                       kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
@@ -67,37 +115,37 @@ export type Circuits<PS> = {
                k_0: string,
                v_0: string): __compactRuntime.CircuitResults<PS, []>;
   clear_field(context: __compactRuntime.CircuitContext<PS>, k_0: string): __compactRuntime.CircuitResults<PS, []>;
-  clear_all_fields(context: __compactRuntime.CircuitContext<PS>,
-                   domain_0: string): __compactRuntime.CircuitResults<PS, []>;
+  clear_all_fields(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, []>;
   register_domain_for(context: __compactRuntime.CircuitContext<PS>,
                       owner_0: { bytes: Uint8Array },
-                      domain_0: string,
+                      domain_0: Uint8Array,
+                      len_0: bigint,
                       resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   set_resolver(context: __compactRuntime.CircuitContext<PS>,
-               domain_0: string,
+               domain_0: Uint8Array,
                resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   update_domain_target(context: __compactRuntime.CircuitContext<PS>,
                        new_target_0: Either<{ bytes: Uint8Array },
                                             { bytes: Uint8Array }>): __compactRuntime.CircuitResults<PS, []>;
   transfer_domain(context: __compactRuntime.CircuitContext<PS>,
-                  domain_0: string,
+                  domain_0: Uint8Array,
                   new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
   change_owner(context: __compactRuntime.CircuitContext<PS>,
                new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
 }
 
 export type Ledger = {
-  readonly PARENT_DOMAIN: Maybe<string>;
+  readonly PARENT_DOMAIN: Maybe<Uint8Array>;
   readonly PARENT_RESOLVER: { bytes: Uint8Array };
-  readonly DOMAIN: Maybe<string>;
+  readonly DOMAIN: Maybe<Uint8Array>;
   readonly DOMAIN_OWNER: { bytes: Uint8Array };
   readonly DOMAIN_TARGET: Either<{ bytes: Uint8Array }, { bytes: Uint8Array }>;
   domains: {
     isEmpty(): boolean;
     size(): bigint;
-    member(key_0: string): boolean;
-    lookup(key_0: string): DomainData;
-    [Symbol.iterator](): Iterator<[string, DomainData]>
+    member(key_0: Uint8Array): boolean;
+    lookup(key_0: Uint8Array): DomainData;
+    [Symbol.iterator](): Iterator<[Uint8Array, DomainData]>
   };
   domains_owned: {
     isEmpty(): boolean;
@@ -106,8 +154,8 @@ export type Ledger = {
     lookup(key_0: { bytes: Uint8Array }): {
       isEmpty(): boolean;
       size(): bigint;
-      member(elem_0: string): boolean;
-      [Symbol.iterator](): Iterator<string>
+      member(elem_0: Uint8Array): boolean;
+      [Symbol.iterator](): Iterator<Uint8Array>
     }
   };
   fields: {
@@ -118,7 +166,9 @@ export type Ledger = {
     [Symbol.iterator](): Iterator<[string, string]>
   };
   readonly COIN_COLOR: Uint8Array;
-  readonly DOMAIN_COST: bigint;
+  readonly COST_SHORT: bigint;
+  readonly COST_MED: bigint;
+  readonly COST_LONG: bigint;
 }
 
 export type ContractReferenceLocations = any;
@@ -129,14 +179,17 @@ export declare class Contract<PS = any, W extends Witnesses<PS> = Witnesses<PS>>
   witnesses: W;
   circuits: Circuits<PS>;
   impureCircuits: ImpureCircuits<PS>;
+  provableCircuits: ProvableCircuits<PS>;
   constructor(witnesses: W);
   initialState(context: __compactRuntime.ConstructorContext<PS>,
-               parent_domain_0: Maybe<string>,
+               parent_domain_0: Maybe<Uint8Array>,
                parent_resolver_0: { bytes: Uint8Array },
                target_0: Either<{ bytes: Uint8Array }, { bytes: Uint8Array }>,
-               domain_0: Maybe<string>,
+               domain_0: Maybe<Uint8Array>,
                coin_color_0: Uint8Array,
-               domain_cost_0: bigint,
+               cost_short_0: bigint,
+               cost_med_0: bigint,
+               cost_long_0: bigint,
                kvs_0: Maybe<[string, string]>[]): __compactRuntime.ConstructorResult<PS>;
 }