@midnames/sdk 0.1.1 → 0.1.3

package/dist/managed/leaf.compact

@@ -0,0 +1,258 @@
+pragma language_version 0.17;
+/// # Unshielded Nameservice
+/// 
+/// Example:
+///     The `domain.mid` register would be deployed with
+///         - parent_domain:   "mid"
+///         - parent_resolver: "mid" resolver
+///         - target:          arbitrary
+///         - domain:          "domain"
+///         - fields for the `domain.mid` domain.
+///     The `sub.domain.mid` register would be deployed with
+///         - parent_domain:   "domain"
+///         - parent_resolver: "domain" resolver
+///         - target:          arbitrary
+///         - domain:          "sub"
+///         - fields for the `sub.domain.mid` domain.
+///     The `hyper.sub.domain.mid` register would be deployed with
+///         - parent_domain:   "sub"
+///         - parent_resolver: "sub" resolver
+///         - target:          arbitrary
+///         - domain:          "hyper"
+///         - fields for the `hyper.sub.domain.mid` domain.
+///         
+/// 
+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_RESOLVER: ContractAddress;
+export sealed ledger DOMAIN: Maybe<Opaque<'string'>>;
+
+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>;
+
+// Set of domains saved here owned by address.
+export ledger domains_owned: Map<ZswapCoinPublicKey, Set<Opaque<'string'>>>;
+
+export ledger fields: Map<Opaque<'string'>, Opaque<'string'>>;
+
+
+export { DomainData, Either, Maybe, CoinInfo }
+struct DomainData {
+    owner: ZswapCoinPublicKey,
+    resolver: ContractAddress
+}
+
+
+constructor(
+    parent_domain: Maybe<Opaque<'string'>>,
+    parent_resolver: ContractAddress,
+    target: Either<ZswapCoinPublicKey, ContractAddress>,
+    domain: Maybe<Opaque<'string'>>, 
+    coin_color: Bytes<32>,
+    domain_cost: Uint<64>,
+    kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
+) {
+    DOMAIN_OWNER = ownPublicKey();
+    PARENT_DOMAIN = disclose(parent_domain);
+    PARENT_RESOLVER = disclose(parent_resolver);
+    DOMAIN_TARGET = disclose(target);
+    DOMAIN = disclose(domain);
+    COIN_COLOR = disclose(coin_color);
+    DOMAIN_COST = disclose(domain_cost);
+    for (const kv of kvs) {
+        if (disclose(kv) == none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            return;
+        }
+        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
+    }
+}
+
+// =========================================== 
+//                  Circuits                  
+// =========================================== 
+
+export ledger COIN_COLOR: Bytes<32>;
+export ledger DOMAIN_COST: Uint<64>;
+
+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>) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
+    DOMAIN_COST = disclose(c);
+}
+
+export circuit update_target_and_fields(
+    new_target: Either<ZswapCoinPublicKey, ContractAddress>,  
+    kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
+) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    for (const kv of kvs) {
+        if (disclose(kv) == none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            return;
+        }
+        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
+    }
+        DOMAIN_TARGET = disclose(new_target);
+
+}
+
+export circuit buy_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'>, resolver: ContractAddress, payment: CoinInfo): [] {
+    assert(!domains.member(disclose(domain)), "Domain already exists");
+
+    const d_payment = disclose(payment);
+    assert(d_payment.value == DOMAIN_COST, "Wrong amount");
+    assert(d_payment.color == COIN_COLOR, "Wrong coin");
+    receive(d_payment);
+    sendImmediate(d_payment, left<ZswapCoinPublicKey, ContractAddress>(DOMAIN_OWNER), DOMAIN_COST);
+    
+    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
+    if (!domains_owned.member(d_owner)) {
+        domains_owned.insert(d_owner, default<Set<Opaque<'string'>>>);
+    }
+    domains_owned.lookup(d_owner).insert(disclose(domain));
+}
+
+export circuit add_multiple_fields(kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    for (const kv of kvs) {
+        if (disclose(kv) == none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            return;
+        }
+        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
+    }
+}
+
+export circuit insert_field(k: Opaque<'string'>, v: Opaque<'string'>) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    fields.insert(disclose(k),disclose(v));
+}
+
+export circuit clear_field(k: Opaque<'string'>): [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    fields.remove(disclose(k));
+}
+
+export circuit clear_all_fields(domain: Opaque<'string'>): [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    fields.resetToDefault();
+}
+
+export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'>, resolver: ContractAddress): [] {
+    assert(!domains.member(disclose(domain)), "Domain already exists");
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+
+    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
+    if (!domains_owned.member(d_owner)) {
+        domains_owned.insert(d_owner, default<Set<Opaque<'string'>>>);
+    }
+    domains_owned.lookup(d_owner).insert(disclose(domain));
+}
+
+export circuit set_resolver(domain: Opaque<'string'>, resolver: ContractAddress): [] {
+    assert(domains.member(disclose(domain)), "Domain does not exist");
+    
+    const current_data = domains.lookup(disclose(domain));
+    assert(current_data.owner == ownPublicKey(), "Not the domain owner");
+    
+    const new_data = DomainData {
+        current_data.owner,
+        disclose(resolver)
+    };
+    
+    domains.insert(disclose(domain), disclose(new_data));
+}
+
+export circuit update_domain_target(new_target: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the contract owner");
+    
+    DOMAIN_TARGET = disclose(new_target);
+}
+
+export circuit transfer_domain(domain: Opaque<'string'>, new_owner: ZswapCoinPublicKey): [] {
+    assert(domains.member(disclose(domain)), "Domain does not exist");
+    
+    const current_data = domains.lookup(disclose(domain));
+    assert(current_data.owner == ownPublicKey(), "Not the domain owner");
+    
+    const new_data = DomainData {
+        disclose(new_owner),
+        current_data.resolver
+    };
+    
+    domains.insert(disclose(domain), disclose(new_data));
+    
+    // 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.lookup(disclose(new_owner)).insert(disclose(domain));
+}
+
+
+export circuit change_owner(new_owner: ZswapCoinPublicKey) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the contract owner");
+    DOMAIN_OWNER = disclose(new_owner);
+}
+
+
+/*
+Read only, but not pure, so let's not use those
+export circuit resolve(domain: Opaque<'string'>): DomainData {
+    assert(domains.member(disclose(domain)), "Domain does not exist");
+    return domains.lookup(disclose(domain));
+}
+
+export circuit get_parent_domain(): Maybe<Opaque<'string'>> {
+    return PARENT_DOMAIN;
+}
+
+export circuit get_contract_owner(): ZswapCoinPublicKey {
+    return DOMAIN_OWNER;
+}
+
+export circuit get_domain(): Maybe<Opaque<'string'>> {
+    return DOMAIN;
+}
+
+export circuit get_domain_target(): Either<ZswapCoinPublicKey, ContractAddress> {
+    return DOMAIN_TARGET;
+}
+
+export circuit get_parent_resolver(): ContractAddress {
+    return PARENT_RESOLVER;
+}
+
+export circuit addr_owns_domain(addr: ZswapCoinPublicKey, domain: Opaque<'string'>): Boolean {
+    assert(domains_owned.member(disclose(addr)), "Address does not own domains in this register");
+    return domains_owned.lookup(disclose(addr)).member(disclose(domain));
+}
+
+*/