service

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 26, 2021 License: GPL-3.0 Imports: 25 Imported by: 0

Documentation

Overview

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Package service serve as service layer for our api business logic on fetching data, processing information will be processed in this package.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountBalanceService 

type AccountBalanceService struct {
	AccountBalanceQuery *query.AccountBalanceQuery
	QueryExecutor       query.ExecutorInterface
}

func NewAccountBalanceService 

func NewAccountBalanceService(executor query.ExecutorInterface,
	accountBalanceQuery *query.AccountBalanceQuery) *AccountBalanceService

func (*AccountBalanceService) GetAccountBalance 

func (abs *AccountBalanceService) GetAccountBalance(request *model.GetAccountBalanceRequest) (*model.GetAccountBalanceResponse, error)

func (*AccountBalanceService) GetAccountBalances 

func (abs *AccountBalanceService) GetAccountBalances(
	request *model.GetAccountBalancesRequest,
) (*model.GetAccountBalancesResponse, error)

type AccountBalanceServiceInterface 

type AccountBalanceServiceInterface interface {
	GetAccountBalance(request *model.GetAccountBalanceRequest) (*model.GetAccountBalanceResponse, error)
	GetAccountBalances(request *model.GetAccountBalancesRequest) (*model.GetAccountBalancesResponse, error)
}

type AccountDatasetService 

type AccountDatasetService struct {
	AccountDatasetQuery *query.AccountDatasetQuery
	QueryExecutor       query.ExecutorInterface
}

AccountDatasetService contain fields that needed for AccountDatasetServiceInterface

func (*AccountDatasetService) GetAccountDataset 

func (ads *AccountDatasetService) GetAccountDataset(
	request *model.GetAccountDatasetRequest,
) (*model.AccountDataset, error)

func (*AccountDatasetService) GetAccountDatasets 

func (ads *AccountDatasetService) GetAccountDatasets(
	request *model.GetAccountDatasetsRequest,
) (*model.GetAccountDatasetsResponse, error)

GetAccountDatasets a method service that use for GetAccountDatasets Handler

type AccountDatasetServiceInterface 

type AccountDatasetServiceInterface interface {
	GetAccountDatasets(request *model.GetAccountDatasetsRequest) (*model.GetAccountDatasetsResponse, error)
	GetAccountDataset(request *model.GetAccountDatasetRequest) (*model.AccountDataset, error)
}

AccountDatasetServiceInterface a methods collection for AccountDataset

func NewAccountDatasetService 

func NewAccountDatasetService(
	accountDatasetQuery *query.AccountDatasetQuery,
	queryExecutor query.ExecutorInterface,
) AccountDatasetServiceInterface

type AccountLedgerService 

type AccountLedgerService struct {
	Query query.ExecutorInterface
}

AccountLedgerService struct fields of AccountLedgerService

func NewAccountLedgerService 

func NewAccountLedgerService(executorInterface query.ExecutorInterface) *AccountLedgerService

NewAccountLedgerService create instance of AccountLedgerService

func (*AccountLedgerService) GetAccountLedgers 

func (al *AccountLedgerService) GetAccountLedgers(
	request *model.GetAccountLedgersRequest,
) (*model.GetAccountLedgersResponse, error)

GetAccountLedgers method of account ledger service that api purpose

type AccountLedgerServiceInterface 

type AccountLedgerServiceInterface interface {
	GetAccountLedgers(request *model.GetAccountLedgersRequest) (*model.GetAccountLedgersResponse, error)
}

AccountLedgerServiceInterface interface that has account ledger api service methods collection

type BlockService 

type BlockService struct {
	Query             query.ExecutorInterface
	BlockCoreServices map[int32]coreService.BlockServiceInterface
	// contains filtered or unexported fields
}

BlockService represents struct of BlockService

func NewBlockService 

func NewBlockService(queryExecutor query.ExecutorInterface, blockCoreServices map[int32]coreService.BlockServiceInterface,
	isDebugMode bool) *BlockService

NewBlockService create a singleton instance of BlockService

func (*BlockService) GetBlockByHeight 

func (bs *BlockService) GetBlockByHeight(chainType chaintype.ChainType, height uint32) (*model.GetBlockResponse, error)

