transaction

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: 24 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.

Package transaction include:

  • Validate
  • ApplyConfirmed
  • ApplyUnconfirmed

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.

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

func GetFixtureForFeeVoteCommitTransaction 

func GetFixtureForFeeVoteCommitTransaction(
	feeVoteInfo *model.FeeVoteInfo,
	seed string,
) (txBody *model.FeeVoteCommitTransactionBody, txBodyBytes []byte)

func GetFixtureForFeeVoteRevealTransaction 

func GetFixtureForFeeVoteRevealTransaction(
	voteInfo *model.FeeVoteInfo,
	seed string,
) (body *model.FeeVoteRevealTransactionBody)

func GetFixtureForSpecificTransaction 

func GetFixtureForSpecificTransaction(
	id, timestamp int64,
	sender, recipient []byte,
	bodyLength uint32,
	transactionType model.TransactionType,
	transactionBody model.TransactionBodyInterface,
	escrow, sign bool,
) (tx *model.Transaction, txBytes []byte)

func GetFixturesForApprovalEscrowTransaction 

func GetFixturesForApprovalEscrowTransaction() (
	txBody *model.ApprovalEscrowTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForBlock 

func GetFixturesForBlock(height uint32, id int64) *model.Block

func GetFixturesForClaimNoderegistration 

func GetFixturesForClaimNoderegistration() (
	poown *model.ProofOfOwnership,
	txBody *model.ClaimNodeRegistrationTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForLiquidPaymentStopTransaction 

func GetFixturesForLiquidPaymentStopTransaction() (
	txBody *model.LiquidPaymentStopTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForLiquidPaymentTransaction 

func GetFixturesForLiquidPaymentTransaction() (
	txBody *model.LiquidPaymentTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForNoderegistration 

func GetFixturesForNoderegistration(nodeRegistrationQuery query.NodeRegistrationQueryInterface) (
	poownMessage *model.ProofOfOwnershipMessage,
	poown *model.ProofOfOwnership,
	txBody *model.NodeRegistrationTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForRemoveAccountDataset 

func GetFixturesForRemoveAccountDataset() (
	txBody *model.RemoveAccountDatasetTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForRemoveNoderegistration 

func GetFixturesForRemoveNoderegistration() (
	txBody *model.RemoveNodeRegistrationTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForSetupAccountDataset 

func GetFixturesForSetupAccountDataset() (
	txBody *model.SetupAccountDatasetTransactionBody,
	txBodyBytes []byte,
)

func GetFixturesForSignedMempoolTransaction 

func GetFixturesForSignedMempoolTransaction(
	id, timestamp int64,
	sender, recipient []byte,
	escrow bool,
) *model.MempoolTransaction

func GetFixturesForTransaction 

func GetFixturesForTransaction(
	timestamp int64,
	sender, recipient []byte,
	escrow bool,
) *model.Transaction

func GetFixturesForTransactionBytes 

func GetFixturesForTransactionBytes(tx *model.Transaction, sign bool) (txBytes []byte, hashed [32]byte)

func GetFixturesForUpdateNoderegistration 

func GetFixturesForUpdateNoderegistration(nodeRegistrationQuery query.NodeRegistrationQueryInterface) (
	poownMessage *model.ProofOfOwnershipMessage,
	poown *model.ProofOfOwnership,
	txBody *model.UpdateNodeRegistrationTransactionBody,
	txBodyBytes []byte,
)

Types

type AccountBalanceHelper 

type AccountBalanceHelper struct {
	AccountBalanceQuery query.AccountBalanceQueryInterface
	AccountLedgerQuery  query.AccountLedgerQueryInterface
	QueryExecutor       query.ExecutorInterface
	// contains filtered or unexported fields
}

AccountBalanceHelper fields for AccountBalanceHelperInterface for transaction helper

func NewAccountBalanceHelper 

func NewAccountBalanceHelper(
	queryExecutor query.ExecutorInterface,
	accountBalanceQuery query.AccountBalanceQueryInterface,
	accountLedgerQuery query.AccountLedgerQueryInterface,
) *AccountBalanceHelper

func (*AccountBalanceHelper) AddAccountBalance 

func (abh *AccountBalanceHelper) AddAccountBalance(
	address []byte,
	amount int64,
	event model.EventType,
	blockHeight uint32,
	transactionID int64,
	blockTimestamp uint64,
) error

AddAccountBalance add balance and spendable_balance field to the address provided at blockHeight, must be executed inside db transaction scope, there process is:

  • Add new record into account_balance
  • Add new record into account_ledger

func (*AccountBalanceHelper) AddAccountSpendableBalance 

func (abh *AccountBalanceHelper) AddAccountSpendableBalance(address []byte, amount int64) error

AddAccountSpendableBalance add spendable_balance field to the address provided, must be executed inside db transaction scope

func (*AccountBalanceHelper) GetBalanceByAccountAddress 

func (abh *AccountBalanceHelper) GetBalanceByAccountAddress(accountBalance *model.AccountBalance, address []byte, dbTx bool) error

GetBalanceByAccountAddress fetching the balance of an account from database

func (*AccountBalanceHelper) HasEnoughSpendableBalance 

func (abh *AccountBalanceHelper) HasEnoughSpendableBalance(dbTX bool, address []byte, compareBalance int64) (enough bool, err error)

HasEnoughSpendableBalance check if account has enough has spendable balance and will save

type AccountBalanceHelperInterface 

type AccountBalanceHelperInterface interface {
	AddAccountSpendableBalance(address []byte, amount int64) error
	AddAccountBalance(address []byte, amount int64, event model.EventType, blockHeight uint32, transactionID int64,
		blockTimestamp uint64) error
	GetBalanceByAccountAddress(accountBalance *model.AccountBalance, address []byte, dbTx bool) error
	HasEnoughSpendableBalance(dbTX bool, address []byte, compareBalance int64) (enough bool, err error)
}

AccountBalanceHelperInterface methods collection for transaction helper, it for account balance stuff and account ledger also It better to use with QueryExecutor.BeginTX()

type ApprovalEscrowTransaction 

type ApprovalEscrowTransaction struct {
	TransactionObject    *model.Transaction
	Body                 *model.ApprovalEscrowTransactionBody
	BlockQuery           query.BlockQueryInterface
	EscrowQuery          query.EscrowTransactionQueryInterface
	QueryExecutor        query.ExecutorInterface
	TransactionQuery     query.TransactionQueryInterface
	TypeActionSwitcher   TypeActionSwitcher
	AccountBalanceHelper AccountBalanceHelperInterface
	FeeScaleService      fee.FeeScaleServiceInterface
}

ApprovalEscrowTransaction field

func (*ApprovalEscrowTransaction) ApplyConfirmed 

func (tx *ApprovalEscrowTransaction) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed func that for applying Transaction SendZBC type. If Genesis perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount. If Not Genesis, perhaps sender and recipient is exists, so update `account_balance`, `recipient.balance` = current + amount and `sender.balance` = current - amount

func (*ApprovalEscrowTransaction) ApplyUnconfirmed 

func (tx *ApprovalEscrowTransaction) ApplyUnconfirmed() error

ApplyUnconfirmed exec before Confirmed

func (*ApprovalEscrowTransaction) EscrowApplyConfirmed 

func (tx *ApprovalEscrowTransaction) EscrowApplyConfirmed(int64) error

EscrowApplyConfirmed func that for applying Transaction SendZBC type.

func (*ApprovalEscrowTransaction) EscrowApplyUnconfirmed 

func (tx *ApprovalEscrowTransaction) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is applyUnconfirmed specific for Escrow's transaction similar with ApplyUnconfirmed and Escrow.Commission

func (*ApprovalEscrowTransaction) EscrowApproval 

func (tx *ApprovalEscrowTransaction) EscrowApproval(int64, *model.ApprovalEscrowTransactionBody) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending. like: spreading commission and fee, and also more pending tasks

func (*ApprovalEscrowTransaction) EscrowUndoApplyUnconfirmed 

func (tx *ApprovalEscrowTransaction) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*ApprovalEscrowTransaction) EscrowValidate 

func (tx *ApprovalEscrowTransaction) EscrowValidate(dbTx bool) error

EscrowValidate special validation for escrow's transaction

func (*ApprovalEscrowTransaction) Escrowable 

func (tx *ApprovalEscrowTransaction) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*ApprovalEscrowTransaction) GetAmount 

func (tx *ApprovalEscrowTransaction) GetAmount() int64

GetAmount return Amount from TransactionBody

func (*ApprovalEscrowTransaction) GetBodyBytes 

func (tx *ApprovalEscrowTransaction) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*ApprovalEscrowTransaction) GetMinimumFee 

func (tx *ApprovalEscrowTransaction) GetMinimumFee() (int64, error)

func (*ApprovalEscrowTransaction) GetSize 

func (*ApprovalEscrowTransaction) GetSize() (uint32, error)

GetSize of approval transaction body bytes

func (*ApprovalEscrowTransaction) GetTransactionBody 

func (tx *ApprovalEscrowTransaction) GetTransactionBody(transaction *model.Transaction)

GetTransactionBody append isTransaction_TransactionBody oneOf

func (*ApprovalEscrowTransaction) ParseBodyBytes 

func (tx *ApprovalEscrowTransaction) ParseBodyBytes(
	bodyBytes []byte,
) (model.TransactionBodyInterface, error)

ParseBodyBytes validate and parse body bytes to TransactionBody interface

func (*ApprovalEscrowTransaction) SkipMempoolTransaction 

func (tx *ApprovalEscrowTransaction) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction to filter out current Approval escrow transaction when this tx already expired based on new block height

func (*ApprovalEscrowTransaction) UndoApplyUnconfirmed 

func (tx *ApprovalEscrowTransaction) UndoApplyUnconfirmed() error

UndoApplyUnconfirmed func exec before confirmed

func (*ApprovalEscrowTransaction) Validate 

func (tx *ApprovalEscrowTransaction) Validate(dbTx bool) error

Validate is func that for validating to Transaction type. Check transaction fields, spendable balance and more

type ClaimNodeRegistration 

type ClaimNodeRegistration struct {
	TransactionObject       *model.Transaction
	Body                    *model.ClaimNodeRegistrationTransactionBody
	NodeRegistrationQuery   query.NodeRegistrationQueryInterface
	BlockQuery              query.BlockQueryInterface
	QueryExecutor           query.ExecutorInterface
	AuthPoown               auth.NodeAuthValidationInterface
	EscrowQuery             query.EscrowTransactionQueryInterface
	AccountBalanceHelper    AccountBalanceHelperInterface
	FeeScaleService         fee.FeeScaleServiceInterface
	NodeAddressInfoQuery    query.NodeAddressInfoQueryInterface
	NodeAddressInfoStorage  storage.TransactionalCache
	ActiveNodeRegistryCache storage.TransactionalCache
}

ClaimNodeRegistration Implement service layer for claim node registration's transaction

func (*ClaimNodeRegistration) ApplyConfirmed 

func (tx *ClaimNodeRegistration) ApplyConfirmed(blockTimestamp int64) error

func (*ClaimNodeRegistration) ApplyUnconfirmed 

func (tx *ClaimNodeRegistration) ApplyUnconfirmed() error

ApplyUnconfirmed is func that for applying to unconfirmed Transaction `ClaimNodeRegistration` type:

  • perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*ClaimNodeRegistration) EscrowApplyConfirmed 

func (tx *ClaimNodeRegistration) EscrowApplyConfirmed(blockTimestamp int64) error

EscrowApplyConfirmed func that for applying pending escrow transaction.

func (*ClaimNodeRegistration) EscrowApplyUnconfirmed 

func (tx *ClaimNodeRegistration) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is func that for applying to unconfirmed Transaction `ClaimNodeRegistration` type:

  • perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*ClaimNodeRegistration) EscrowApproval 

func (tx *ClaimNodeRegistration) EscrowApproval(
	blockTimestamp int64,
	txBody *model.ApprovalEscrowTransactionBody,
) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending. like: spreading commission and fee, and also more pending tasks

func (*ClaimNodeRegistration) EscrowUndoApplyUnconfirmed 

func (tx *ClaimNodeRegistration) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed func that perform on apply confirm preparation

func (*ClaimNodeRegistration) EscrowValidate 

func (tx *ClaimNodeRegistration) EscrowValidate(dbTX bool) error

EscrowValidate validate node registration transaction and tx body

func (*ClaimNodeRegistration) Escrowable 

func (tx *ClaimNodeRegistration) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*ClaimNodeRegistration) GetAmount 

func (tx *ClaimNodeRegistration) GetAmount() int64

func (*ClaimNodeRegistration) GetBodyBytes 

func (tx *ClaimNodeRegistration) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*ClaimNodeRegistration) GetMinimumFee 

