@midnames/sdk 0.2.1 → 1.0.1

package/managed/leaf.compact

@@ -1,6 +1,6 @@
-pragma language_version 0.17;
+pragma language_version >= 0.20;
 /// # Unshielded Nameservice
-/// 
+///
 /// Example:
 ///     The `domain.mid` register would be deployed with
 ///         - parent_domain:   "mid"
@@ -20,30 +20,30 @@ pragma language_version 0.17;
 ///         - 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_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_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'>>;
 
 
-export { DomainData, Either, Maybe, CoinInfo }
+export { DomainData, Either, Maybe }
 struct DomainData {
     owner: ZswapCoinPublicKey,
     resolver: ContractAddress
@@ -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<64>,
+    cost_short: Uint<128>,
+    cost_med: Uint<128>,
+    cost_long: Uint<128>,
     kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
 ) {
     DOMAIN_OWNER = ownPublicKey();
@@ -65,68 +67,88 @@ 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'>]>()) {
-            return;
+        if (disclose(kv) != none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
         }
-        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
     }
 }
 
-// =========================================== 
-//                  Circuits                  
-// =========================================== 
+// ===========================================
+//                  Circuits
+// ===========================================
 
 export ledger COIN_COLOR: Bytes<32>;
-export ledger DOMAIN_COST: Uint<64>;
+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(
-    new_target: Either<ZswapCoinPublicKey, ContractAddress>,  
+    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;
+        if (disclose(kv) != none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
         }
-        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): [] {
+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");
 
-    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);
+    // 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 domain_data = DomainData {
+    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.insert(d_owner, default<Set<Bytes<32>>>);
     }
     domains_owned.lookup(d_owner).insert(disclose(domain));
 }
@@ -134,10 +156,9 @@ export circuit buy_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'
 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;
+        if (disclose(kv) != none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
         }
-        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
     }
 }
 
@@ -151,67 +172,78 @@ 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");
 
-    const d_owner = disclose(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.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));
     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): [] {
+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));
     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.insert(disclose(new_owner), default<Set<Bytes<32>>>);
     }
     domains_owned.lookup(disclose(new_owner)).insert(disclose(domain));
 }
@@ -225,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;
 }
 
@@ -238,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;
 }
 
@@ -250,9 +282,9 @@ 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));
 }
 
-*/
+*/