GetBlockByHeight fetches a single block from Blockchain by providing block size

func (*BlockService) GetBlockByID 

func (bs *BlockService) GetBlockByID(chainType chaintype.ChainType, id int64) (*model.GetBlockResponse, error)

GetBlockByID fetch a single block from Blockchain by providing block ID

func (*BlockService) GetBlocks 

func (bs *BlockService) GetBlocks(chainType chaintype.ChainType, blockSize, height uint32) (*model.GetBlocksResponse, error)

GetBlocks fetches multiple blocks from Blockchain system

type BlockServiceInterface 

type BlockServiceInterface interface {
	GetBlockByID(chainType chaintype.ChainType, ID int64) (*model.GetBlockResponse, error)
	GetBlockByHeight(chainType chaintype.ChainType, Height uint32) (*model.GetBlockResponse, error)
	GetBlocks(chainType chaintype.ChainType, Count uint32, Height uint32) (*model.GetBlocksResponse, error)
}

BlockServiceInterface represents interface for BlockService

type EscrowTransactionServiceInterface 

type EscrowTransactionServiceInterface interface {
	GetEscrowTransactions(request *model.GetEscrowTransactionsRequest) (*model.GetEscrowTransactionsResponse, error)
	GetEscrowTransaction(request *model.GetEscrowTransactionRequest) (*model.Escrow, error)
}

EscrowTransactionServiceInterface interface that contain methods of escrow transaction

func NewEscrowTransactionService 

func NewEscrowTransactionService(
	query query.ExecutorInterface,
) EscrowTransactionServiceInterface

NewEscrowTransactionService will create EscrowTransactionServiceInterface instance

type HostService 

type HostService struct {
	Query                   query.ExecutorInterface
	P2pService              p2p.Peer2PeerServiceInterface
	BlockServices           map[int32]coreService.BlockServiceInterface
	NodeRegistrationService coreService.NodeRegistrationServiceInterface
	ScrambleNodeService     coreService.ScrambleNodeServiceInterface
	BlockStateStorages      map[int32]storage.CacheStorageInterface
}

func (*HostService) GetHostInfo 

func (hs *HostService) GetHostInfo() (*model.HostInfo, error)

func (*HostService) GetHostPeers 

func (hs *HostService) GetHostPeers() (*model.GetHostPeersResponse, error)

type HostServiceInterface 

type HostServiceInterface interface {
	GetHostInfo() (*model.HostInfo, error)
	GetHostPeers() (*model.GetHostPeersResponse, error)
}

func NewHostService 

func NewHostService(
	queryExecutor query.ExecutorInterface,
	p2pService p2p.Peer2PeerServiceInterface,
	blockServices map[int32]coreService.BlockServiceInterface,
	nodeRegistrationService coreService.NodeRegistrationServiceInterface,
	scrambleNodeService coreService.ScrambleNodeServiceInterface,
	blockStateStorages map[int32]storage.CacheStorageInterface,
) HostServiceInterface

NewHostService create a singleton instance of PeerExplorer

type LiquidTransactionService 

type LiquidTransactionService struct {
	LiquidPaymentTransactionQuery *query.LiquidPaymentTransactionQuery
	QueryExecutor                 query.ExecutorInterface
}

func NewLiquidTransactionService 

func NewLiquidTransactionService(executor query.ExecutorInterface,
	liquidPaymentTransactionQuery *query.LiquidPaymentTransactionQuery) *LiquidTransactionService

func (*LiquidTransactionService) GetLiquidTransactions 

func (lts *LiquidTransactionService) GetLiquidTransactions(
	request *model.GetLiquidTransactionsRequest,
) (*model.GetLiquidTransactionsResponse, error)

type LiquidTransactionServiceInterface 

type LiquidTransactionServiceInterface interface {
	GetLiquidTransactions(request *model.GetLiquidTransactionsRequest) (*model.GetLiquidTransactionsResponse, error)
}

type MempoolTransactionService 

type MempoolTransactionService struct {
	Query query.ExecutorInterface
}

func NewMempoolTransactionsService 

func NewMempoolTransactionsService(
	queryExecutor query.ExecutorInterface,
) *MempoolTransactionService