func (tx *ClaimNodeRegistration) GetMinimumFee() (int64, error)

func (*ClaimNodeRegistration) GetSize 

func (tx *ClaimNodeRegistration) GetSize() (uint32, error)

func (*ClaimNodeRegistration) GetTransactionBody 

func (tx *ClaimNodeRegistration) GetTransactionBody(transaction *model.Transaction)

func (*ClaimNodeRegistration) ParseBodyBytes 

func (tx *ClaimNodeRegistration) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*ClaimNodeRegistration) SkipMempoolTransaction 

func (tx *ClaimNodeRegistration) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out of the mempool a node registration tx if there are other node registration tx in mempool to make sure only one node registration tx at the time (the one with highest fee paid) makes it to the same block

func (*ClaimNodeRegistration) UndoApplyUnconfirmed 

func (tx *ClaimNodeRegistration) UndoApplyUnconfirmed() error

func (*ClaimNodeRegistration) Validate 

func (tx *ClaimNodeRegistration) Validate(dbTx bool) error

Validate validate node registration transaction and tx body

type EscrowTypeAction 

type EscrowTypeAction interface {
	// EscrowApplyConfirmed perhaps this method called with QueryExecutor.BeginTX() because inside this process has separated QueryExecutor.Execute
	EscrowApplyConfirmed(blockTimestamp int64) error
	EscrowApplyUnconfirmed() error
	EscrowUndoApplyUnconfirmed() error
	EscrowValidate(dbTx bool) error
	// EscrowApproval handle approval an escrow transaction, execute tasks that was skipped on EscrowApplyConfirmed.
	EscrowApproval(
		blockTimestamp int64,
		txBody *model.ApprovalEscrowTransactionBody,
	) error
}

EscrowTypeAction is escrow transaction type methods collection

type FeeVoteCommitTransaction 

type FeeVoteCommitTransaction struct {
	TransactionObject          *model.Transaction
	Body                       *model.FeeVoteCommitTransactionBody
	FeeScaleService            fee.FeeScaleServiceInterface
	NodeRegistrationQuery      query.NodeRegistrationQueryInterface
	BlockQuery                 query.BlockQueryInterface
	FeeVoteCommitmentVoteQuery query.FeeVoteCommitmentVoteQueryInterface
	AccountBalanceHelper       AccountBalanceHelperInterface
	QueryExecutor              query.ExecutorInterface
	EscrowQuery                query.EscrowTransactionQueryInterface
}

FeeVoteCommitTransaction is Transaction Type that implemented TypeAction

func (*FeeVoteCommitTransaction) ApplyConfirmed 

func (tx *FeeVoteCommitTransaction) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed to apply confirmed transaction FeeVoteCommitTransaction type

func (*FeeVoteCommitTransaction) ApplyUnconfirmed 

func (tx *FeeVoteCommitTransaction) ApplyUnconfirmed() error

ApplyUnconfirmed to apply unconfirmed transaction FeeVoteCommitTransaction type

func (*FeeVoteCommitTransaction) EscrowApplyConfirmed 

func (tx *FeeVoteCommitTransaction) EscrowApplyConfirmed(blockTimestamp int64) (err error)

func (*FeeVoteCommitTransaction) EscrowApplyUnconfirmed 

func (tx *FeeVoteCommitTransaction) EscrowApplyUnconfirmed() (err error)

func (*FeeVoteCommitTransaction) EscrowApproval 

func (tx *FeeVoteCommitTransaction) EscrowApproval(blockTimestamp int64, txBody *model.ApprovalEscrowTransactionBody) (err error)

func (*FeeVoteCommitTransaction) EscrowUndoApplyUnconfirmed 

func (tx *FeeVoteCommitTransaction) EscrowUndoApplyUnconfirmed() error

func (*FeeVoteCommitTransaction) EscrowValidate 

func (tx *FeeVoteCommitTransaction) EscrowValidate(dbTx bool) (err error)

func (*FeeVoteCommitTransaction) Escrowable 

func (tx *FeeVoteCommitTransaction) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Currently doesn't have escrow option

func (*FeeVoteCommitTransaction) GetAmount 

func (tx *FeeVoteCommitTransaction) GetAmount() int64

GetAmount return Amount from TransactionBody

func (*FeeVoteCommitTransaction) GetBodyBytes 

func (tx *FeeVoteCommitTransaction) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*FeeVoteCommitTransaction) GetMinimumFee 

func (tx *FeeVoteCommitTransaction) GetMinimumFee() (int64, error)

GetMinimumFee return minimum fee of transaction TODO: need to calculate the minimum fee

func (*FeeVoteCommitTransaction) GetSize 

func (tx *FeeVoteCommitTransaction) GetSize() (uint32, error)

GetSize is size of transaction body

