@leofcoin/standards 0.2.16 → 0.3.1

package/src/meta.ts

@@ -0,0 +1,31 @@
+import { MetaState } from './types.js'
+
+export default class Meta {
+  #creator: address
+  #createdAt: bigint = BigInt(Date.now())
+
+  constructor(state?: MetaState) {
+    if (state) {
+      this.#creator = state.creator
+      this.#createdAt = state.createdAt
+    } else {
+      this.#creator = msg.sender
+      this.#createdAt = BigInt(Date.now())
+    }
+  }
+
+  /**
+   * get state object for snapshotting
+   */
+  get state(): {} {
+    return { creator: this.#creator, createdAt: this.#createdAt }
+  }
+
+  get creator(): address {
+    return this.#creator
+  }
+
+  get createdAt(): bigint {
+    return this.#createdAt
+  }
+}

package/src/roles.ts

@@ -1,89 +1,88 @@
-import ContractCreator, { ContractCreatorState } from './contract-creator.js'
-
-export interface RolesState extends ContractCreatorState {
-  roles: { [index: string]: address[] }
-}
-
-export default class Roles extends ContractCreator {
-  /**
-   * Object => Array
-   */
-  #roles = {
-    OWNER: [],
-    MINT: [],
-    BURN: []
-  }
-
-  constructor(state) {
-    super(state)
-    // 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 (state?.roles) {
-      if (state.roles instanceof Object) {
-        this.#roles = { ...state.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(): RolesState {
-    return { ...super.state, roles: this.roles }
-  }
-
-  get roles(): {} {
-    return { ...this.#roles }
-  }
-  /**
-   * @param {address} address
-   * @param {string} role
-   * @returns true | false
-   */
-  hasRole(address: address, role: string): boolean {
-    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: address, role: string): void {
-    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: address, role: string) {
-    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: address, role: string) {
-    if (!this.hasRole(address, 'OWNER')) throw new Error('Not allowed')
-
-    this.#grantRole(address, role)
-  }
-
-  revokeRole(address: address, role: string) {
-    if (!this.hasRole(address, 'OWNER')) throw new Error('Not allowed')
-
-    this.#revokeRole(address, role)
-  }
-}
+import Meta from './meta.js'
+import { RolesState } from './types.js'
+
+export default class Roles extends Meta {
+  /**
+   * Object => Array
+   */
+  #roles: { [index: string]: address[] } = {
+    OWNER: [],
+    MINT: [],
+    BURN: []
+  }
+
+  constructor(state?: RolesState) {
+    super(state)
+    if (state?.roles) {
+      if (state.roles instanceof Object) {
+        this.#roles = { ...state.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 {
+      ...super.state,
+      roles: this.roles
+    }
+  }
+
+  get roles(): {} {
+    return { ...this.#roles }
+  }
+  /**
+   * @param {address} address
+   * @param {string} role
+   * @returns true | false
+   */
+  hasRole(address: address, role: string): boolean {
+    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: address, role: string): void {
+    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: address, role: string) {
+    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: address, role: string) {
+    if (!this.hasRole(address, 'OWNER')) throw new Error('Not allowed')
+
+    this.#grantRole(address, role)
+  }
+
+  revokeRole(address: address, role: string) {
+    if (!this.hasRole(address, 'OWNER')) throw new Error('Not allowed')
+
+    this.#revokeRole(address, role)
+  }
+}

package/src/token-receiver.ts

@@ -1,175 +1,196 @@
-import { IVoting } from './voting/interfaces/i-voting.js'
-import PublicVoting, { PublicVotingState } from './voting/public-voting.js'
-
-export interface TokenReceiverState extends PublicVotingState {
-  tokenToReceive: address
-  tokenReceiver: address
-  tokenAmountToReceive: bigint
-  voteType: 'burn' | 'transfer'
-}
-export default class TokenReceiver extends PublicVoting implements IVoting {
-  #tokenToReceive: address
-  #tokenAmountToReceive: bigint
-  #tokenReceiver: address
-  #voteType: TokenReceiverState['voteType'] = 'transfer'
-
-  constructor(tokenToReceive: address, tokenAmountToReceive: bigint, burns: boolean, state?: TokenReceiverState) {
-    super(state)
-    if (state) {
-      this.#tokenReceiver = state.tokenReceiver
-      this.#tokenToReceive = state.tokenToReceive
-      this.#tokenAmountToReceive = BigInt(state.tokenAmountToReceive)
-      this.#voteType = state.voteType
-    } else {
-      this.#tokenReceiver = msg.contract
-      this.#tokenToReceive = tokenToReceive
-      this.#tokenAmountToReceive = BigInt(tokenAmountToReceive)
-      if (burns) this.#voteType = 'burn'
-    }
-  }
-
-  get tokenToReceive() {
-    return this.#tokenToReceive
-  }
-
-  get tokenAmountToReceive() {
-    return this.#tokenAmountToReceive
-  }
-
-  get tokenReceiver() {
-    return this.#tokenReceiver
-  }
-
-  get state() {
-    return {
-      ...super.state,
-      tokenReceiver: this.#tokenReceiver,
-      tokenToReceive: this.#tokenToReceive,
-      tokenAmountToReceive: this.#tokenAmountToReceive,
-      voteType: this.#voteType
-    }
-  }
-
-  async #canVote() {
-    const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [msg.sender])) as bigint
-    return amount >= this.#tokenAmountToReceive
-  }
-
-  /**
-   * check if sender can pay
-   * @returns {boolean} promise
-   */
-  async _canVote(): Promise<boolean> {
-    return this.#canVote()
-  }
-
-  async #beforeVote(): Promise<any> {
-    if (this.#voteType === 'burn') return msg.staticCall(this.tokenToReceive, 'burn', [this.tokenAmountToReceive])
-    return msg.staticCall(this.tokenToReceive, 'transfer', [msg.sender, this.tokenReceiver, this.tokenAmountToReceive])
-  }
-
-  async _beforeVote(): Promise<any> {
-    return this.#beforeVote()
-  }
-
-  /**
-   * check if sender can pay
-   * @returns {boolean} promise
-   */
-  async _payTokenToReceive(): Promise<boolean> {
-    return msg.staticCall(this.#tokenToReceive, 'transfer', [
-      msg.sender,
-      this.#tokenReceiver,
-      this.#tokenAmountToReceive
-    ])
-  }
-
-  /**
-   * check if sender can pay
-   * @returns {boolean} promise
-   */
-  async _burnTokenToReceive(): Promise<boolean> {
-    return msg.staticCall(this.#tokenToReceive, 'burn', [this.#tokenAmountToReceive])
-  }
-
-  async _canPay() {
-    const amount = await msg.call(this.#tokenToReceive, 'balance', [])
-    return amount.gte(this.tokenAmountToReceive)
-  }
-
-  #changeTokenToReceive(address: address) {
-    this.#tokenToReceive = address
-  }
-
-  #changeTokenAmountToReceive(amount: bigint) {
-    this.#tokenAmountToReceive = amount
-  }
-
-  #changeVoteType(type: TokenReceiverState['voteType']) {
-    this.#voteType = type
-  }
-
-  #getTokensOut(amount: bigint, receiver: address) {
-    return msg.call(this.#tokenReceiver, 'transfer', [this.#tokenReceiver, receiver, amount])
-  }
-
-  async changeVoteType(type: TokenReceiverState['voteType']) {
-    if (!this.#canVote()) throw new Error('not a allowed')
-    if (this.#voteType === 'transfer' && (await this.#balance()) > 0n)
-      throw new Error('get tokens out first or they be lost forever')
-    else {
-      this.createVote(
-        `change the token amount to receive`,
-        `set tokenAmountToReceive`,
-        new Date().getTime() + this.votingDuration,
-        '#changeVoteType',
-        [type]
-      )
-    }
-  }
-
-  getTokensOut(amount: bigint, receiver: address) {
-    if (!this.#canVote()) throw new Error('not a allowed')
-    else {
-      this.createVote(
-        `withdraw all tokens`,
-        `withdraw all tokens to ${receiver}`,
-        new Date().getTime() + this.votingDuration,
-        '#getTokensOut',
-        [amount, receiver]
-      )
-    }
-  }
-
-  changeTokenAmountToReceive() {
-    if (!this.#canVote()) throw new Error('not a allowed')
-    else {
-      this.createVote(
-        `change the token amount to receive`,
-        `set tokenAmountToReceive`,
-        new Date().getTime() + this.votingDuration,
-        '#changeTokenAmountToReceive',
-        []
-      )
-    }
-  }
-
-  #balance(): Promise<bigint> {
-    return msg.staticCall(this.#tokenToReceive, 'balanceOf', [this.#tokenReceiver])
-  }
-
-  async changeTokenToReceive() {
-    if (!this.#canVote()) throw new Error('not a allowed')
-    if ((await this.#balance()) > 0n && this.#voteType === 'transfer')
-      throw new Error('get tokens out first or they be lost forever')
-    else {
-      this.createVote(
-        `change the token to receive`,
-        `set tokenToReceive to a new address`,
-        new Date().getTime() + this.votingDuration,
-        '#changeTokenToReceive',
-        []
-      )
-    }
-  }
-}
+import { IPublicVoting } from './voting/interfaces/i-public-voting.js'
+import PublicVoting from './voting/public-voting.js'
+import { VotingState } from './voting/types.js'
+
+export interface TokenReceiverState extends VotingState {
+  tokenToReceive: address
+  tokenReceiver: address
+  tokenAmountToReceive: bigint
+  voteType: 'burn' | 'transfer'
+}
+export default class TokenReceiver
+  extends PublicVoting
+  implements IPublicVoting
+{
+  #tokenToReceive: address
+  #tokenAmountToReceive: bigint
+  #tokenReceiver: address
+  #voteType: TokenReceiverState['voteType'] = 'transfer'
+
+  constructor(
+    tokenToReceive: address,
+    tokenAmountToReceive: bigint,
+    burns: boolean,
+    state?: TokenReceiverState
+  ) {
+    super(state)
+    if (state) {
+      this.#tokenReceiver = state.tokenReceiver
+      this.#tokenToReceive = state.tokenToReceive
+      this.#tokenAmountToReceive = BigInt(state.tokenAmountToReceive)
+      this.#voteType = state.voteType
+    } else {
+      this.#tokenReceiver = msg.contract
+      this.#tokenToReceive = tokenToReceive
+      this.#tokenAmountToReceive = BigInt(tokenAmountToReceive)
+      if (burns) this.#voteType = 'burn'
+    }
+  }
+
+  get tokenToReceive() {
+    return this.#tokenToReceive
+  }
+
+  get tokenAmountToReceive() {
+    return this.#tokenAmountToReceive
+  }
+
+  get tokenReceiver() {
+    return this.#tokenReceiver
+  }
+
+  get state() {
+    return {
+      ...super.state,
+      tokenReceiver: this.#tokenReceiver,
+      tokenToReceive: this.#tokenToReceive,
+      tokenAmountToReceive: this.#tokenAmountToReceive,
+      voteType: this.#voteType
+    }
+  }
+
+  async #canVote() {
+    const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [
+      msg.sender
+    ])) as bigint
+    return amount >= this.#tokenAmountToReceive
+  }
+
+  /**
+   * check if sender can pay
+   * @returns {boolean} promise
+   */
+  async _canVote(): Promise<boolean> {
+    return this.#canVote()
+  }
+
+  async #beforeVote(): Promise<any> {
+    if (this.#voteType === 'burn')
+      return msg.staticCall(this.tokenToReceive, 'burn', [
+        this.tokenAmountToReceive
+      ])
+    return msg.staticCall(this.tokenToReceive, 'transfer', [
+      msg.sender,
+      this.tokenReceiver,
+      this.tokenAmountToReceive
+    ])
+  }
+
+  async _beforeVote(): Promise<any> {
+    await this.#beforeVote()
+  }
+
+  /**
+   * check if sender can pay
+   * @returns {boolean} promise
+   */
+  async _payTokenToReceive(): Promise<boolean> {
+    return msg.staticCall(this.#tokenToReceive, 'transfer', [
+      msg.sender,
+      this.#tokenReceiver,
+      this.#tokenAmountToReceive
+    ])
+  }
+
+  /**
+   * check if sender can pay
+   * @returns {boolean} promise
+   */
+  async _burnTokenToReceive(): Promise<boolean> {
+    return msg.staticCall(this.#tokenToReceive, 'burn', [
+      this.#tokenAmountToReceive
+    ])
+  }
+
+  #changeTokenToReceive(address: address) {
+    this.#tokenToReceive = address
+  }
+
+  #changeTokenAmountToReceive(amount: bigint) {
+    this.#tokenAmountToReceive = amount
+  }
+
+  #changeVoteType(type: TokenReceiverState['voteType']) {
+    this.#voteType = type
+  }
+
+  #getTokensOut(amount: bigint, receiver: address) {
+    return msg.call(this.#tokenReceiver, 'transfer', [
+      this.#tokenReceiver,
+      receiver,
+      amount
+    ])
+  }
+
+  async changeVoteType(type: TokenReceiverState['voteType']) {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    if (this.#voteType === 'transfer' && (await this.#balance()) > 0n)
+      throw new Error('get tokens out first or they be lost forever')
+    else {
+      this.createVote(
+        `change the token amount to receive`,
+        `set tokenAmountToReceive`,
+        new Date().getTime() + this.votingDuration,
+        '#changeVoteType',
+        [type]
+      )
+    }
+  }
+
+  getTokensOut(amount: bigint, receiver: address) {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    else {
+      this.createVote(
+        `withdraw all tokens`,
+        `withdraw all tokens to ${receiver}`,
+        new Date().getTime() + this.votingDuration,
+        '#getTokensOut',
+        [amount, receiver]
+      )
+    }
+  }
+
+  changeTokenAmountToReceive() {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    else {
+      this.createVote(
+        `change the token amount to receive`,
+        `set tokenAmountToReceive`,
+        new Date().getTime() + this.votingDuration,
+        '#changeTokenAmountToReceive',
+        []
+      )
+    }
+  }
+
+  #balance(): Promise<bigint> {
+    return msg.staticCall(this.#tokenToReceive, 'balanceOf', [
+      this.#tokenReceiver
+    ])
+  }
+
+  async changeTokenToReceive() {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    if ((await this.#balance()) !== 0n && this.#voteType === 'transfer')
+      throw new Error('get tokens out first or they be lost forever')
+    else {
+      this.createVote(
+        `change the token to receive`,
+        `set tokenToReceive to a new address`,
+        new Date().getTime() + this.votingDuration,
+        '#changeTokenToReceive',
+        []
+      )
+    }
+  }
+}