func (*MempoolTransactionService) GetMempoolTransaction 

func (ut *MempoolTransactionService) GetMempoolTransaction(
	chainType chaintype.ChainType,
	params *model.GetMempoolTransactionRequest,
) (*model.GetMempoolTransactionResponse, error)

func (*MempoolTransactionService) GetMempoolTransactions 

func (ut *MempoolTransactionService) GetMempoolTransactions(
	chainType chaintype.ChainType,
	params *model.GetMempoolTransactionsRequest,
) (*model.GetMempoolTransactionsResponse, error)

type MempoolTransactionServiceInterface 

type MempoolTransactionServiceInterface interface {
	GetMempoolTransaction(
		chainType chaintype.ChainType,
		params *model.GetMempoolTransactionRequest,
	) (*model.GetMempoolTransactionResponse, error)
	GetMempoolTransactions(
		chainType chaintype.ChainType,
		params *model.GetMempoolTransactionsRequest,
	) (*model.GetMempoolTransactionsResponse, error)
}

type MultisigService 

type MultisigService struct {
	Executor                       query.ExecutorInterface
	BlockService                   coreService.BlockServiceInterface
	PendingTransactionQuery        query.PendingTransactionQueryInterface
	PendingSignatureQuery          query.PendingSignatureQueryInterface
	MultisignatureInfoQuery        query.MultisignatureInfoQueryInterface
	MultiSignatureParticipantQuery query.MultiSignatureParticipantQueryInterface
	Logger                         *logrus.Logger
}

func NewMultisigService 

func NewMultisigService(
	executor query.ExecutorInterface,
	blockService coreService.BlockServiceInterface,
	pendingTransactionQuery query.PendingTransactionQueryInterface,
	pendingSignatureQuery query.PendingSignatureQueryInterface,
	multisignatureQuery query.MultisignatureInfoQueryInterface,
	multiSignatureParticipantQuery query.MultiSignatureParticipantQueryInterface,
) *MultisigService

func (*MultisigService) GetMultisigAddressByParticipantAddress 

func (ms *MultisigService) GetMultisigAddressByParticipantAddress(
	param *model.GetMultisigAddressByParticipantAddressRequest,
) (*model.GetMultisigAddressByParticipantAddressResponse, error)

func (*MultisigService) GetMultisigAddressesByBlockHeightRange 

func (ms *MultisigService) GetMultisigAddressesByBlockHeightRange(
	param *model.GetMultisigAddressesByBlockHeightRangeRequest,
) (*model.GetMultisigAddressesByBlockHeightRangeResponse, error)

func (*MultisigService) GetMultisignatureInfo 

func (ms *MultisigService) GetMultisignatureInfo(
	param *model.GetMultisignatureInfoRequest,
) (*model.GetMultisignatureInfoResponse, error)

func (*MultisigService) GetParticipantsByMultisigAddresses 

func (ms *MultisigService) GetParticipantsByMultisigAddresses(
	param *model.GetParticipantsByMultisigAddressesRequest,
) (*model.GetParticipantsByMultisigAddressesResponse, error)

func (*MultisigService) GetPendingTransactionDetailByTransactionHash 

func (ms *MultisigService) GetPendingTransactionDetailByTransactionHash(
	param *model.GetPendingTransactionDetailByTransactionHashRequest,
) (*model.GetPendingTransactionDetailByTransactionHashResponse, error)

func (*MultisigService) GetPendingTransactions 

func (ms *MultisigService) GetPendingTransactions(
	param *model.GetPendingTransactionsRequest,
) (*model.GetPendingTransactionsResponse, error)

func (*MultisigService) GetPendingTransactionsByHeight 

func (ms *MultisigService) GetPendingTransactionsByHeight(
	fromHeight, toHeight uint32,
) ([]*model.PendingTransaction, error)

type MultisigServiceInterface 