func (*FeeVoteCommitTransaction) GetTransactionBody 

func (tx *FeeVoteCommitTransaction) GetTransactionBody(transaction *model.Transaction)

GetTransactionBody return transaction body of FeeVoteCommitTransaction transactions

func (*FeeVoteCommitTransaction) ParseBodyBytes 

func (tx *FeeVoteCommitTransaction) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*FeeVoteCommitTransaction) SkipMempoolTransaction 

func (tx *FeeVoteCommitTransaction) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out current fee commit vote tx when

  • Current time is already not commit vote phase based on new block timestamp
  • There are other tx fee commit vote with same sender in mempool
  • Fee commit vote tx for current phase already exist in previous block

func (*FeeVoteCommitTransaction) UndoApplyUnconfirmed 

func (tx *FeeVoteCommitTransaction) UndoApplyUnconfirmed() error

UndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*FeeVoteCommitTransaction) Validate 

func (tx *FeeVoteCommitTransaction) Validate(dbTx bool) error

Validate to validating Transaction FeeVoteCommitTransaction type

type FeeVoteRevealTransaction 

type FeeVoteRevealTransaction struct {
	TransactionObject      *model.Transaction
	Body                   *model.FeeVoteRevealTransactionBody
	FeeScaleService        fee.FeeScaleServiceInterface
	SignatureInterface     crypto.SignatureInterface
	BlockQuery             query.BlockQueryInterface
	NodeRegistrationQuery  query.NodeRegistrationQueryInterface
	FeeVoteCommitVoteQuery query.FeeVoteCommitmentVoteQueryInterface
	FeeVoteRevealVoteQuery query.FeeVoteRevealVoteQueryInterface
	AccountBalanceHelper   AccountBalanceHelperInterface
	QueryExecutor          query.ExecutorInterface
	EscrowQuery            query.EscrowTransactionQueryInterface
}

func (*FeeVoteRevealTransaction) ApplyConfirmed 

func (tx *FeeVoteRevealTransaction) ApplyConfirmed(blockTimestamp int64) (err error)

ApplyConfirmed applying transaction, will store ledger, account balance update, and also the transaction it self

func (*FeeVoteRevealTransaction) ApplyUnconfirmed 

func (tx *FeeVoteRevealTransaction) ApplyUnconfirmed() error

ApplyUnconfirmed to apply unconfirmed transaction

func (*FeeVoteRevealTransaction) EscrowApplyConfirmed 

func (tx *FeeVoteRevealTransaction) EscrowApplyConfirmed(blockTimestamp int64) (err error)

func (*FeeVoteRevealTransaction) EscrowApplyUnconfirmed 

func (tx *FeeVoteRevealTransaction) EscrowApplyUnconfirmed() (err error)

func (*FeeVoteRevealTransaction) EscrowApproval 

func (tx *FeeVoteRevealTransaction) EscrowApproval(blockTimestamp int64, txBody *model.ApprovalEscrowTransactionBody) (err error)

func (*FeeVoteRevealTransaction) EscrowUndoApplyUnconfirmed 

func (tx *FeeVoteRevealTransaction) EscrowUndoApplyUnconfirmed() error

func (*FeeVoteRevealTransaction) EscrowValidate 

func (tx *FeeVoteRevealTransaction) EscrowValidate(dbTx bool) (err error)

func (*FeeVoteRevealTransaction) Escrowable 

func (tx *FeeVoteRevealTransaction) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Currently doesn't have escrow option

func (*FeeVoteRevealTransaction) GetAmount 

func (tx *FeeVoteRevealTransaction) GetAmount() int64

GetAmount return Amount from TransactionBody

func (*FeeVoteRevealTransaction) GetBodyBytes 

func (tx *FeeVoteRevealTransaction) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*FeeVoteRevealTransaction) GetFeeVoteInfoBytes 

func (tx *FeeVoteRevealTransaction) GetFeeVoteInfoBytes() []byte

GetFeeVoteInfoBytes will build bytes from model.FeeVoteInfo

func (*FeeVoteRevealTransaction) GetMinimumFee 

func (tx *FeeVoteRevealTransaction) GetMinimumFee() (int64, error)

GetMinimumFee calculate fee

func (*FeeVoteRevealTransaction) GetSize 

func (tx *FeeVoteRevealTransaction) GetSize() (uint32, error)

GetSize send zbc Amount should be 8

func (*FeeVoteRevealTransaction) GetTransactionBody 

func (tx *FeeVoteRevealTransaction) GetTransactionBody(transaction *model.Transaction)

GetTransactionBody append isTransaction_TransactionBody oneOf

func (*FeeVoteRevealTransaction) ParseBodyBytes 

func (*FeeVoteRevealTransaction) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*FeeVoteRevealTransaction) SkipMempoolTransaction 

func (tx *FeeVoteRevealTransaction) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out current fee reveal vote tx when

  • Current time is already not reveal vote phase based on new block timestamp
  • There are other tx fee reveal vote with same sender in mempool
  • Fee reveal vote tx for current phase already exist in previous block

func (*FeeVoteRevealTransaction) UndoApplyUnconfirmed 

func (tx *FeeVoteRevealTransaction) UndoApplyUnconfirmed() error

UndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*FeeVoteRevealTransaction) Validate 

func (tx *FeeVoteRevealTransaction) Validate(dbTx bool) error

Validate for validating the transaction concerned

type LiquidPaymentStopTransaction 

type LiquidPaymentStopTransaction struct {
	TransactionObject             *model.Transaction
	Body                          *model.LiquidPaymentStopTransactionBody
	QueryExecutor                 query.ExecutorInterface
	TransactionQuery              query.TransactionQueryInterface
	LiquidPaymentTransactionQuery query.LiquidPaymentTransactionQueryInterface
	AccountBalanceHelper          AccountBalanceHelperInterface
	TypeActionSwitcher            TypeActionSwitcher
	EscrowQuery                   query.EscrowTransactionQueryInterface
	FeeScaleService               fee.FeeScaleServiceInterface
}

LiquidPaymentStopTransaction is Transaction Type that implemented TypeAction

func (*LiquidPaymentStopTransaction) ApplyConfirmed 

func (tx *LiquidPaymentStopTransaction) ApplyConfirmed(blockTimestamp int64) error

func (*LiquidPaymentStopTransaction) ApplyUnconfirmed 

func (tx *LiquidPaymentStopTransaction) ApplyUnconfirmed() error

func (*LiquidPaymentStopTransaction) EscrowApplyConfirmed 

func (tx *LiquidPaymentStopTransaction) EscrowApplyConfirmed(blockTimestamp int64) (err error)

func (*LiquidPaymentStopTransaction) EscrowApplyUnconfirmed 

func (tx *LiquidPaymentStopTransaction) EscrowApplyUnconfirmed() error

func (*LiquidPaymentStopTransaction) EscrowApproval 

func (tx *LiquidPaymentStopTransaction) EscrowApproval(blockTimestamp int64, txBody *model.ApprovalEscrowTransactionBody) (err error)

func (*LiquidPaymentStopTransaction) EscrowUndoApplyUnconfirmed 

func (tx *LiquidPaymentStopTransaction) EscrowUndoApplyUnconfirmed() error

func (*LiquidPaymentStopTransaction) EscrowValidate 

func (tx *LiquidPaymentStopTransaction) EscrowValidate(dbTx bool) (err error)

func (*LiquidPaymentStopTransaction) Escrowable 

func (tx *LiquidPaymentStopTransaction) Escrowable() (EscrowTypeAction, bool)

func (*LiquidPaymentStopTransaction) GetAmount 

func (tx *LiquidPaymentStopTransaction) GetAmount() int64

func (*LiquidPaymentStopTransaction) GetBodyBytes 

func (tx *LiquidPaymentStopTransaction) GetBodyBytes() ([]byte, error)

func (*LiquidPaymentStopTransaction) GetMinimumFee 

func (tx *LiquidPaymentStopTransaction) GetMinimumFee() (int64, error)

func (*LiquidPaymentStopTransaction) GetSize 

func (tx *LiquidPaymentStopTransaction) GetSize() (uint32, error)

func (*LiquidPaymentStopTransaction) GetTransactionBody 

func (tx *LiquidPaymentStopTransaction) GetTransactionBody(transaction *model.Transaction)

func (*LiquidPaymentStopTransaction) ParseBodyBytes 

func (tx *LiquidPaymentStopTransaction) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

func (*LiquidPaymentStopTransaction) SkipMempoolTransaction 

func (tx *LiquidPaymentStopTransaction) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out of the mempool tx under specific condition

func (*LiquidPaymentStopTransaction) UndoApplyUnconfirmed 

func (tx *LiquidPaymentStopTransaction) UndoApplyUnconfirmed() error

func (*LiquidPaymentStopTransaction) Validate 

