@leofcoin/contracts 0.1.1 → 0.1.2

package/exports/factory.d.ts

@@ -0,0 +1,20 @@
+export default class Factory {
+    #private;
+    constructor(state: {
+        contracts: any[];
+        totalContracts: number;
+    });
+    get state(): {
+        totalContracts: number;
+        contracts: any[];
+    };
+    get name(): string;
+    get contracts(): any[];
+    get totalContracts(): number;
+    isRegistered(address: any): boolean;
+    /**
+     *
+     * @param {Address} address contract address to register
+     */
+    registerContract(address: string): Promise<void>;
+}

package/exports/factory.js

@@ -1,56 +1,51 @@
-export default class Factory {
-  /**
-   * string
-   */
-  #name = 'ArtOnlineContractFactory'
-  /**
-   * uint
-   */
-  #totalContracts = 0
-  /**
-   * Array => string
-   */
-  #contracts = []
-
-  constructor(state) {
-    if (state) {
-      this.#contracts = state.contracts
-      this.#totalContracts = state.totalContracts
+class Factory {
+    /**
+     * string
+     */
+    #name = 'ArtOnlineContractFactory';
+    /**
+     * uint
+     */
+    #totalContracts = 0;
+    /**
+     * Array => string
+     */
+    #contracts = [];
+    constructor(state) {
+        if (state) {
+            this.#contracts = state.contracts;
+            this.#totalContracts = state.totalContracts;
+        }
     }
-  }
-
-  get state() {
-    return {
-      totalContracts: this.#totalContracts,
-      contracts: this.#contracts
+    get state() {
+        return {
+            totalContracts: this.#totalContracts,
+            contracts: this.#contracts
+        };
+    }
+    get name() {
+        return this.#name;
+    }
+    get contracts() {
+        return [...this.#contracts];
+    }
+    get totalContracts() {
+        return this.#totalContracts;
+    }
+    isRegistered(address) {
+        return this.#contracts.includes(address);
+    }
+    /**
+     *
+     * @param {Address} address contract address to register
+     */
+    async registerContract(address) {
+        await msg.staticCall(address, 'hasRole', [msg.sender, 'OWNER']);
+        if (this.#contracts.includes(address))
+            throw new Error('already registered');
+        this.#totalContracts += 1;
+        this.#contracts.push(address);
     }
-  }
-
-  get name() {
-    return this.#name
-  }
-
-  get contracts() {
-    return [...this.#contracts]
-  }
-
-  get totalContracts() {
-    return this.#totalContracts
-  }
-
-  isRegistered(address) {
-    return this.#contracts.includes(address)
-  }
-
-  /**
-   * 
-   * @param {Address} address contract address to register
-   */
-  async registerContract(address) {
-    await msg.staticCall(address, 'hasRole', [msg.sender, 'OWNER'])
-    if (this.#contracts.includes(address)) throw new Error('already registered')
-
-    this.#totalContracts += 1
-    this.#contracts.push(address)
-  }
 }
+
+export { Factory as default };

package/exports/name-service.d.ts

@@ -0,0 +1,31 @@
+type registry = {
+    name: {
+        address: address;
+        owner: address;
+    };
+};
+export default class NameService {
+    #private;
+    get name(): string;
+    get registry(): {};
+    get state(): {
+        owner: string;
+        registry: registry;
+        currency: string;
+        price: BigNumberish;
+    };
+    constructor(factoryAddress: address, currency: address, validatorAddress: address, price: BigNumberish, state: {
+        owner: address;
+        registry: registry;
+        currency: address;
+        price: BigNumberish;
+    });
+    changeOwner(owner: any): void;
+    changePrice(price: number): void;
+    changeCurrency(currency: any): void;
+    purchaseName(name: string | number, address: any): Promise<void>;
+    lookup(name: string | number): any;
+    transferOwnership(name: string | number, to: any): void;
+    changeAddress(name: string | number, address: any): void;
+}
+export {};

package/exports/name-service.js

@@ -1,106 +1,107 @@
-export default class NameService {
-  /**
-   * string
-   */
-  #name = 'ArtOnlineNameService'
-  /**
-   * string
-   */
-  #owner
-  /**
-   * number
-   */
-  #price = 0
-  /**
-   * Object => string
-   */
-  #registry = {}
-
-  /**
-   * => string
-   */
-  #currency
-
-  get name() {
-    return this.#name
-  }
-
-  get registry() {
-    return {...this.#registry}
-  }
-
-  get state() {}
-
-  // TODO: control with contract
-  constructor(factoryAddress, currency, validatorAddress, price, state) {
-    if (state) {
-      this.#owner = state.owner
-      this.#registry = state.registry
-      this.#currency = state.currency
-      this.#price = state.price
-    } else {
-      this.#owner = msg.sender
-      this.#price = price
-      this.#registry['ArtOnlineContractFactory'] = {
-        owner: msg.sender,
-        address: factoryAddress
-      }
-
-      this.#registry['ArtOnlineToken'] = {
-        owner: msg.sender,
-        address: currency
-      }
-
-      this.#registry['ArtOnlineValidators'] = {
-        owner: msg.sender,
-        address: validatorAddress
-      }
-
-      this.#currency = currency
+class NameService {
+    /**
+     * string
+     */
+    #name = 'ArtOnlineNameService';
+    /**
+     * string
+     */
+    #owner;
+    /**
+     * number
+     */
+    #price = 0;
+    /**
+     * Object => string
+     */
+    #registry;
+    /**
+     * => string
+     */
+    #currency;
+    get name() {
+        return this.#name;
     }
-  }
-
-  changeOwner(owner) {
-    if (msg.sender !== this.#owner) throw new Error('no owner')
-    this.#owner = owner
-  }
-
-  changePrice(price) {
-    if (msg.sender !== this.#owner) throw new Error('no owner')
-    this.#price = price
-  }
-
-  changeCurrency(currency) {
-    if (msg.sender !== this.#owner) throw new Error('no owner')
-    this.#currency = currency
-  }
-
-  async purchaseName(name, address) {
-    const balance = await msg.call(this.#currency, 'balanceOf', [msg.sender])
-    if (balance < this.#price) throw new Error('price exceeds balance')
-    try {
-      await msg.call(this.#currency, 'transfer', [msg.sender, this.#owner, this.#price])
-    } catch (error) {
-      throw error
+    get registry() {
+        return { ...this.#registry };
     }
-
-    this.#registry[name] = {
-      owner: msg.sender,
-      address
+    get state() {
+        return {
+            owner: this.#owner,
+            registry: this.#registry,
+            currency: this.#currency,
+            price: this.#price
+        };
+    }
+    // TODO: control with contract
+    constructor(factoryAddress, currency, validatorAddress, price, state) {
+        if (state) {
+            this.#owner = state.owner;
+            this.#registry = state.registry;
+            this.#currency = state.currency;
+            this.#price = state.price;
+        }
+        else {
+            this.#owner = msg.sender;
+            this.#price = price;
+            this.#registry['ArtOnlineContractFactory'] = {
+                owner: msg.sender,
+                address: factoryAddress
+            };
+            this.#registry['ArtOnlineToken'] = {
+                owner: msg.sender,
+                address: currency
+            };
+            this.#registry['ArtOnlineValidators'] = {
+                owner: msg.sender,
+                address: validatorAddress
+            };
+            this.#currency = currency;
+        }
+    }
+    changeOwner(owner) {
+        if (msg.sender !== this.#owner)
+            throw new Error('no owner');
+        this.#owner = owner;
+    }
+    changePrice(price) {
+        if (msg.sender !== this.#owner)
+            throw new Error('no owner');
+        this.#price = price;
+    }
+    changeCurrency(currency) {
+        if (msg.sender !== this.#owner)
+            throw new Error('no owner');
+        this.#currency = currency;
+    }
+    async purchaseName(name, address) {
+        const balance = await msg.call(this.#currency, 'balanceOf', [msg.sender]);
+        if (balance < this.#price)
+            throw new Error('price exceeds balance');
+        try {
+            await msg.call(this.#currency, 'transfer', [msg.sender, this.#owner, this.#price]);
+        }
+        catch (error) {
+            throw error;
+        }
+        this.#registry[name] = {
+            owner: msg.sender,
+            address
+        };
+    }
+    lookup(name) {
+        return this.#registry[name];
+    }
+    transferOwnership(name, to) {
+        if (msg.sender !== this.#registry[name].owner)
+            throw new Error('not a owner');
+        this.#registry[name].owner = to;
+    }
+    changeAddress(name, address) {
+        if (msg.sender !== this.#registry[name].owner)
+            throw new Error('not a owner');
+        this.#registry[name].address = address;
     }
-  }
-
-  lookup(name) {
-    return this.#registry[name]
-  }
-
-  transferOwnership(name, to) {
-    if (msg.sender !== this.#registry.owner) throw new Error('not a owner')
-    this.#registry[name].owner = to
-  }
-
-  changeAddress(name, address) {
-    if (msg.sender !== this.#registry.owner) throw new Error('not a owner')
-    this.#registry[name].address = address
-  }
 }
+
+export { NameService as default };

package/exports/native-token.d.ts

@@ -0,0 +1,4 @@
+import Token from '@leofcoin/standards/token.js';
+export default class ArtOnline extends Token {
+    constructor(state: {});
+}

package/exports/native-token.js

@@ -1,7 +1,205 @@
-import Token from '@leofcoin/standards/token.js'
+class Roles {
+    /**
+     * Object => Array
+     */
+    #roles = {
+        'OWNER': [],
+        'MINT': [],
+        'BURN': []
+    };
+    constructor(roles) {
+        // allow devs to set their own roles but always keep the default ones included
+        // also allows roles to be loaded from the stateStore
+        // carefull when including the roles make sure to add the owner
+        // because no roles are granted by default when using custom roles
+        if (roles) {
+            if (roles instanceof Object) {
+                this.#roles = { ...roles, ...this.#roles };
+            }
+            else {
+                throw new TypeError(`expected roles to be an object`);
+            }
+        }
+        else {
+            // no roles given so fallback to default to the msg sender
+            this.#grantRole(msg.sender, 'OWNER');
+        }
+    }
+    /**
+     *
+     */
+    get state() {
+        return { roles: this.roles };
+    }
+    get roles() {
+        return { ...this.#roles };
+    }
+    /**
+     * @param {address} address
+     * @param {string} role
+     * @returns true | false
+     */
+    hasRole(address, role) {
+        return this.#roles[role] ? this.#roles[role].includes(address) : false;
+    }
+    /**
+     * @private
+     * @param {address} address address to grant the role to
+     * @param {string} role role to give
+     */
+    #grantRole(address, role) {
+        if (this.hasRole(address, role))
+            throw new Error(`${role} role already granted for ${address}`);
+        this.#roles[role].push(address);
+    }
+    /**
+     * remove role for address
+     * @private
+     * @param {address} address address to revoke role from
+     * @param {string} role role to evoke
+     */
+    #revokeRole(address, role) {
+        if (!this.hasRole(address, role))
+            throw new Error(`${role} role already revoked for ${address}`);
+        if (role === 'OWNER' && this.#roles[role].length === 1)
+            throw new Error(`atleast one owner is needed!`);
+        this.#roles[role].splice(this.#roles[role].indexOf(address));
+    }
+    grantRole(address, role) {
+        if (!this.hasRole(address, 'OWNER'))
+            throw new Error('Not allowed');
+        this.#grantRole(address, role);
+    }
+    revokeRole(address, role) {
+        if (!this.hasRole(address, 'OWNER'))
+            throw new Error('Not allowed');
+        this.#revokeRole(address, role);
+    }
+}
+
+class Token extends Roles {
+    /**
+     * string
+     */
+    #name;
+    /**
+     * String
+     */
+    #symbol;
+    /**
+     * uint
+     */
+    #holders = 0;
+    /**
+     * Object => Object => uint
+     */
+    #balances = {};
+    /**
+     * Object => Object => uint
+     */
+    #approvals = {};
+    #decimals = 18;
+    #totalSupply = BigNumber.from(0);
+    // this.#privateField2 = 1
+    constructor(name, symbol, decimals = 18, state) {
+        if (!name)
+            throw new Error(`name undefined`);
+        if (!symbol)
+            throw new Error(`symbol undefined`);
+        super(state?.roles);
+        this.#name = name;
+        this.#symbol = symbol;
+        this.#decimals = decimals;
+    }
+    // enables snapshotting
+    // needs dev attention so nothing breaks after snapshot happens
+    // iow everything that is not static needs to be included in the stateObject
+    /**
+     * @return {Object} {holders, balances, ...}
+     */
+    get state() {
+        return {
+            ...super.state,
+            holders: this.holders,
+            balances: this.balances,
+            approvals: { ...this.#approvals },
+            totalSupply: this.totalSupply
+        };
+    }
+    get totalSupply() {
+        return this.#totalSupply;
+    }
+    get name() {
+        return this.#name;
+    }
+    get symbol() {
+        return this.#symbol;
+    }
+    get holders() {
+        return this.#holders;
+    }
+    get balances() {
+        return { ...this.#balances };
+    }
+    mint(to, amount) {
+        if (!this.hasRole(msg.sender, 'MINT'))
+            throw new Error('not allowed');
+        this.#totalSupply = this.#totalSupply.add(amount);
+        this.#increaseBalance(to, amount);
+    }
+    burn(from, amount) {
+        if (!this.hasRole(msg.sender, 'BURN'))
+            throw new Error('not allowed');
+        this.#totalSupply = this.#totalSupply.sub(amount);
+        this.#decreaseBalance(from, amount);
+    }
+    #beforeTransfer(from, to, amount) {
+        if (!this.#balances[from] || this.#balances[from] < amount)
+            throw new Error('amount exceeds balance');
+    }
+    #updateHolders(address, previousBalance) {
+        if (this.#balances[address].toHexString() === '0x00')
+            this.#holders -= 1;
+        else if (this.#balances[address].toHexString() !== '0x00' && previousBalance.toHexString() === '0x00')
+            this.#holders += 1;
+    }
+    #increaseBalance(address, amount) {
+        if (!this.#balances[address])
+            this.#balances[address] = BigNumber.from(0);
+        const previousBalance = this.#balances[address];
+        this.#balances[address] = this.#balances[address].add(amount);
+        this.#updateHolders(address, previousBalance);
+    }
+    #decreaseBalance(address, amount) {
+        const previousBalance = this.#balances[address];
+        this.#balances[address] = this.#balances[address].sub(amount);
+        this.#updateHolders(address, previousBalance);
+    }
+    balanceOf(address) {
+        return this.#balances[address];
+    }
+    setApproval(operator, amount) {
+        const owner = msg.sender;
+        if (!this.#approvals[owner])
+            this.#approvals[owner] = {};
+        this.#approvals[owner][operator] = amount;
+    }
+    approved(owner, operator, amount) {
+        return this.#approvals[owner][operator] === amount;
+    }
+    transfer(from, to, amount) {
+        // TODO: is BigNumber?
+        amount = BigNumber.from(amount);
+        this.#beforeTransfer(from, to, amount);
+        this.#decreaseBalance(from, amount);
+        this.#increaseBalance(to, amount);
+    }
+}
 
-export default class ArtOnline extends Token {
-  constructor(state) {
-    super('ArtOnline', 'ART', 18, state)
-  }
+class ArtOnline extends Token {
+    constructor(state) {
+        super('ArtOnline', 'ART', 18, state);
+    }
 }
+
+export { ArtOnline as default };

package/exports/power-token.d.ts

@@ -0,0 +1,4 @@
+import Token from '@leofcoin/standards/token.js';
+export default class Power extends Token {
+    constructor(state: {});
+}