type MultisigServiceInterface interface {
	GetPendingTransactions(
		param *model.GetPendingTransactionsRequest,
	) (*model.GetPendingTransactionsResponse, error)
	GetPendingTransactionsByHeight(
		fromHeight, toHeight uint32,
	) ([]*model.PendingTransaction, error)
	GetPendingTransactionDetailByTransactionHash(
		param *model.GetPendingTransactionDetailByTransactionHashRequest,
	) (*model.GetPendingTransactionDetailByTransactionHashResponse, error)
	GetMultisignatureInfo(
		param *model.GetMultisignatureInfoRequest,
	) (*model.GetMultisignatureInfoResponse, error)
	GetMultisigAddressByParticipantAddress(
		param *model.GetMultisigAddressByParticipantAddressRequest,
	) (*model.GetMultisigAddressByParticipantAddressResponse, error)
	GetMultisigAddressesByBlockHeightRange(
		param *model.GetMultisigAddressesByBlockHeightRangeRequest,
	) (*model.GetMultisigAddressesByBlockHeightRangeResponse, error)
	GetParticipantsByMultisigAddresses(
		param *model.GetParticipantsByMultisigAddressesRequest,
	) (*model.GetParticipantsByMultisigAddressesResponse, error)
}

type NodeAddressInfoAPIService 

type NodeAddressInfoAPIService struct {
	NodeAddressInfoService coreService.NodeAddressInfoServiceInterface
}

func NewNodeAddressInfoAPIService 

func NewNodeAddressInfoAPIService(
	nodeAddressInfoService coreService.NodeAddressInfoServiceInterface,
) *NodeAddressInfoAPIService

func (*NodeAddressInfoAPIService) GetNodeAddressesInfo 

func (nhs *NodeAddressInfoAPIService) GetNodeAddressesInfo(request *model.GetNodeAddressesInfoRequest,
) (*model.GetNodeAddressesInfoResponse, error)

GetNodeAddressesInfo client api to get one, many or all address info from db note: if request.NodeIDs is an empty array, the whole address info table will be returned note2: only one address per (registered) node is returned. if a node has two addresses for the same nodeID (pending and confirmed), confirmed address is chosen over the pending one

type NodeAddressInfoAPIServiceInterface 

type NodeAddressInfoAPIServiceInterface interface {
	GetNodeAddressesInfo(request *model.GetNodeAddressesInfoRequest) (*model.GetNodeAddressesInfoResponse, error)
}

type NodeAdminService 

type NodeAdminService struct {
	Query                query.ExecutorInterface
	NodeAdminCoreService coreService.NodeAdminServiceInterface
	// contains filtered or unexported fields
}

TransactionService represents struct of TransactionService

func NewNodeAdminService 

func NewNodeAdminService(
	queryExecutor query.ExecutorInterface,
	blockService coreService.BlockServiceInterface,
	ownerAccountAddress []byte,
	nodeKeyFilePath string,
) *NodeAdminService

NewBlockService create a singleton instance of BlockService

func (*NodeAdminService) GenerateNodeKey 

func (nas *NodeAdminService) GenerateNodeKey(seed string) ([]byte, error)

GenerateNodeKey api to request the node to generate a new key pairs

func (*NodeAdminService) GetProofOfOwnership 

func (nas *NodeAdminService) GetProofOfOwnership() (*model.ProofOfOwnership, error)

GetProofOfOwnership GetProof of ownership

type NodeAdminServiceInterface 

type NodeAdminServiceInterface interface {
	GetProofOfOwnership() (*model.ProofOfOwnership, error)
	GenerateNodeKey(seed string) ([]byte, error)
}

TransactionServiceInterface represents interface for TransactionService

type NodeHardwareService 

type NodeHardwareService struct {
	OwnerAccountAddress []byte
	Signature           crypto.SignatureInterface
}

func NewNodeHardwareService 

func NewNodeHardwareService(
	ownerAccountAddress []byte,
	signature crypto.SignatureInterface,
) *NodeHardwareService

func (*NodeHardwareService) GetNodeHardware 

func (nhs *NodeHardwareService) GetNodeHardware(request *model.GetNodeHardwareRequest) (*model.GetNodeHardwareResponse, error)

type NodeHardwareServiceInterface 

type NodeHardwareServiceInterface interface {
	GetNodeHardware(request *model.GetNodeHardwareRequest) (*model.GetNodeHardwareResponse, error)
}

type NodeRegistryService 