func (tx *LiquidPaymentStopTransaction) Validate(dbTx bool) error

type LiquidPaymentTransaction 

type LiquidPaymentTransaction struct {
	TransactionObject             *model.Transaction
	Body                          *model.LiquidPaymentTransactionBody
	QueryExecutor                 query.ExecutorInterface
	LiquidPaymentTransactionQuery query.LiquidPaymentTransactionQueryInterface
	AccountBalanceHelper          AccountBalanceHelperInterface
	EscrowQuery                   query.EscrowTransactionQueryInterface
	FeeScaleService               fee.FeeScaleServiceInterface
}

LiquidPaymentTransaction is Transaction Type that implemented TypeAction

func (*LiquidPaymentTransaction) ApplyConfirmed 

func (tx *LiquidPaymentTransaction) ApplyConfirmed(blockTimestamp int64) (err error)

func (*LiquidPaymentTransaction) ApplyUnconfirmed 

func (tx *LiquidPaymentTransaction) ApplyUnconfirmed() (err error)

func (*LiquidPaymentTransaction) CompletePayment 

func (tx *LiquidPaymentTransaction) CompletePayment(blockHeight uint32, blockTimestamp, firstAppliedTimestamp int64) error

func (*LiquidPaymentTransaction) EscrowApplyConfirmed 

func (tx *LiquidPaymentTransaction) EscrowApplyConfirmed(blockTimestamp int64) (err error)

func (*LiquidPaymentTransaction) EscrowApplyUnconfirmed 

func (tx *LiquidPaymentTransaction) EscrowApplyUnconfirmed() (err error)

func (*LiquidPaymentTransaction) EscrowApproval 

func (tx *LiquidPaymentTransaction) EscrowApproval(blockTimestamp int64, txBody *model.ApprovalEscrowTransactionBody) (err error)

func (*LiquidPaymentTransaction) EscrowUndoApplyUnconfirmed 

func (tx *LiquidPaymentTransaction) EscrowUndoApplyUnconfirmed() (err error)

func (*LiquidPaymentTransaction) EscrowValidate 

func (tx *LiquidPaymentTransaction) EscrowValidate(dbTx bool) (err error)

func (*LiquidPaymentTransaction) Escrowable 

func (tx *LiquidPaymentTransaction) Escrowable() (EscrowTypeAction, bool)

func (*LiquidPaymentTransaction) GetAmount 

func (tx *LiquidPaymentTransaction) GetAmount() int64

func (*LiquidPaymentTransaction) GetBodyBytes 

func (tx *LiquidPaymentTransaction) GetBodyBytes() ([]byte, error)

func (*LiquidPaymentTransaction) GetMinimumFee 

func (tx *LiquidPaymentTransaction) GetMinimumFee() (int64, error)

func (*LiquidPaymentTransaction) GetSize 

func (tx *LiquidPaymentTransaction) GetSize() (uint32, error)

func (*LiquidPaymentTransaction) GetTransactionBody 

func (tx *LiquidPaymentTransaction) GetTransactionBody(transaction *model.Transaction)

func (*LiquidPaymentTransaction) ParseBodyBytes 

func (tx *LiquidPaymentTransaction) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

func (*LiquidPaymentTransaction) SkipMempoolTransaction 

func (tx *LiquidPaymentTransaction) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out of the mempool tx under specific condition

func (*LiquidPaymentTransaction) UndoApplyUnconfirmed 

func (tx *LiquidPaymentTransaction) UndoApplyUnconfirmed() (err error)

func (*LiquidPaymentTransaction) Validate 

func (tx *LiquidPaymentTransaction) Validate(dbTx bool) error

type LiquidPaymentTransactionInterface 

type LiquidPaymentTransactionInterface interface {
	CompletePayment(blockHeight uint32, blockTimestamp, firstAppliedTimestamp int64) error
}

type MultiSignatureTransaction 

type MultiSignatureTransaction struct {
	TransactionObject *model.Transaction
	Body              *model.MultiSignatureTransactionBody
	FeeScaleService   fee.FeeScaleServiceInterface
	TransactionUtil   UtilInterface
	TypeSwitcher      TypeActionSwitcher
	Signature         crypto.SignatureInterface
	EscrowQuery       query.EscrowTransactionQueryInterface
	// multisig helpers
	MultisigUtil             MultisigTransactionUtilInterface
	SignatureInfoHelper      SignatureInfoHelperInterface
	MultisignatureInfoHelper MultisignatureInfoHelperInterface
	PendingTransactionHelper PendingTransactionHelperInterface
	// general helpers
	AccountBalanceHelper AccountBalanceHelperInterface
	TransactionHelper    TransactionHelperInterface
	QueryExecutor        query.ExecutorInterface
}

MultiSignatureTransaction represent wrapper transaction type that require multiple signer to approve the transaction wrapped

func (*MultiSignatureTransaction) ApplyConfirmed 

func (tx *MultiSignatureTransaction) ApplyConfirmed(blockTimestamp int64) error

func (*MultiSignatureTransaction) ApplyUnconfirmed 

func (tx *MultiSignatureTransaction) ApplyUnconfirmed() error

func (*MultiSignatureTransaction) EscrowApplyConfirmed 

func (tx *MultiSignatureTransaction) EscrowApplyConfirmed(blockTimestamp int64) error

func (*MultiSignatureTransaction) EscrowApplyUnconfirmed 

func (tx *MultiSignatureTransaction) EscrowApplyUnconfirmed() error

func (*MultiSignatureTransaction) EscrowApproval 

func (tx *MultiSignatureTransaction) EscrowApproval(blockTimestamp int64, txBody *model.ApprovalEscrowTransactionBody) (err error)

func (*MultiSignatureTransaction) EscrowUndoApplyUnconfirmed 

func (tx *MultiSignatureTransaction) EscrowUndoApplyUnconfirmed() error

func (*MultiSignatureTransaction) EscrowValidate 

func (tx *MultiSignatureTransaction) EscrowValidate(dbTx bool) error

func (*MultiSignatureTransaction) Escrowable 

func (tx *MultiSignatureTransaction) Escrowable() (EscrowTypeAction, bool)

func (*MultiSignatureTransaction) GetAmount 

func (*MultiSignatureTransaction) GetAmount() int64

func (*MultiSignatureTransaction) GetBodyBytes 

func (tx *MultiSignatureTransaction) GetBodyBytes() ([]byte, error)

func (*MultiSignatureTransaction) GetMinimumFee 

func (tx *MultiSignatureTransaction) GetMinimumFee() (int64, error)

func (*MultiSignatureTransaction) GetSize 

func (tx *MultiSignatureTransaction) GetSize() (uint32, error)

func (*MultiSignatureTransaction) GetTransactionBody 

func (tx *MultiSignatureTransaction) GetTransactionBody(transaction *model.Transaction)

func (*MultiSignatureTransaction) ParseBodyBytes 

func (tx *MultiSignatureTransaction) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

func (*MultiSignatureTransaction) SkipMempoolTransaction 

func (*MultiSignatureTransaction) SkipMempoolTransaction([]*model.Transaction, int64, uint32) (bool, error)

func (*MultiSignatureTransaction) UndoApplyUnconfirmed 

func (tx *MultiSignatureTransaction) UndoApplyUnconfirmed() error

func (*MultiSignatureTransaction) Validate 

func (tx *MultiSignatureTransaction) Validate(dbTx bool) error

Validate dbTx specify whether validation should read from transaction state or db state

type MultisigTransactionUtil 

type MultisigTransactionUtil struct{}

func NewMultisigTransactionUtil 

func NewMultisigTransactionUtil() *MultisigTransactionUtil

func (*MultisigTransactionUtil) CheckMultisigComplete 

func (mtu *MultisigTransactionUtil) CheckMultisigComplete(
	transactionUtil UtilInterface,
	multisignatureInfoHelper MultisignatureInfoHelperInterface,
	signatureInfoHelper SignatureInfoHelperInterface,
	pendingTransactionHelper PendingTransactionHelperInterface,
	body *model.MultiSignatureTransactionBody, txHeight uint32,
) ([]*model.MultiSignatureTransactionBody, error)

func (*MultisigTransactionUtil) ValidateMultisignatureInfo 

func (*MultisigTransactionUtil) ValidateMultisignatureInfo(multisigInfo *model.MultiSignatureInfo) error

func (*MultisigTransactionUtil) ValidatePendingTransactionBytes 

func (mtu *MultisigTransactionUtil) ValidatePendingTransactionBytes(
	transactionUtil UtilInterface,
	typeSwitcher TypeActionSwitcher,
	multisigInfoHelper MultisignatureInfoHelperInterface,
	pendingTransactionHelper PendingTransactionHelperInterface,
	multisigInfo *model.MultiSignatureInfo,
	senderAddress, unsignedTxBytes []byte,
	blockHeight uint32,
	dbTx bool,
) error

