@midnames/sdk 0.2.0 → 1.0.0

package/dist/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,8 +20,8 @@ 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
@@ -30,8 +30,8 @@ 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_OWNER: ZswapCoinPublicKey;
+// This domain could target either a wallet or a contract
 export ledger DOMAIN_TARGET: Either<ZswapCoinPublicKey, ContractAddress>;
 
 // Map<domain, (owner, resolver)>.
@@ -43,7 +43,7 @@ export ledger domains_owned: Map<ZswapCoinPublicKey, Set<Opaque<'string'>>>;
 export ledger fields: Map<Opaque<'string'>, Opaque<'string'>>;
 
 
-export { DomainData, Either, Maybe, CoinInfo }
+export { DomainData, Either, Maybe }
 struct DomainData {
     owner: ZswapCoinPublicKey,
     resolver: ContractAddress
@@ -54,9 +54,9 @@ constructor(
     parent_domain: Maybe<Opaque<'string'>>,
     parent_resolver: ContractAddress,
     target: Either<ZswapCoinPublicKey, ContractAddress>,
-    domain: Maybe<Opaque<'string'>>, 
+    domain: Maybe<Opaque<'string'>>,
     coin_color: Bytes<32>,
-    domain_cost: Uint<64>,
+    domain_cost: Uint<128>,
     kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
 ) {
     DOMAIN_OWNER = ownPublicKey();
@@ -67,19 +67,18 @@ constructor(
     COIN_COLOR = disclose(coin_color);
     DOMAIN_COST = disclose(domain_cost);
     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 DOMAIN_COST: Uint<128>;
 
 export circuit update_color(c: Bytes<32>) : [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
@@ -92,39 +91,32 @@ export circuit update_cost(c: Uint<64>) : [] {
 }
 
 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: Opaque<'string'>, resolver: ContractAddress): [] {
     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);
+    // receiveUnshielded(COIN_COLOR, DOMAIN_COST);
+    // sendUnshielded(COIN_COLOR, DOMAIN_COST, 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
+        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'>>>);
     }
@@ -134,10 +126,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]));
     }
 }
 
@@ -160,14 +151,14 @@ export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'st
     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'>>>);
