@midnames/sdk 1.0.1 → 1.0.4

package/exported.md

@@ -1,111 +0,0 @@
-# MidNames SDK - Exported Signatures
-
-This document contains all exported functions, types, interfaces, classes, and components from the MidNames SDK.
-
-## Functions
-
-### Core
-
-```typescript
-export function resolveDomain(domain: string, options?: { provider?: PublicDataProvider; tldAddress?: string }): Promise<Result<string>>
-```
-Resolves a domain name to its target address.
-
-```typescript
-export function getDomainInfoInContract(contractAddress: string, domainName: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainInfo>>
-```
-Gets information about a domain from a specific contract.
-
-```typescript
-export function getDomainInfo(fullDomain: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainInfo>>
-```
-Gets domain information by resolving the full domain path.
-
-```typescript
-export function getDomainFields(contractAddress: string, options?: { provider?: PublicDataProvider }): Promise<Result<Array<[string, string]>>>
-```
-Gets all fields stored in a domain contract.
-
-```typescript
-export function getDomainSettings(contractAddress: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainSettings>>
-```
-Gets the settings (coin color, domain cost) for a domain contract.
-
-```typescript
-export function getDomainProfile(fullDomain: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainProfileData>>
-```
-Gets the complete profile data for a domain.
-
-### Domain Utility Functions
-
-```typescript
-export function normalizeDomain(input: string, assumeTld: boolean): string
-```
-Normalizes a domain string by cleaning and formatting it.
-
-```typescript
-export function parseFullDomain(fullDomain: string, tld: string): ParsedDomain
-```
-Parses a full domain string into its component parts.
-
-```typescript
-export function buildTraversalPath(fullDomain: string, tld: string): string[]
-```
-Builds the traversal path for resolving a domain.
-
-```typescript
-export function isValidDomainName(domainName: string): boolean
-```
-Validates if a domain name follows the correct format.
-
-```typescript
-export function getParentDomain(fullDomain: string): null | string
-```
-Gets the parent domain of a given domain.
-
-```typescript
-export function getSubdomain(fullDomain: string): string
-```
-Extracts the subdomain portion from a full domain.
-
-```typescript
-export function isTLD(domain: string, tld: string): boolean
-```
-Checks if a domain is a top-level domain.
-
-```typescript
-export function buildFullDomain(subdomain: string, parent: string): string
-```
-Builds a full domain from subdomain and parent parts.
-
-### Address Utility Functions
-
-```typescript
-export function bytesToHex(bytes: Uint8Array): string
-```
-Converts a byte array to a hexadecimal string.
-
-```typescript
-export function formatContractAddress(bytes: Uint8Array): string
-```
-Formats a contract address from bytes with proper prefix.
-
-```typescript
-export function deriveShieldedAddress(coinPublicKeyAddress: string, encryptionPublicKey: string): null | string
-```
-Derives a shielded address from coin public key and encryption key.
-
-## React Components
-
-```typescript
-export type DomainProfileWidgetProps = {
-  fullDomain: string;
-  publicDataProvider: PublicDataProvider;
-  className?: string;
-  showStatus?: boolean;
-  onError?: (error: MidnamesError) => void;
-}
-
-export function DomainProfileWidget(props: DomainProfileWidgetProps): JSX.Element
-```
-React component for displaying domain profile information.

package/managed/index.js

@@ -1,4 +0,0 @@
-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/managed/index.js.map

@@ -1 +0,0 @@
-{"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/managed/leaf.compact

@@ -1,290 +0,0 @@
-pragma language_version >= 0.20;
-/// # 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<Bytes<32>>;
-export sealed ledger PARENT_RESOLVER: ContractAddress;
-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<Bytes<32>, DomainData>;
-
-// Set of domains saved here owned by address.
-export ledger domains_owned: Map<ZswapCoinPublicKey, Set<Bytes<32>>>;
-
-export ledger fields: Map<Opaque<'string'>, Opaque<'string'>>;
-
-
-export { DomainData, Either, Maybe }
-struct DomainData {
-    owner: ZswapCoinPublicKey,
-    resolver: ContractAddress
-}
-
-
-constructor(
-    parent_domain: Maybe<Bytes<32>>,
-    parent_resolver: ContractAddress,
-    target: Either<ZswapCoinPublicKey, ContractAddress>,
-    domain: Maybe<Bytes<32>>,
-    coin_color: Bytes<32>,
-    cost_short: Uint<128>,
-    cost_med: Uint<128>,
-    cost_long: Uint<128>,
-    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);
-    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]));
-        }
-    }
-}
-
-// ===========================================
-//                  Circuits
-// ===========================================
-
-export ledger COIN_COLOR: Bytes<32>;
-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>): [] {
-    assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
-    COIN_COLOR = disclose(c);
-}
-
-export circuit update_costs(cost_short: Uint<128>, cost_med: Uint<128>, cost_long: Uint<128>): [] {
-    assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
-    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>,
-    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'>]>()) {
-            fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
-        }
-    }
-        DOMAIN_TARGET = disclose(new_target);
-
-}
-
-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");
-
-    // 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
-    if (!domains_owned.member(d_owner)) {
-        domains_owned.insert(d_owner, default<Set<Bytes<32>>>);
-    }
-    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'>]>()) {
-            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(): [] {
-    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
-    fields.resetToDefault();
-}
-
-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 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<Bytes<32>>>);
-    }
-    domains_owned.lookup(d_owner).insert(disclose(domain));
-}
-
-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: 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<Bytes<32>>>);
-    }
-    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: Bytes<32>): DomainData {
-    assert(domains.member(disclose(domain)), "Domain does not exist");
-    return domains.lookup(disclose(domain));
-}
-
-export circuit get_parent_domain(): Maybe<Bytes<32>> {
-    return PARENT_DOMAIN;
-}
-
-export circuit get_contract_owner(): ZswapCoinPublicKey {
-    return DOMAIN_OWNER;
-}
-
-export circuit get_domain(): Maybe<Bytes<32>> {
-    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: 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));
-}
-
-*/