type NodeRegistryService struct {
	Query                 query.ExecutorInterface
	NodeRegistrationQuery query.NodeRegistrationQueryInterface
}

func NewNodeRegistryService 

func NewNodeRegistryService(queryExecutor query.ExecutorInterface) *NodeRegistryService

func (NodeRegistryService) GetNodeRegistration 

func (ns NodeRegistryService) GetNodeRegistration(
	params *model.GetNodeRegistrationRequest,
) (*model.GetNodeRegistrationResponse, error)

func (NodeRegistryService) GetNodeRegistrations 

func (ns NodeRegistryService) GetNodeRegistrations(params *model.GetNodeRegistrationsRequest) (
	*model.GetNodeRegistrationsResponse,
	error,
)

func (NodeRegistryService) GetNodeRegistrationsByNodePublicKeys 

func (ns NodeRegistryService) GetNodeRegistrationsByNodePublicKeys(params *model.GetNodeRegistrationsByNodePublicKeysRequest,
) (*model.GetNodeRegistrationsByNodePublicKeysResponse, error)

func (NodeRegistryService) GetPendingNodeRegistrations 

func (ns NodeRegistryService) GetPendingNodeRegistrations(
	req *model.GetPendingNodeRegistrationsRequest) (*model.GetPendingNodeRegistrationsResponse, error)

type NodeRegistryServiceInterface 

type NodeRegistryServiceInterface interface {
	GetNodeRegistrations(*model.GetNodeRegistrationsRequest) (*model.GetNodeRegistrationsResponse, error)
	GetNodeRegistration(*model.GetNodeRegistrationRequest) (*model.GetNodeRegistrationResponse, error)
	GetNodeRegistrationsByNodePublicKeys(*model.GetNodeRegistrationsByNodePublicKeysRequest,
	) (*model.GetNodeRegistrationsByNodePublicKeysResponse, error)
	GetPendingNodeRegistrations(*model.GetPendingNodeRegistrationsRequest) (*model.GetPendingNodeRegistrationsResponse, error)
}

type ParticipationScoreInterface 

type ParticipationScoreInterface interface {
	GetParticipationScores(params *model.GetParticipationScoresRequest) (*model.GetParticipationScoresResponse, error)
	GetLatestParticipationScoreByNodeID(params *model.GetLatestParticipationScoreByNodeIDRequest) (*model.ParticipationScore, error)
}

ParticipationScoreInterface represents interface for ParticipationScoreService

type ParticipationScoreService 

type ParticipationScoreService struct {
	ParticipationScoreService coreService.ParticipationScoreServiceInterface
}

ParticipationScoreService represents struct of ParticipationScoreService

func NewParticipationScoreService 

func NewParticipationScoreService(
	participationScoreService coreService.ParticipationScoreServiceInterface) *ParticipationScoreService

NewParticipationScoreService creates a singleton instance of ParticipationScoreService

func (*ParticipationScoreService) GetLatestParticipationScoreByNodeID 

func (pss *ParticipationScoreService) GetLatestParticipationScoreByNodeID(
	params *model.GetLatestParticipationScoreByNodeIDRequest,
) (*model.ParticipationScore, error)

GetParticipationScores fetches participation scores for given height range Note: if we pass NodeAddress, it must be formatted as address:port

func (*ParticipationScoreService) GetParticipationScores 

func (pss *ParticipationScoreService) GetParticipationScores(
	params *model.GetParticipationScoresRequest,
) (*model.GetParticipationScoresResponse, error)

GetParticipationScores fetches participation scores for given height range

type PublishedReceiptService 

type PublishedReceiptService struct {
	PublishedReceiptUtil util2.PublishedReceiptUtilInterface
}

PublishedReceiptService represents struct of published receipt service

func NewPublishedReceiptService 

func NewPublishedReceiptService(
	publishedReceiptUtil util2.PublishedReceiptUtilInterface,
) *PublishedReceiptService

NewPublishedReceiptService creates an instance of PublishedReceiptService

func (*PublishedReceiptService) GetPublishedReceipts 

func (prs *PublishedReceiptService) GetPublishedReceipts(
	params *model.GetPublishedReceiptsRequest,
) (*model.GetPublishedReceiptsResponse, error)