func (*MultisigTransactionUtil) ValidateSignatureInfo 

func (mtu *MultisigTransactionUtil) ValidateSignatureInfo(
	signature crypto.SignatureInterface,
	signatureInfo *model.SignatureInfo,
	multiSignatureInfoAddresses map[string]bool,
) error

type MultisigTransactionUtilInterface 

type MultisigTransactionUtilInterface interface {
	CheckMultisigComplete(
		transactionUtil UtilInterface,
		multisignatureInfoHelper MultisignatureInfoHelperInterface,
		signatureInfoHelper SignatureInfoHelperInterface,
		pendingTransactionHelper PendingTransactionHelperInterface,
		tx *model.MultiSignatureTransactionBody, txHeight uint32,
	) ([]*model.MultiSignatureTransactionBody, error)
	ValidatePendingTransactionBytes(
		transactionUtil UtilInterface,
		typeSwitcher TypeActionSwitcher,
		multisigInfoHelper MultisignatureInfoHelperInterface,
		pendingTransactionHelper PendingTransactionHelperInterface,
		multisigInfo *model.MultiSignatureInfo,
		senderAddress, unsignedTxBytes []byte,
		blockHeight uint32,
		dbTx bool,
	) error
	ValidateMultisignatureInfo(info *model.MultiSignatureInfo) error
	ValidateSignatureInfo(
		signature crypto.SignatureInterface, signatureInfo *model.SignatureInfo, multisignatureAddresses map[string]bool,
	) error
}

type MultisignatureInfoHelper 

type MultisignatureInfoHelper struct {
	MultisignatureInfoQuery        query.MultisignatureInfoQueryInterface
	MultiSignatureParticipantQuery query.MultiSignatureParticipantQueryInterface
	QueryExecutor                  query.ExecutorInterface
}

func (*MultisignatureInfoHelper) GetMultisigInfoByAddress 

func (msi *MultisignatureInfoHelper) GetMultisigInfoByAddress(
	multisigInfo *model.MultiSignatureInfo,
	multisigAddress []byte,
	blockHeight uint32,
) error

func (*MultisignatureInfoHelper) InsertMultisignatureInfo 

func (msi *MultisignatureInfoHelper) InsertMultisignatureInfo(multisigInfo *model.MultiSignatureInfo) error

type MultisignatureInfoHelperInterface 

type MultisignatureInfoHelperInterface interface {
	GetMultisigInfoByAddress(
		multisigInfo *model.MultiSignatureInfo,
		multisigAddress []byte,
		blockHeight uint32,
	) error
	InsertMultisignatureInfo(
		multisigInfo *model.MultiSignatureInfo,
	) error
}

type NodeRegistration 

type NodeRegistration struct {
	TransactionObject        *model.Transaction
	Body                     *model.NodeRegistrationTransactionBody
	NodeRegistrationQuery    query.NodeRegistrationQueryInterface
	BlockQuery               query.BlockQueryInterface
	ParticipationScoreQuery  query.ParticipationScoreQueryInterface
	QueryExecutor            query.ExecutorInterface
	AuthPoown                auth.NodeAuthValidationInterface
	EscrowQuery              query.EscrowTransactionQueryInterface
	AccountBalanceHelper     AccountBalanceHelperInterface
	FeeScaleService          fee.FeeScaleServiceInterface
	PendingNodeRegistryCache storage.TransactionalCache
}

NodeRegistration Implement service layer for (new) node registration's transaction

func (*NodeRegistration) ApplyConfirmed 

func (tx *NodeRegistration) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed method for confirmed the transaction and store into database

func (*NodeRegistration) ApplyUnconfirmed 

func (tx *NodeRegistration) ApplyUnconfirmed() error

ApplyUnconfirmed is func that for applying to unconfirmed Transaction `NodeRegistration` type:

  • perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*NodeRegistration) EscrowApplyConfirmed 

func (tx *NodeRegistration) EscrowApplyConfirmed(blockTimestamp int64) error

EscrowApplyConfirmed func that for applying Transaction SendZBC type

func (*NodeRegistration) EscrowApplyUnconfirmed 

func (tx *NodeRegistration) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is applyUnconfirmed specific for Escrow's transaction similar with ApplyUnconfirmed and Escrow.Commission

func (*NodeRegistration) EscrowApproval 

func (tx *NodeRegistration) EscrowApproval(
	blockTimestamp int64,
	txBody *model.ApprovalEscrowTransactionBody,
) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending. like: spreading commission and fee, and also more pending tasks

func (*NodeRegistration) EscrowUndoApplyUnconfirmed 

func (tx *NodeRegistration) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*NodeRegistration) EscrowValidate 

func (tx *NodeRegistration) EscrowValidate(dbTx bool) error

EscrowValidate special validation for escrow's transaction

func (*NodeRegistration) Escrowable 

func (tx *NodeRegistration) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*NodeRegistration) GetAmount 

func (tx *NodeRegistration) GetAmount() int64

func (*NodeRegistration) GetBodyBytes 

func (tx *NodeRegistration) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*NodeRegistration) GetMinimumFee 

func (tx *NodeRegistration) GetMinimumFee() (int64, error)

func (*NodeRegistration) GetSize 

func (tx *NodeRegistration) GetSize() (uint32, error)

func (*NodeRegistration) GetTransactionBody 

func (tx *NodeRegistration) GetTransactionBody(transaction *model.Transaction)

func (*NodeRegistration) ParseBodyBytes 

func (tx *NodeRegistration) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*NodeRegistration) SkipMempoolTransaction 

func (tx *NodeRegistration) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out of the mempool a node registration tx if there are other node registration tx in mempool to make sure only one node registration tx at the time (the one with highest fee paid) makes it to the same block

func (*NodeRegistration) UndoApplyUnconfirmed 

func (tx *NodeRegistration) UndoApplyUnconfirmed() error

func (*NodeRegistration) Validate 

func (tx *NodeRegistration) Validate(dbTx bool) error

Validate validate node registration transaction and tx body

type PendingTransactionHelper 

type PendingTransactionHelper struct {
	MultisignatureInfoQuery query.MultisignatureInfoQueryInterface
	PendingTransactionQuery query.PendingTransactionQueryInterface
	TransactionUtil         UtilInterface
	TypeSwitcher            TypeActionSwitcher
	QueryExecutor           query.ExecutorInterface
}

func (*PendingTransactionHelper) ApplyConfirmedPendingTransaction 

func (pth *PendingTransactionHelper) ApplyConfirmedPendingTransaction(
	pendingTransactionBytes []byte, txHeight uint32, blockTimestamp int64,
) (*model.Transaction, error)

func (*PendingTransactionHelper) ApplyUnconfirmedPendingTransaction 

func (pth *PendingTransactionHelper) ApplyUnconfirmedPendingTransaction(
	pendingTransactionBytes []byte,
) error

func (*PendingTransactionHelper) GetPendingTransactionByHash 

func (pth *PendingTransactionHelper) GetPendingTransactionByHash(
	pendingTx *model.PendingTransaction,
	pendingTransactionHash []byte,
	pendingTransactionStatuses []model.PendingTransactionStatus,
	blockHeight uint32,
	dbTx bool,
) error

func (*PendingTransactionHelper) GetPendingTransactionBySenderAddress 

func (pth *PendingTransactionHelper) GetPendingTransactionBySenderAddress(
	senderAddress []byte, txHeight uint32,
) ([]*model.PendingTransaction, error)

func (*PendingTransactionHelper) InsertPendingTransaction 

func (pth *PendingTransactionHelper) InsertPendingTransaction(
	pendingTransaction *model.PendingTransaction,
) error

func (*PendingTransactionHelper) UndoApplyUnconfirmedPendingTransaction 

func (pth *PendingTransactionHelper) UndoApplyUnconfirmedPendingTransaction(pendingTransactionBytes []byte) error

type PendingTransactionHelperInterface 

type PendingTransactionHelperInterface interface {
	InsertPendingTransaction(
		pendingTransaction *model.PendingTransaction,
	) error
	GetPendingTransactionByHash(
		pendingTransaction *model.PendingTransaction,
		pendingTransactionHash []byte,
		pendingTransactionStatuses []model.PendingTransactionStatus,
		blockHeight uint32,
		dbTx bool,
	) error
	GetPendingTransactionBySenderAddress(
		senderAddress []byte, txHeight uint32,
	) ([]*model.PendingTransaction, error)
	ApplyUnconfirmedPendingTransaction(pendingTransactionBytes []byte) error
	UndoApplyUnconfirmedPendingTransaction(pendingTransactionBytes []byte) error
	ApplyConfirmedPendingTransaction(
		pendingTransaction []byte, txHeight uint32, blockTimestamp int64,
	) (*model.Transaction, error)
}