@@ -177,37 +168,37 @@ export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'st
 
 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))) {
@@ -255,4 +246,4 @@ export circuit addr_owns_domain(addr: ZswapCoinPublicKey, domain: Opaque<'string
     return domains_owned.lookup(disclose(addr)).member(disclose(domain));
 }
 
-*/
+*/

package/dist/managed/managed/leaf/contract/{index.d.cts → index.d.ts}

@@ -8,84 +8,82 @@ export type Either<A, B> = { is_left: boolean; left: A; right: B };
 
 export type Maybe<T> = { is_some: boolean; value: T };
 
-export type CoinInfo = { nonce: Uint8Array; color: Uint8Array; value: bigint };
-
-export type Witnesses<T> = {
+export type Witnesses<PS> = {
 }
 
-export type ImpureCircuits<T> = {
-  update_color(context: __compactRuntime.CircuitContext<T>, c_0: Uint8Array): __compactRuntime.CircuitResults<T, []>;
-  update_cost(context: __compactRuntime.CircuitContext<T>, c_0: bigint): __compactRuntime.CircuitResults<T, []>;
-  update_target_and_fields(context: __compactRuntime.CircuitContext<T>,
+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_target_and_fields(context: __compactRuntime.CircuitContext<PS>,
                            new_target_0: Either<{ bytes: Uint8Array },
                                                 { bytes: Uint8Array }>,
-                           kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<T, []>;
-  buy_domain_for(context: __compactRuntime.CircuitContext<T>,
+                           kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
+  buy_domain_for(context: __compactRuntime.CircuitContext<PS>,
                  owner_0: { bytes: Uint8Array },
                  domain_0: string,
-                 resolver_0: { bytes: Uint8Array },
-                 payment_0: CoinInfo): __compactRuntime.CircuitResults<T, []>;
-  add_multiple_fields(context: __compactRuntime.CircuitContext<T>,
-                      kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<T, []>;
-  insert_field(context: __compactRuntime.CircuitContext<T>,
+                 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<T, []>;
-  clear_field(context: __compactRuntime.CircuitContext<T>, k_0: string): __compactRuntime.CircuitResults<T, []>;
-  clear_all_fields(context: __compactRuntime.CircuitContext<T>, domain_0: string): __compactRuntime.CircuitResults<T, []>;
-  register_domain_for(context: __compactRuntime.CircuitContext<T>,
+               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, []>;
+  register_domain_for(context: __compactRuntime.CircuitContext<PS>,
                       owner_0: { bytes: Uint8Array },
                       domain_0: string,
-                      resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
-  set_resolver(context: __compactRuntime.CircuitContext<T>,
+                      resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  set_resolver(context: __compactRuntime.CircuitContext<PS>,
                domain_0: string,
-               resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
-  update_domain_target(context: __compactRuntime.CircuitContext<T>,
+               resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  update_domain_target(context: __compactRuntime.CircuitContext<PS>,
                        new_target_0: Either<{ bytes: Uint8Array },
-                                            { bytes: Uint8Array }>): __compactRuntime.CircuitResults<T, []>;
-  transfer_domain(context: __compactRuntime.CircuitContext<T>,
+                                            { bytes: Uint8Array }>): __compactRuntime.CircuitResults<PS, []>;
+  transfer_domain(context: __compactRuntime.CircuitContext<PS>,
                   domain_0: string,
-                  new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
-  change_owner(context: __compactRuntime.CircuitContext<T>,
-               new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
+                  new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  change_owner(context: __compactRuntime.CircuitContext<PS>,
+               new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
 }
 
 export type PureCircuits = {
 }
 
-export type Circuits<T> = {
-  update_color(context: __compactRuntime.CircuitContext<T>, c_0: Uint8Array): __compactRuntime.CircuitResults<T, []>;
-  update_cost(context: __compactRuntime.CircuitContext<T>, c_0: bigint): __compactRuntime.CircuitResults<T, []>;
-  update_target_and_fields(context: __compactRuntime.CircuitContext<T>,
+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_target_and_fields(context: __compactRuntime.CircuitContext<PS>,
                            new_target_0: Either<{ bytes: Uint8Array },
                                                 { bytes: Uint8Array }>,
-                           kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<T, []>;
-  buy_domain_for(context: __compactRuntime.CircuitContext<T>,
+                           kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<PS, []>;
+  buy_domain_for(context: __compactRuntime.CircuitContext<PS>,
                  owner_0: { bytes: Uint8Array },
                  domain_0: string,
-                 resolver_0: { bytes: Uint8Array },
-                 payment_0: CoinInfo): __compactRuntime.CircuitResults<T, []>;
-  add_multiple_fields(context: __compactRuntime.CircuitContext<T>,
-                      kvs_0: Maybe<[string, string]>[]): __compactRuntime.CircuitResults<T, []>;
-  insert_field(context: __compactRuntime.CircuitContext<T>,
+                 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<T, []>;
-  clear_field(context: __compactRuntime.CircuitContext<T>, k_0: string): __compactRuntime.CircuitResults<T, []>;
-  clear_all_fields(context: __compactRuntime.CircuitContext<T>, domain_0: string): __compactRuntime.CircuitResults<T, []>;
-  register_domain_for(context: __compactRuntime.CircuitContext<T>,
+               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, []>;
+  register_domain_for(context: __compactRuntime.CircuitContext<PS>,
                       owner_0: { bytes: Uint8Array },
                       domain_0: string,
-                      resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
-  set_resolver(context: __compactRuntime.CircuitContext<T>,
+                      resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  set_resolver(context: __compactRuntime.CircuitContext<PS>,
                domain_0: string,
-               resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
-  update_domain_target(context: __compactRuntime.CircuitContext<T>,
+               resolver_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<PS, []>;
+  update_domain_target(context: __compactRuntime.CircuitContext<PS>,
                        new_target_0: Either<{ bytes: Uint8Array },
-                                            { bytes: Uint8Array }>): __compactRuntime.CircuitResults<T, []>;
-  transfer_domain(context: __compactRuntime.CircuitContext<T>,
+                                            { bytes: Uint8Array }>): __compactRuntime.CircuitResults<PS, []>;
+  transfer_domain(context: __compactRuntime.CircuitContext<PS>,
                   domain_0: string,
-                  new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
-  change_owner(context: __compactRuntime.CircuitContext<T>,
-               new_owner_0: { bytes: Uint8Array }): __compactRuntime.CircuitResults<T, []>;
+                  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 = {
@@ -127,20 +125,20 @@ export type ContractReferenceLocations = any;
 
 export declare const contractReferenceLocations : ContractReferenceLocations;
 
-export declare class Contract<T, W extends Witnesses<T> = Witnesses<T>> {
+export declare class Contract<PS = any, W extends Witnesses<PS> = Witnesses<PS>> {
   witnesses: W;
-  circuits: Circuits<T>;
-  impureCircuits: ImpureCircuits<T>;
+  circuits: Circuits<PS>;
+  impureCircuits: ImpureCircuits<PS>;
   constructor(witnesses: W);
-  initialState(context: __compactRuntime.ConstructorContext<T>,
+  initialState(context: __compactRuntime.ConstructorContext<PS>,
                parent_domain_0: Maybe<string>,
                parent_resolver_0: { bytes: Uint8Array },
                target_0: Either<{ bytes: Uint8Array }, { bytes: Uint8Array }>,
                domain_0: Maybe<string>,
                coin_color_0: Uint8Array,
                domain_cost_0: bigint,
-               kvs_0: Maybe<[string, string]>[]): __compactRuntime.ConstructorResult<T>;
+               kvs_0: Maybe<[string, string]>[]): __compactRuntime.ConstructorResult<PS>;
 }
 
-export declare function ledger(state: __compactRuntime.StateValue): Ledger;
+export declare function ledger(state: __compactRuntime.StateValue | __compactRuntime.ChargedState): Ledger;
 export declare const pureCircuits: PureCircuits;