GetPublishedReceipts fetches a published receipts within range of `fromHeight` - `toHeight`

type PublishedReceiptServiceInterface 

type PublishedReceiptServiceInterface interface {
	GetPublishedReceipts(*model.GetPublishedReceiptsRequest) (*model.GetPublishedReceiptsResponse, error)
}

PublishedReceiptServiceInterface represents interface for PublishedReceiptService

type SkippedBlockSmithService 

type SkippedBlockSmithService struct {
	QueryExecutor          query.ExecutorInterface
	SkippedBlocksmithQuery *query.SkippedBlocksmithQuery
}

SkippedBlockSmithService represents struct of SkippedBlockSmithService

func (*SkippedBlockSmithService) GetSkippedBlockSmiths 

func (sbs *SkippedBlockSmithService) GetSkippedBlockSmiths(
	req *model.GetSkippedBlocksmithsRequest,
) (*model.GetSkippedBlocksmithsResponse, error)

type SkippedBlockSmithServiceInterface 

type SkippedBlockSmithServiceInterface interface {
	GetSkippedBlockSmiths(*model.GetSkippedBlocksmithsRequest) (*model.GetSkippedBlocksmithsResponse, error)
}

SkippedBlockSmithServiceInterface represents interface for BlockService

func NewSkippedBlockSmithService 

func NewSkippedBlockSmithService(
	skippedBlocksmithQuery *query.SkippedBlocksmithQuery,
	queryExecutor query.ExecutorInterface,
) SkippedBlockSmithServiceInterface

type TransactionService 

type TransactionService struct {
	Query              query.ExecutorInterface
	Signature          crypto.SignatureInterface
	ActionTypeSwitcher transaction.TypeActionSwitcher
	MempoolService     service.MempoolServiceInterface
	Observer           *observer.Observer
	TransactionUtil    transaction.UtilInterface
	FeedbackStrategy   feedbacksystem.FeedbackStrategyInterface
	Logger             *log.Logger
}

TransactionService represents struct of TransactionService

func NewTransactionService 

func NewTransactionService(
	queryExecutor query.ExecutorInterface,
	signature crypto.SignatureInterface,
	txTypeSwitcher transaction.TypeActionSwitcher,
	mempoolService service.MempoolServiceInterface,
	observer *observer.Observer,
	transactionUtil transaction.UtilInterface,
	feedbackStrategy feedbacksystem.FeedbackStrategyInterface,
	logger *log.Logger,
) *TransactionService

NewTransactionService creates a singleton instance of TransactionService

func (*TransactionService) GetTransaction 

func (ts *TransactionService) GetTransaction(
	chainType chaintype.ChainType,
	params *model.GetTransactionRequest,
) (*model.Transaction, error)

GetTransaction fetches a single transaction from DB

func (*TransactionService) GetTransactionMinimumFee 

func (ts *TransactionService) GetTransactionMinimumFee(req *model.GetTransactionMinimumFeeRequest) (
	*model.GetTransactionMinimumFeeResponse, error,
)

func (*TransactionService) GetTransactions 

func (ts *TransactionService) GetTransactions(
	chainType chaintype.ChainType,
	params *model.GetTransactionsRequest,
) (*model.GetTransactionsResponse, error)

GetTransactions fetches a single transaction from DB included filters

func (*TransactionService) PostTransaction 

func (ts *TransactionService) PostTransaction(
	chaintype chaintype.ChainType,
	req *model.PostTransactionRequest,
) (*model.Transaction, error)

PostTransaction represents POST transaction method

type TransactionServiceInterface 

type TransactionServiceInterface interface {
	GetTransaction(chaintype.ChainType, *model.GetTransactionRequest) (*model.Transaction, error)
	GetTransactions(chaintype.ChainType, *model.GetTransactionsRequest) (*model.GetTransactionsResponse, error)
	PostTransaction(chaintype.ChainType, *model.PostTransactionRequest) (*model.Transaction, error)
	GetTransactionMinimumFee(request *model.GetTransactionMinimumFeeRequest) (
		*model.GetTransactionMinimumFeeResponse, error,
	)
}

TransactionServiceInterface represents interface for TransactionService

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.