type RemoveAccountDataset 

type RemoveAccountDataset struct {
	TransactionObject    *model.Transaction
	Body                 *model.RemoveAccountDatasetTransactionBody
	AccountDatasetQuery  query.AccountDatasetQueryInterface
	QueryExecutor        query.ExecutorInterface
	EscrowQuery          query.EscrowTransactionQueryInterface
	AccountBalanceHelper AccountBalanceHelperInterface
	FeeScaleService      fee.FeeScaleServiceInterface
}

RemoveAccountDataset has fields that's needed

func (*RemoveAccountDataset) ApplyConfirmed 

func (tx *RemoveAccountDataset) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed is func that for applying Transaction RemoveAccountDataset type,

func (*RemoveAccountDataset) ApplyUnconfirmed 

func (tx *RemoveAccountDataset) ApplyUnconfirmed() error

ApplyUnconfirmed is func that for applying to unconfirmed Transaction `RemoveAccountDataset` type

func (*RemoveAccountDataset) EscrowApplyConfirmed 

func (tx *RemoveAccountDataset) EscrowApplyConfirmed(blockTimestamp int64) error

EscrowApplyConfirmed is func that for applying Transaction RemoveAccountDataset type,

func (*RemoveAccountDataset) EscrowApplyUnconfirmed 

func (tx *RemoveAccountDataset) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is func that for applying to unconfirmed Transaction `RemoveAccountDataset` type

func (*RemoveAccountDataset) EscrowApproval 

func (tx *RemoveAccountDataset) EscrowApproval(
	blockTimestamp int64,
	txBody *model.ApprovalEscrowTransactionBody,
) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending. like: spreading commission and fee, and also more pending tasks

func (*RemoveAccountDataset) EscrowUndoApplyUnconfirmed 

func (tx *RemoveAccountDataset) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*RemoveAccountDataset) EscrowValidate 

func (tx *RemoveAccountDataset) EscrowValidate(dbTx bool) error

EscrowValidate is func that for validating to Transaction RemoveAccountDataset type That specs:

  • Check existing Account Dataset
  • Check Spendable Balance sender

func (*RemoveAccountDataset) Escrowable 

func (tx *RemoveAccountDataset) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*RemoveAccountDataset) GetAmount 

func (tx *RemoveAccountDataset) GetAmount() int64

GetAmount return Amount from TransactionBody

func (*RemoveAccountDataset) GetBodyBytes 

func (tx *RemoveAccountDataset) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*RemoveAccountDataset) GetMinimumFee 

func (tx *RemoveAccountDataset) GetMinimumFee() (int64, error)

GetMinimumFee return minimum fee of transaction TODO: need to calculate the minimum fee

func (*RemoveAccountDataset) GetSize 

func (tx *RemoveAccountDataset) GetSize() (uint32, error)

GetSize is size of transaction body

func (*RemoveAccountDataset) GetTransactionBody 

func (tx *RemoveAccountDataset) GetTransactionBody(transaction *model.Transaction)

GetTransactionBody return transaction body of RemoveAccountDataset transactions

func (*RemoveAccountDataset) ParseBodyBytes 

func (tx *RemoveAccountDataset) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*RemoveAccountDataset) SkipMempoolTransaction 

func (tx *RemoveAccountDataset) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction this tx type has no mempool filter

func (*RemoveAccountDataset) UndoApplyUnconfirmed 

func (tx *RemoveAccountDataset) UndoApplyUnconfirmed() error

UndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*RemoveAccountDataset) Validate 

func (tx *RemoveAccountDataset) Validate(dbTx bool) error

Validate is func that for validating to Transaction RemoveAccountDataset type That specs:

  • Check existing Account Dataset
  • Check Spendable Balance sender

type RemoveNodeRegistration 

type RemoveNodeRegistration struct {
	TransactionObject        *model.Transaction
	Body                     *model.RemoveNodeRegistrationTransactionBody
	NodeRegistrationQuery    query.NodeRegistrationQueryInterface
	NodeAddressInfoQuery     query.NodeAddressInfoQueryInterface
	QueryExecutor            query.ExecutorInterface
	AccountBalanceHelper     AccountBalanceHelperInterface
	EscrowQuery              query.EscrowTransactionQueryInterface
	FeeScaleService          fee.FeeScaleServiceInterface
	NodeAddressInfoStorage   storage.TransactionalCache
	PendingNodeRegistryCache storage.TransactionalCache
	ActiveNodeRegistryCache  storage.TransactionalCache
}

RemoveNodeRegistration Implement service layer for (new) node registration's transaction

func (*RemoveNodeRegistration) ApplyConfirmed 

func (tx *RemoveNodeRegistration) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed method for confirmed the transaction and store into database

func (*RemoveNodeRegistration) ApplyUnconfirmed 

func (tx *RemoveNodeRegistration) ApplyUnconfirmed() error

ApplyUnconfirmed is func that for applying to unconfirmed Transaction `RemoveNodeRegistration` type:

  • perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*RemoveNodeRegistration) EscrowApplyConfirmed 

func (tx *RemoveNodeRegistration) EscrowApplyConfirmed(blockTimestamp int64) error

EscrowApplyConfirmed method for confirmed the transaction and store into database

func (*RemoveNodeRegistration) EscrowApplyUnconfirmed 

func (tx *RemoveNodeRegistration) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is func that for applying to unconfirmed Transaction `RemoveNodeRegistration` type. Perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*RemoveNodeRegistration) EscrowApproval 

func (tx *RemoveNodeRegistration) EscrowApproval(
	blockTimestamp int64,
	txBody *model.ApprovalEscrowTransactionBody,
) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending. like: spreading commission and fee, and also more pending tasks

func (*RemoveNodeRegistration) EscrowUndoApplyUnconfirmed 

func (tx *RemoveNodeRegistration) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed func that perform on apply confirm preparation

func (*RemoveNodeRegistration) EscrowValidate 

func (tx *RemoveNodeRegistration) EscrowValidate(dbTx bool) error

EscrowValidate validate node registration transaction and tx body

func (*RemoveNodeRegistration) Escrowable 

func (tx *RemoveNodeRegistration) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*RemoveNodeRegistration) GetAmount 

func (tx *RemoveNodeRegistration) GetAmount() int64

func (*RemoveNodeRegistration) GetBodyBytes 

func (tx *RemoveNodeRegistration) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*RemoveNodeRegistration) GetMinimumFee 

func (tx *RemoveNodeRegistration) GetMinimumFee() (int64, error)

func (*RemoveNodeRegistration) GetSize 

func (tx *RemoveNodeRegistration) GetSize() (uint32, error)

func (*RemoveNodeRegistration) GetTransactionBody 

func (tx *RemoveNodeRegistration) GetTransactionBody(transaction *model.Transaction)

func (*RemoveNodeRegistration) ParseBodyBytes 

func (tx *RemoveNodeRegistration) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*RemoveNodeRegistration) SkipMempoolTransaction 

func (tx *RemoveNodeRegistration) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out of the mempool a node registration tx if there are other node registration tx in mempool to make sure only one node registration tx at the time (the one with highest fee paid) makes it to the same block

func (*RemoveNodeRegistration) UndoApplyUnconfirmed 

func (tx *RemoveNodeRegistration) UndoApplyUnconfirmed() error

func (*RemoveNodeRegistration) Validate 

func (tx *RemoveNodeRegistration) Validate(dbTx bool) error

Validate validate node registration transaction and tx body

type SendZBC 

type SendZBC struct {
	TransactionObject    *model.Transaction
	Body                 *model.SendZBCTransactionBody
	QueryExecutor        query.ExecutorInterface
	EscrowQuery          query.EscrowTransactionQueryInterface
	BlockQuery           query.BlockQueryInterface
	FeeScaleService      fee.FeeScaleServiceInterface
	AccountBalanceHelper AccountBalanceHelperInterface
}

SendZBC is Transaction Type that implemented TypeAction

func (*SendZBC) ApplyConfirmed 

func (tx *SendZBC) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed func that for applying Transaction SendZBC type. If Genesis:

  • perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

If Not Genesis:

  • perhaps sender and recipient is exists, so update `account_balance`, `recipient.balance` = current + amount and `sender.balance` = current - amount

func (*SendZBC) ApplyUnconfirmed 

func (tx *SendZBC) ApplyUnconfirmed() error

ApplyUnconfirmed is func that for applying to unconfirmed Transaction `SendZBC` type:

  • perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*SendZBC) EscrowApplyConfirmed 

func (tx *SendZBC) EscrowApplyConfirmed(blockTimestamp int64) error

EscrowApplyConfirmed func that for applying Transaction SendZBC type, insert and update balance, account ledger, and escrow

func (*SendZBC) EscrowApplyUnconfirmed 

func (tx *SendZBC) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is applyUnconfirmed specific for Escrow's transaction similar with ApplyUnconfirmed and Escrow.Commission

func (*SendZBC) EscrowApproval 

func (tx *SendZBC) EscrowApproval(
	blockTimestamp int64,
	txBody *model.ApprovalEscrowTransactionBody,
) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending. like: spreading commission and fee, and also more pending tasks

func (*SendZBC) EscrowUndoApplyUnconfirmed 

func (tx *SendZBC) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*SendZBC) EscrowValidate 

func (tx *SendZBC) EscrowValidate(dbTx bool) error

EscrowValidate special validation for escrow's transaction

func (*SendZBC) Escrowable 

func (tx *SendZBC) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*SendZBC) GetAmount 

func (tx *SendZBC) GetAmount() int64

GetAmount return Amount from TransactionBody

func (*SendZBC) GetBodyBytes 

func (tx *SendZBC) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*SendZBC) GetMinimumFee 

func (tx *SendZBC) GetMinimumFee() (int64, error)

func (*SendZBC) GetSize 

func (*SendZBC) GetSize() (uint32, error)

GetSize send zbc Amount should be 8

func (*SendZBC) GetTransactionBody 

func (tx *SendZBC) GetTransactionBody(transaction *model.Transaction)

GetTransactionBody append isTransaction_TransactionBody oneOf

func (*SendZBC) ParseBodyBytes 

func (tx *SendZBC) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*SendZBC) SkipMempoolTransaction 

func (tx *SendZBC) SkipMempoolTransaction([]*model.Transaction, int64, uint32) (bool, error)

SkipMempoolTransaction this tx type has no mempool filter

func (*SendZBC) UndoApplyUnconfirmed 

func (tx *SendZBC) UndoApplyUnconfirmed() error

UndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*SendZBC) Validate 

func (tx *SendZBC) Validate(dbTx bool) error

Validate is func that for validating to Transaction SendZBC type That specs:

  • If Genesis, sender and recipient allowed not exists,
  • If Not Genesis, sender and recipient must be exists, `sender.spendable_balance` must bigger than amount

type SetupAccountDataset 

type SetupAccountDataset struct {
	TransactionObject    *model.Transaction
	Body                 *model.SetupAccountDatasetTransactionBody
	AccountDatasetQuery  query.AccountDatasetQueryInterface
	QueryExecutor        query.ExecutorInterface
	EscrowQuery          query.EscrowTransactionQueryInterface
	AccountBalanceHelper AccountBalanceHelperInterface
	TransactionQuery     query.TransactionQueryInterface
	FeeScaleService      fee.FeeScaleServiceInterface
}

SetupAccountDataset fields that's needed

func (*SetupAccountDataset) ApplyConfirmed 

func (tx *SetupAccountDataset) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed is func that for applying Transaction SetupAccountDataset type, And Perhaps EscrowApplyConfirmed called with QueryExecutor.BeginTX() because inside this process has separated QueryExecutor.Execute

func (*SetupAccountDataset) ApplyUnconfirmed 

func (tx *SetupAccountDataset) ApplyUnconfirmed() error

ApplyUnconfirmed is func that for applying to unconfirmed Transaction `SetupAccountDataset` type

func (*SetupAccountDataset) EscrowApplyConfirmed 

func (tx *SetupAccountDataset) EscrowApplyConfirmed(blockTimestamp int64) error

EscrowApplyConfirmed is func that for applying Transaction SetupAccountDataset type. And Perhaps EscrowApplyConfirmed called with QueryExecutor.BeginTX() because inside this process has separated QueryExecutor.Execute

func (*SetupAccountDataset) EscrowApplyUnconfirmed 

func (tx *SetupAccountDataset) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is func that for applying to unconfirmed Transaction `SetupAccountDataset` type.

func (*SetupAccountDataset) EscrowApproval 

func (tx *SetupAccountDataset) EscrowApproval(
	blockTimestamp int64,
	txBody *model.ApprovalEscrowTransactionBody,
) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending.

func (*SetupAccountDataset) EscrowUndoApplyUnconfirmed 

func (tx *SetupAccountDataset) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*SetupAccountDataset) EscrowValidate 

func (tx *SetupAccountDataset) EscrowValidate(dbTx bool) error

EscrowValidate is func that for validating to Transaction SetupAccountDataset type.

func (*SetupAccountDataset) Escrowable 

func (tx *SetupAccountDataset) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*SetupAccountDataset) GetAmount 

func (tx *SetupAccountDataset) GetAmount() int64

GetAmount return Amount from TransactionBody

func (*SetupAccountDataset) GetBodyBytes 

func (tx *SetupAccountDataset) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*SetupAccountDataset) GetMinimumFee 

func (tx *SetupAccountDataset) GetMinimumFee() (int64, error)

GetMinimumFee return minimum fee of transaction

func (*SetupAccountDataset) GetSize 

func (tx *SetupAccountDataset) GetSize() (uint32, error)

GetSize is size of transaction body

func (*SetupAccountDataset) GetTransactionBody 

func (tx *SetupAccountDataset) GetTransactionBody(transaction *model.Transaction)

GetTransactionBody return transaction body of SetupAccountDataset transactions

func (*SetupAccountDataset) ParseBodyBytes 

func (tx *SetupAccountDataset) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*SetupAccountDataset) SkipMempoolTransaction 

func (tx *SetupAccountDataset) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction this tx type has no mempool filter

func (*SetupAccountDataset) UndoApplyUnconfirmed 

func (tx *SetupAccountDataset) UndoApplyUnconfirmed() error

UndoApplyUnconfirmed is used to undo the previous applied unconfirmed tx action this will be called on apply confirmed or when rollback occurred

func (*SetupAccountDataset) Validate 

func (tx *SetupAccountDataset) Validate(dbTx bool) error

Validate is func that for validating to Transaction SetupAccountDataset type That specs:

  • Checking the expiration time
  • Checking Spendable Balance sender

type SignatureInfoHelper 

type SignatureInfoHelper struct {
	PendingSignatureQuery   query.PendingSignatureQueryInterface
	PendingTransactionQuery query.PendingTransactionQueryInterface
	QueryExecutor           query.ExecutorInterface
	Signature               crypto.SignatureInterface
}

func (*SignatureInfoHelper) GetPendingSignatureByTransactionHash 

func (sih *SignatureInfoHelper) GetPendingSignatureByTransactionHash(transactionHash []byte, txHeight uint32) ([]*model.PendingSignature, error)

func (*SignatureInfoHelper) InsertPendingSignature 

func (sih *SignatureInfoHelper) InsertPendingSignature(
	pendingSignature *model.PendingSignature,
) error

type SignatureInfoHelperInterface 

type SignatureInfoHelperInterface interface {
	InsertPendingSignature(
		pendingSignature *model.PendingSignature,
	) error
	GetPendingSignatureByTransactionHash(
		transactionHash []byte, txHeight uint32,
	) ([]*model.PendingSignature, error)
}

SignatureInfoHelperInterface multisignature helpers

type TXEmpty 

type TXEmpty struct {
	Body *model.EmptyTransactionBody
}

func (*TXEmpty) ApplyConfirmed 

func (tx *TXEmpty) ApplyConfirmed(int64) error

func (*TXEmpty) ApplyUnconfirmed 

func (tx *TXEmpty) ApplyUnconfirmed() error

func (*TXEmpty) Escrowable 

func (tx *TXEmpty) Escrowable() (EscrowTypeAction, bool)

func (*TXEmpty) GetAmount 

func (*TXEmpty) GetAmount() int64

func (*TXEmpty) GetBodyBytes 

func (*TXEmpty) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*TXEmpty) GetMinimumFee 

func (*TXEmpty) GetMinimumFee() (int64, error)

func (*TXEmpty) GetSize 

func (tx *TXEmpty) GetSize() (uint32, error)

func (*TXEmpty) GetTransactionBody 

func (*TXEmpty) GetTransactionBody(*model.Transaction)

func (*TXEmpty) ParseBodyBytes 

func (*TXEmpty) ParseBodyBytes([]byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*TXEmpty) SkipMempoolTransaction 

func (tx *TXEmpty) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction this tx type has no mempool filter

func (*TXEmpty) UndoApplyUnconfirmed 

func (tx *TXEmpty) UndoApplyUnconfirmed() error

func (*TXEmpty) Validate 

func (tx *TXEmpty) Validate(bool) error

type TransactionHelper 

type TransactionHelper struct {
	TransactionQuery query.TransactionQueryInterface
	QueryExecutor    query.ExecutorInterface
}

func NewTransactionHelper 

func NewTransactionHelper(
	transactionQuery query.TransactionQueryInterface,
	queryExecutor query.ExecutorInterface,
) *TransactionHelper

func (*TransactionHelper) InsertTransaction 

func (th *TransactionHelper) InsertTransaction(transaction *model.Transaction) error

type TransactionHelperInterface 

type TransactionHelperInterface interface {
	InsertTransaction(transaction *model.Transaction) error
}

type TypeAction 

type TypeAction interface {
	// ApplyConfirmed perhaps this method called with QueryExecutor.BeginTX() because inside this process has separated QueryExecutor.Execute
	ApplyConfirmed(blockTimestamp int64) error
	ApplyUnconfirmed() error
	UndoApplyUnconfirmed() error
	// Validate dbTx specify whether validation should read from transaction state or db state
	Validate(dbTx bool) error
	GetMinimumFee() (int64, error)
	GetAmount() int64
	GetSize() (uint32, error)
	ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)
	GetBodyBytes() ([]byte, error)
	GetTransactionBody(transaction *model.Transaction)
	SkipMempoolTransaction(
		selectedTransactions []*model.Transaction,
		blockTimestamp int64,
		blockHeight uint32,
	) (bool, error)
	// Escrowable check if transaction type has escrow part and it will refill escrow part
	Escrowable() (EscrowTypeAction, bool)
}

TypeAction is transaction methods collection

type TypeActionSwitcher 

type TypeActionSwitcher interface {
	GetTransactionType(tx *model.Transaction) (TypeAction, error)
}

TypeActionSwitcher assert transaction to TypeAction / EscrowTypeAction

type TypeSwitcher 

type TypeSwitcher struct {
	Executor                   query.ExecutorInterface
	NodeAuthValidation         auth.NodeAuthValidationInterface
	MempoolCacheStorage        storage.CacheStorageInterface
	NodeAddressInfoStorage     storage.TransactionalCache
	PendingNodeRegistryStorage storage.TransactionalCache
	ActiveNodeRegistryStorage  storage.TransactionalCache
	FeeScaleService            fee.FeeScaleServiceInterface
}

TypeSwitcher is TypeActionSwitcher shell

func (*TypeSwitcher) GetTransactionType 

func (ts *TypeSwitcher) GetTransactionType(tx *model.Transaction) (TypeAction, error)

GetTransactionType assert transaction to TypeAction

type UpdateNodeRegistration 

type UpdateNodeRegistration struct {
	TransactionObject            *model.Transaction
	Body                         *model.UpdateNodeRegistrationTransactionBody
	NodeRegistrationQuery        query.NodeRegistrationQueryInterface
	BlockQuery                   query.BlockQueryInterface
	QueryExecutor                query.ExecutorInterface
	AuthPoown                    auth.NodeAuthValidationInterface
	EscrowQuery                  query.EscrowTransactionQueryInterface
	AccountBalanceHelper         AccountBalanceHelperInterface
	FeeScaleService              fee.FeeScaleServiceInterface
	PendingNodeRegistrationCache storage.TransactionalCache
	ActiveNodeRegistrationCache  storage.TransactionalCache
}

UpdateNodeRegistration Implement service layer for (new) node registration's transaction

func (*UpdateNodeRegistration) ApplyConfirmed 

func (tx *UpdateNodeRegistration) ApplyConfirmed(blockTimestamp int64) error

ApplyConfirmed method for confirmed the transaction and store into database

func (*UpdateNodeRegistration) ApplyUnconfirmed 

func (tx *UpdateNodeRegistration) ApplyUnconfirmed() error

ApplyUnconfirmed is func that for applying to unconfirmed Transaction `UpdateNodeRegistration` type:

  • perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*UpdateNodeRegistration) EscrowApplyConfirmed 

func (tx *UpdateNodeRegistration) EscrowApplyConfirmed(blockTimestamp int64) error

EscrowApplyConfirmed method for confirmed the transaction and store into database

func (*UpdateNodeRegistration) EscrowApplyUnconfirmed 

func (tx *UpdateNodeRegistration) EscrowApplyUnconfirmed() error

EscrowApplyUnconfirmed is func that for applying to unconfirmed Transaction `UpdateNodeRegistration` type, perhaps recipient is not exists , so create new `account` and `account_balance`, balance and spendable = amount.

func (*UpdateNodeRegistration) EscrowApproval 

func (tx *UpdateNodeRegistration) EscrowApproval(
	blockTimestamp int64,
	txBody *model.ApprovalEscrowTransactionBody,
) error

EscrowApproval handle approval an escrow transaction, execute tasks that was skipped when escrow pending. like: spreading commission and fee, and also more pending tasks

func (*UpdateNodeRegistration) EscrowUndoApplyUnconfirmed 

func (tx *UpdateNodeRegistration) EscrowUndoApplyUnconfirmed() error

EscrowUndoApplyUnconfirmed func that perform on apply confirm preparation

func (*UpdateNodeRegistration) EscrowValidate 

func (tx *UpdateNodeRegistration) EscrowValidate(dbTx bool) error

EscrowValidate validate node registration transaction and tx body

func (*UpdateNodeRegistration) Escrowable 

func (tx *UpdateNodeRegistration) Escrowable() (EscrowTypeAction, bool)

Escrowable will check the transaction is escrow or not. Rebuild escrow if not nil, and can use for whole sibling methods (escrow)

func (*UpdateNodeRegistration) GetAmount 

func (tx *UpdateNodeRegistration) GetAmount() int64

func (*UpdateNodeRegistration) GetBodyBytes 

func (tx *UpdateNodeRegistration) GetBodyBytes() ([]byte, error)

GetBodyBytes translate tx body to bytes representation

func (*UpdateNodeRegistration) GetMinimumFee 

func (tx *UpdateNodeRegistration) GetMinimumFee() (int64, error)

func (*UpdateNodeRegistration) GetSize 

func (tx *UpdateNodeRegistration) GetSize() (uint32, error)

func (*UpdateNodeRegistration) GetTransactionBody 

func (tx *UpdateNodeRegistration) GetTransactionBody(transaction *model.Transaction)

func (*UpdateNodeRegistration) ParseBodyBytes 

func (tx *UpdateNodeRegistration) ParseBodyBytes(txBodyBytes []byte) (model.TransactionBodyInterface, error)

ParseBodyBytes read and translate body bytes to body implementation fields

func (*UpdateNodeRegistration) SkipMempoolTransaction 

func (tx *UpdateNodeRegistration) SkipMempoolTransaction(
	selectedTransactions []*model.Transaction,
	newBlockTimestamp int64,
	newBlockHeight uint32,
) (bool, error)

SkipMempoolTransaction filter out of the mempool a node registration tx if there are other node registration tx in mempool to make sure only one node registration tx at the time (the one with highest fee paid) makes it to the same block

func (*UpdateNodeRegistration) UndoApplyUnconfirmed 

func (tx *UpdateNodeRegistration) UndoApplyUnconfirmed() error

func (*UpdateNodeRegistration) Validate 

func (tx *UpdateNodeRegistration) Validate(dbTx bool) error

Validate validate node registration transaction and tx body

type Util 

type Util struct {
	FeeScaleService     fee.FeeScaleServiceInterface
	MempoolCacheStorage storage.CacheStorageInterface
	QueryExecutor       query.ExecutorInterface
	AccountDatasetQuery query.AccountDatasetQueryInterface
}

func (*Util) GenerateMultiSigAddress 

func (u *Util) GenerateMultiSigAddress(info *model.MultiSignatureInfo) ([]byte, error)

GenerateMultiSigAddress assembling MultiSignatureInfo to be an account address that is multi signature account address

func (*Util) GetTransactionBytes 

func (*Util) GetTransactionBytes(transaction *model.Transaction, signed bool) ([]byte, error)

GetTransactionBytes translate transaction model to its byte representation provide sign = true to translate transaction with its signature, sign = false for without signature (used for verify signature)

func (*Util) GetTransactionID 

func (*Util) GetTransactionID(transactionHash []byte) (int64, error)

GetTransactionID calculate and returns a transaction ID given a transaction model

func (*Util) ParseTransactionBytes 

func (u *Util) ParseTransactionBytes(transactionBytes []byte, sign bool) (*model.Transaction, error)

ParseTransactionBytes build transaction from transaction bytes

func (*Util) ValidateTransaction 

func (u *Util) ValidateTransaction(tx *model.Transaction, typeAction TypeAction, verifySignature bool) error

ValidateTransaction take in transaction object and execute basic validation

type UtilInterface 

type UtilInterface interface {
	GetTransactionBytes(transaction *model.Transaction, sign bool) ([]byte, error)
	ParseTransactionBytes(transactionBytes []byte, sign bool) (*model.Transaction, error)
	GetTransactionID(transactionHash []byte) (int64, error)
	ValidateTransaction(tx *model.Transaction, typeAction TypeAction, verifySignature bool) error
	GenerateMultiSigAddress(info *model.MultiSignatureInfo) ([]byte, error)
}

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.