feat: change start config

Merge pull request !2 from 赵伟杰/feat/start-port

.gitignore

@@ -3,4 +3,5 @@
 debugconf.json
 /ContractDB/
 /defaultLog/
-/log/
+/log/
+.DS_Store

LICENSE

@@ -1,339 +1,127 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
+                     木兰宽松许可证, 第2版
 
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+   木兰宽松许可证， 第2版 
+   2020年1月 http://license.coscl.org.cn/MulanPSL2
 
-                            Preamble
 
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
+   您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（“本许可证”）的如下条款的约束：
 
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
+   0. 定义
 
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
+      “软件”是指由“贡献”构成的许可在“本许可证”下的程序和相关文档的集合。
 
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
+      “贡献”是指由任一“贡献者”许可在“本许可证”下的受版权法保护的作品。
 
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
+      “贡献者”是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
 
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
+      “法人实体”是指提交贡献的机构及其“关联实体”。
 
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
+      “关联实体”是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
 
-  The precise terms and conditions for copying, distribution and
-modification follow.
+   1. 授予版权许可
 
-                    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+      每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其“贡献”，不论修改与否。
 
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
+   2. 授予专利许可
 
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
+      每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”本身或其“贡献”与许可“贡献”时的“软件”结合而将必然会侵犯的专利权利要求，不包括对“贡献”的修改或包含“贡献”的其他结合。如果您或您的“关联实体”直接或间接地，就“软件”或其中的“贡献”对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则“本许可证”授予您对“软件”的专利许可自您提起诉讼或发起维权行动之日终止。
 
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
+   3. 无商标许可
 
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
+      “本许可证”不提供对“贡献者”的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。
 
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
+   4. 分发限制
 
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
+      您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
 
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
+   5. 免责声明与责任限制
 
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
+      “软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。 
 
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
+   6. 语言
+      “本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
 
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
+   条款结束 
 
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
+   如何将木兰宽松许可证，第2版，应用到您的软件
+   
+   如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：
 
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
+      1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
 
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
+      2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
 
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
+      3， 请将如下声明文本放入每个源文件的头部注释中。
 
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
+   Copyright (c) [Year] [name of copyright holder]
+   [Software Name] is licensed under Mulan PSL v2.
+   You can use this software according to the terms and conditions of the Mulan PSL v2. 
+   You may obtain a copy of Mulan PSL v2 at:
+            http://license.coscl.org.cn/MulanPSL2 
+   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.  
+   See the Mulan PSL v2 for more details.  
 
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
 
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
+                     Mulan Permissive Software License，Version 2
 
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
+   Mulan Permissive Software License，Version 2 (Mulan PSL v2)
+   January 2020 http://license.coscl.org.cn/MulanPSL2
 
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
+   Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions: 
+   
+   0. Definition
+   
+      Software means the program and related documents which are licensed under this License and comprise all Contribution(s). 
+   
+      Contribution means the copyrightable work licensed by a particular Contributor under this License.
+   
+      Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
+   
+      Legal Entity means the entity making a Contribution and all its Affiliates.
+   
+      Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, ‘control’ means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
 
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
+   1. Grant of Copyright License
 
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
+      Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
 
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
+   2. Grant of Patent License 
 
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
+      Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.
 
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
+   3. No Trademark License
 
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
+      No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in Section 4.
 
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
+   4. Distribution Restriction
 
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
+      You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.
 
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
+   5. Disclaimer of Warranty and Limitation of Liability
 
-                            NO WARRANTY
+      THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT’S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
+   6. Language
 
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
+      THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
 
-                     END OF TERMS AND CONDITIONS
+   END OF THE TERMS AND CONDITIONS
 
-            How to Apply These Terms to Your New Programs
+   How to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software
 
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
+      To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
 
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
+      i Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner; 
 
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
+      ii Create a file named “LICENSE” which contains the whole context of this License in the first directory of your software package;
 
-    This program 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 2 of the License, or
-    (at your option) any later version.
+      iii Attach the statement to the appropriate annotated syntax at the beginning of each source file.
 
-    This program 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 this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.
+   Copyright (c) [Year] [name of copyright holder]
+   [Software Name] is licensed under Mulan PSL v2.
+   You can use this software according to the terms and conditions of the Mulan PSL v2. 
+   You may obtain a copy of Mulan PSL v2 at:
+               http://license.coscl.org.cn/MulanPSL2 
+   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.  
+   See the Mulan PSL v2 for more details.  

README.md

@@ -16,4 +16,9 @@ copy debugconf.json.template debugconf.json
 3.设置DebugMain的路径为：xxx/xxx/cp
 ```
 执行DebugMain.main即可
-```
+```
+
+## 构建可执行版本
+执行`cp/build.gradle`中的`buildBundle`任务。
+在`cp/build/output`即为相关的jar包。
+由`yjs.jar`（即cp.jar)和一系列依赖（在libs目录下)组成。

build.gradle

@@ -5,9 +5,15 @@ plugins {
     id 'signing'
 }
 
-group = "org.bdware.sc"
-version = "2.0.0"
+apply from: '../spotless.gradle'
 
+group = "org.bdware.sc"
+version = "1.10.6"
+tasks.withType(JavaCompile) {
+    //   options.compilerArgs << '-Xlint:none'
+    //   options.compilerArgs << '-Xlint:deprecation' << "-Werror"
+    options.compilerArgs << '-parameters'
+}
 repositories {
     mavenCentral()
     mavenLocal()
@@ -34,25 +40,29 @@ sourceSets {
 dependencies {
     api project(":common")
     api project(":mockjava")
+    implementation 'org.bdware:delta-crdts:1.2.0'
     implementation 'org.apache.commons:commons-lang3:3.0'
     implementation 'com.atlassian.commonmark:commonmark:0.17.0'
     implementation 'com.idealista:format-preserving-encryption:1.0.0'
     implementation 'org.apache.commons:commons-math3:3.6.1'
     implementation 'org.codehaus.groovy:groovy-all:3.0.8'
-    implementation 'io.grpc:grpc-all:1.41.0'
+    implementation 'io.grpc:grpc-all:1.64.0'
     implementation 'org.jsoup:jsoup:1.14.2'
     implementation 'com.sun.mail:javax.mail:1.6.2'
     implementation 'com.squareup.okhttp3:okhttp:4.9.1'
     implementation 'org.bdware.bdcontract:sdk-java:1.0.2'
-    implementation 'org.bdware.doip:doip-audit-tool:1.1.3'
+    implementation 'org.bdware.doip:doip-audit-tool:1.6.0'
+    implementation 'org.bdware.doip:doip-sdk:1.5.9'
+    implementation 'org.apache.logging.log4j:log4j-layout-template-json:2.17.2'
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.3'
     implementation fileTree(dir: 'lib', include: '*.jar')
     testImplementation 'junit:junit:4.13.2'
 }
 tasks.jar.setDuplicatesStrategy(DuplicatesStrategy.INCLUDE)
-
 task classJar(type: Jar, dependsOn: classes) {
     classifier = "jar"
 }
+
 jar {
     String libs = ''
     configurations.runtimeClasspath.each {
@@ -60,9 +70,9 @@ jar {
     }
     from {
         //  uncomment this when publish,
-        //while develop at local use "false"
+        // while develop at local use "false"
         configurations.runtimeClasspath.filter {
-           // it.getAbsolutePath().contains("/lib/")
+            // it.getAbsolutePath().contains("/lib/")
             false
         }.collect {
             it.isDirectory() ? it : zipTree(it)
@@ -119,8 +129,7 @@ tasks.withType(Javadoc) {
 task javadocJar(type: Jar, dependsOn: javadoc) {
     archiveClassifier = 'javadoc'
     classifier = "javadoc"
-    exclude {
-        details -> details.file.getAbsolutePath().contains("/gm/")
+    exclude { details -> details.file.getAbsolutePath().contains("/gm/")
     }
     from javadoc.destinationDir
 }
@@ -173,18 +182,18 @@ publishing {
         maven {
             name 'bdwareSnapshotRepository'
             url 'https://oss.sonatype.org/content/repositories/snapshots'
-//            credentials {
-//                username = "${NEXUS_USERNAME}"
-//                password = "${NEXUS_PASSWORD}"
-//            }
+            credentials {
+                username = "${NEXUS_USERNAME}"
+                password = "${NEXUS_PASSWORD}"
+            }
         }
         maven {
             name 'bdwareRepository'
             url 'https://oss.sonatype.org/service/local/staging/deploy/maven2'
-//            credentials {
-//                username = "${NEXUS_USERNAME}"
-//                password = "${NEXUS_PASSWORD}"
-//            }
+            credentials {
+                username = "${NEXUS_USERNAME}"
+                password = "${NEXUS_PASSWORD}"
+            }
         }
     }
 }

debugconf.json.template

@@ -1,6 +1,8 @@
 {
-  "agentHttpAddr": "127.0.0.1:18000",
-  "script": "/Users/huaqiancai/BDWare/datanet/datanet-gateway-bundle/datanet-gateway-backend/build/gateway.ypk",
-  "pubKey": "04d1924329f72ced148f6f333fb985ccbaa31b1e3aacf10be5f43d4a4ff5ad88899a005e79e37fc06993e1d66ada8cf8b711cb36f59538bb7d3e39e70fa9360ddd",
-  "privKey": "589d94ee5688358a1c5c18430dd9c75097ddddebf769f139da36a807911d20f8"
+  "agentAddress": "127.0.0.1:18000",
+  "ypkPath": "/Users/huaqiancai/BDWare/datanet/datanet-gateway-bundle/datanet-gateway-backend/build/gateway.ypk",
+  "privateKey": "04d1924329f72ced148f6f333fb985ccbaa31b1e3aacf10be5f43d4a4ff5ad88899a005e79e37fc06993e1d66ada8cf8b711cb36f59538bb7d3e39e70fa9360ddd",
+  "publicKey": "589d94ee5688358a1c5c18430dd9c75097ddddebf769f139da36a807911d20f8",
+  "killBeforeStart":"ContractName",
+  "createParam":{}
 }

src/main/data-mask/maskingJobs/MaskingJob.java

@@ -16,8 +16,6 @@ import com.alibaba.datax.plugin.rdbms.util.DBUtil;
 import com.alibaba.datax.plugin.rdbms.util.DBUtilErrorCode;
 import com.alibaba.datax.plugin.rdbms.util.DataBaseType;
 import com.alibaba.datax.plugin.rdbms.util.RdbmsException;
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
 import com.google.gson.JsonPrimitive;
 import org.apache.commons.lang3.Validate;
 import org.bdware.sc.util.JsonUtil;
@@ -47,8 +45,8 @@ public class MaskingJob {
 
     public void init(String confContent) {
         maskConf = Configuration.from(confContent);
-        System.out.println("maskConf"+maskConf.toString());
-        System.out.println(("maskCOnfjob"+maskConf.get("job").toString()));
+        System.out.println("maskConf" + maskConf.toString());
+        System.out.println(("maskCOnfjob" + maskConf.get("job").toString()));
         readerPara = maskConf.getConfiguration(CoreConstant.DATAX_JOB_CONTENT_READER_PARAMETER);
         System.out.println(readerPara);
         username = readerPara.getString(Key.USERNAME);
@@ -56,16 +54,19 @@ public class MaskingJob {
         jdbcUrl = readerPara.getString(Key.JDBC_URL);
         table = readerPara.getString(Key.TABLE);
         buffer = new ArrayList<>();
-        System.out.println("maskConf11"+maskConf.getConfiguration(CoreConstant.DATAX_JOB_CONTENT + "[0]"));
-        transformerExecs = TransformerUtil.buildTransformerInfo(maskConf.getConfiguration(CoreConstant.DATAX_JOB_CONTENT + "[0]"));
+        System.out.println(
+                "maskConf11" + maskConf.getConfiguration(CoreConstant.DATAX_JOB_CONTENT + "[0]"));
+        transformerExecs = TransformerUtil.buildTransformerInfo(
+                maskConf.getConfiguration(CoreConstant.DATAX_JOB_CONTENT + "[0]"));
     }
 
     public String buildQuerySql() {
         String column = "*";
-        //String column = readerPara.getString(Key.COLUMN);
+        // String column = readerPara.getString(Key.COLUMN);
         String table = readerPara.getString(Key.TABLE);
         String where = readerPara.getString(Key.WHERE, null);
-        //String querySql = SingleTableSplitUtil.buildQuerySql(column, table, where) + " limit 100";
+        // String querySql = SingleTableSplitUtil.buildQuerySql(column, table, where) + " limit
+        // 100";
         String querySql = SingleTableSplitUtil.buildQuerySql(column, table, where) + " limit 100";
 
         return querySql;
@@ -74,24 +75,24 @@ public class MaskingJob {
     public JsonPrimitive getMaskedData(String confContent) {
         init(confContent);
         return startRead();
-        //return new JsonPrimitive(getResult());
+        // return new JsonPrimitive(getResult());
     }
 
     public JsonPrimitive startRead() {
         String querySql = buildQuerySql();
-        System.out.println("startRead"+dataBaseType+jdbcUrl+username+password);
+        System.out.println("startRead" + dataBaseType + jdbcUrl + username + password);
         Connection conn = DBUtil.getConnection(dataBaseType, jdbcUrl, username, password);
-        System.out.println(dataBaseType+jdbcUrl+username+password);
+        System.out.println(dataBaseType + jdbcUrl + username + password);
         int columnNumber = 0;
-        String res="";
-        ArrayList<String>columnName=new ArrayList<>();
+        String res = "";
+        ArrayList<String> columnName = new ArrayList<>();
         try {
             ResultSet rs = DBUtil.query(conn, querySql);
             ResultSetMetaData metaData = rs.getMetaData();
             columnNumber = metaData.getColumnCount();
-            for(int i=1;i<=metaData.getColumnCount();i++){
-                //获取列表 index 从1开始、列名、列类型、列的数据长度
-                //System.out.println("aaa"+metaData.getColumnName(i)+"\t"+metaData.getColumnTypeName(i)+"\t"+metaData.getColumnDisplaySize(i));
+            for (int i = 1; i <= metaData.getColumnCount(); i++) {
+                // 获取列表 index 从1开始、列名、列类型、列的数据长度
+                // System.out.println("aaa"+metaData.getColumnName(i)+"\t"+metaData.getColumnTypeName(i)+"\t"+metaData.getColumnDisplaySize(i));
                 columnName.add(metaData.getColumnName(i));
 
             }
@@ -106,15 +107,14 @@ public class MaskingJob {
         } finally {
             DBUtil.closeDBResources(null, conn);
         }
-        ////for(int i=0;i<columnNumber;i++){
-            //columnName.add(metaData.getColumnName(i));
-        //}//
-        res=getResult(columnName);
+        //// for(int i=0;i<columnNumber;i++){
+        // columnName.add(metaData.getColumnName(i));
+        // }//
+        res = getResult(columnName);
         return new JsonPrimitive(res);
     }
 
-    private Record transportOneRecord(ResultSet rs, ResultSetMetaData metaData,
-                                      int columnNumber) {
+    private Record transportOneRecord(ResultSet rs, ResultSetMetaData metaData, int columnNumber) {
         Record record = buildRecord(rs, metaData, columnNumber);
         sendToWriter(record);
         return record;
@@ -133,32 +133,34 @@ public class MaskingJob {
     }
 
     private Record doTransformer(Record record) {
-        System.out.println("Record"+record);
+        System.out.println("Record" + record);
         if (transformerExecs == null || transformerExecs.size() == 0) {
             return record;
         }
 
-        ClassLoaderSwapper classLoaderSwapper = ClassLoaderSwapper
-                .newCurrentThreadClassLoaderSwapper();
+        ClassLoaderSwapper classLoaderSwapper =
+                ClassLoaderSwapper.newCurrentThreadClassLoaderSwapper();
 
         Record result = record;
 
         String errorMsg = null;
         boolean failed = false;
         for (TransformerExecution transformerInfoExec : transformerExecs) {
-            System.out.println("transformerExecs"+transformerInfoExec.getTransformerName());
+            System.out.println("transformerExecs" + transformerInfoExec.getTransformerName());
             if (transformerInfoExec.getClassLoader() != null) {
-                classLoaderSwapper.setCurrentThreadClassLoader(transformerInfoExec.getClassLoader());
+                classLoaderSwapper
+                        .setCurrentThreadClassLoader(transformerInfoExec.getClassLoader());
             }
 
             /**
-             * 延迟检查transformer参数的有效性，直接抛出异常，不作为脏数据
-             * 不需要在插件中检查参数的有效性。但参数的个数等和插件相关的参数，在插件内部检查
+             * 延迟检查transformer参数的有效性，直接抛出异常，不作为脏数据 不需要在插件中检查参数的有效性。但参数的个数等和插件相关的参数，在插件内部检查
              */
             if (!transformerInfoExec.isChecked()) {
 
-                if (transformerInfoExec.getColumnIndex() != null && transformerInfoExec.getColumnIndex() >= record.getColumnNumber()) {
-                    throw DataXException.asDataXException(TransformerErrorCode.TRANSFORMER_ILLEGAL_PARAMETER,
+                if (transformerInfoExec.getColumnIndex() != null
+                        && transformerInfoExec.getColumnIndex() >= record.getColumnNumber()) {
+                    throw DataXException.asDataXException(
+                            TransformerErrorCode.TRANSFORMER_ILLEGAL_PARAMETER,
                             String.format("columnIndex[%s] out of bound[%s]. name=%s",
                                     transformerInfoExec.getColumnIndex(), record.getColumnNumber(),
                                     transformerInfoExec.getTransformerName()));
@@ -167,14 +169,15 @@ public class MaskingJob {
             }
 
             try {
-                result = transformerInfoExec.getTransformer().evaluate(result, transformerInfoExec.gettContext(), transformerInfoExec.getFinalParas());
+                result = transformerInfoExec.getTransformer().evaluate(result,
+                        transformerInfoExec.gettContext(), transformerInfoExec.getFinalParas());
             } catch (Exception e) {
-                errorMsg = String.format("transformer(%s) has Exception(%s)", transformerInfoExec.getTransformerName(),
-                        e.getMessage());
+                errorMsg = String.format("transformer(%s) has Exception(%s)",
+                        transformerInfoExec.getTransformerName(), e.getMessage());
                 failed = true;
-                //LOG.error(errorMsg, e);
+                // LOG.error(errorMsg, e);
                 // transformerInfoExec.addFailedRecords(1);
-                //脏数据不再进行后续transformer处理，按脏数据处理，并过滤该record。
+                // 脏数据不再进行后续transformer处理，按脏数据处理，并过滤该record。
                 break;
 
             } finally {
@@ -193,14 +196,13 @@ public class MaskingJob {
         if (failed) {
             return null;
         } else {
-            System.out.println("result"+result);
+            System.out.println("result" + result);
             return result;
         }
 
     }
 
-    protected Record buildRecord(ResultSet rs, ResultSetMetaData metaData,
-                                 int columnNumber) {
+    protected Record buildRecord(ResultSet rs, ResultSetMetaData metaData, int columnNumber) {
         final byte[] EMPTY_CHAR_ARRAY = new byte[0];
         Record record = new DefaultRecord();
         try {
@@ -276,14 +278,11 @@ public class MaskingJob {
                         break;
 
                     default:
-                        throw DataXException
-                                .asDataXException(
-                                        DBUtilErrorCode.UNSUPPORTED_TYPE,
-                                        String.format(
-                                                "您的配置文件中的列配置信息有误. 因为DataX 不支持数据库读取这种字段类型. 字段名:[%s], 字段名称:[%s], 字段Java类型:[%s]. 请尝试使用数据库函数将其转换datax支持的类型 或者不同步该字段 .",
-                                                metaData.getColumnName(i),
-                                                metaData.getColumnType(i),
-                                                metaData.getColumnClassName(i)));
+                        throw DataXException.asDataXException(DBUtilErrorCode.UNSUPPORTED_TYPE,
+                                String.format(
+                                        "您的配置文件中的列配置信息有误. 因为DataX 不支持数据库读取这种字段类型. 字段名:[%s], 字段名称:[%s], 字段Java类型:[%s]. 请尝试使用数据库函数将其转换datax支持的类型 或者不同步该字段 .",
+                                        metaData.getColumnName(i), metaData.getColumnType(i),
+                                        metaData.getColumnClassName(i)));
                 }
             }
         } catch (Exception e) {
@@ -294,33 +293,33 @@ public class MaskingJob {
         return record;
     }
 
-//    private String recordToString(Record record) {
-//        final String NEWLINE_FLAG = "\n";
-//        String fieldDelimiter = "\t";
-//
-//        int recordLength = record.getColumnNumber();
-//        if (0 == recordLength) {
-//            return NEWLINE_FLAG;
-//        }
-//
-//        Column column;
-//        StringBuilder sb = new StringBuilder();
-//        for (int i = 0; i < recordLength; i++) {
-//            column = record.getColumn(i);
-//            sb.append(column.asString()).append(fieldDelimiter);
-//        }
-//        sb.setLength(sb.length() - 1);
-//        sb.append(NEWLINE_FLAG);
-//
-//        return sb.toString();
-//    }
+    // private String recordToString(Record record) {
+    // final String NEWLINE_FLAG = "\n";
+    // String fieldDelimiter = "\t";
+    //
+    // int recordLength = record.getColumnNumber();
+    // if (0 == recordLength) {
+    // return NEWLINE_FLAG;
+    // }
+    //
+    // Column column;
+    // StringBuilder sb = new StringBuilder();
+    // for (int i = 0; i < recordLength; i++) {
+    // column = record.getColumn(i);
+    // sb.append(column.asString()).append(fieldDelimiter);
+    // }
+    // sb.setLength(sb.length() - 1);
+    // sb.append(NEWLINE_FLAG);
+    //
+    // return sb.toString();
+    // }
 
     public String getResult(ArrayList<String> columnName) {
         List<Object> dataList = new ArrayList<>();
         int size = buffer.size();
-        //System.out.println("CCULUMN"+readerPara.getString(Key.COLUMN).toString());
-        //String[] colmnNames = readerPara.getString(Key.COLUMN).replace(" ", "").split(",");
-        int colmnSize= columnName.size();
+        // System.out.println("CCULUMN"+readerPara.getString(Key.COLUMN).toString());
+        // String[] colmnNames = readerPara.getString(Key.COLUMN).replace(" ", "").split(",");
+        int colmnSize = columnName.size();
         for (int i = 0; i < colmnSize; ++i) {
             Map<Object, Object> rowData = new HashMap<>();
             for (int j = 0; j < size; ++j) {

src/main/debugger/org/bdware/sc/debugger/DebugMain.java

@@ -26,58 +26,65 @@ public class DebugMain {
         DebugConfig config = JsonUtil.fromJson(content, DebugConfig.class);
         inject(config);
         String keyPairStr = "{\"publicKey\":\"%s\",\"privateKey\":\"%s\"}";
-        SM2KeyPair pair = SM2KeyPair.fromJson(String.format(keyPairStr, config.publicKey, config.privateKey));
+        SM2KeyPair pair =
+                SM2KeyPair.fromJson(String.format(keyPairStr, config.publicKey, config.privateKey));
         String uriFormat = "ws://%s/SCIDE/SCExecutor";
         if (config.killBeforeStart != null && config.killBeforeStart.length() > 0) {
             AtomicInteger counter = new AtomicInteger(0);
 
-            SmartContractClient client = new SmartContractClient(String.format(uriFormat, config.agentAddress), pair) {
-                public void onLogin(JsonObject obj) {
-                    counter.incrementAndGet();
-                }
+            SmartContractClient client =
+                    new SmartContractClient(String.format(uriFormat, config.agentAddress), pair) {
+                        public void onLogin(JsonObject obj) {
+                            counter.incrementAndGet();
+                        }
 
-                public void onKillContractProcess(JsonObject obj) {
-                    counter.incrementAndGet();
-                }
+                        public void onKillContractProcess(JsonObject obj) {
+                            counter.incrementAndGet();
+                        }
 
-            };
+                    };
             client.waitForConnect();
             client.login();
             try {
-                for (; counter.get() == 0; )
+                for (; counter.get() == 0;)
                     Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
-            client.sendMsg("{\"action\":\"killContractProcess\",\"name\":\"" + config.killBeforeStart + "\"}");
+            client.sendMsg("{\"action\":\"killContractProcess\",\"name\":\""
+                    + config.killBeforeStart + "\"}");
             try {
-                for (; counter.get() == 1; )
+                for (; counter.get() == 1;)
                     Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         config.contract.setCreateParam(config.createParam);
-        ContractProcess.main(new String[]{"-port=" + config.port, "-cmi=" + config.cmi, "-disablePID"});
-        ResultCallback printCallback
-                = new ResultCallback() {
+        ContractProcess
+                .main(new String[] {"-port=" + config.port, "-cmi=" + config.cmi, "-disablePID"});
+        ResultCallback printCallback = new ResultCallback() {
             @Override
             public void onResult(String str) {
-
+                if (str.contains("Error")) {
+                    LOGGER.error("Some error happens: " + str);
+                }
                 LOGGER.info("[PrintCB] " + str);
             }
         };
         ContractProcess.instance.handler.setDBInfo(wrap("", config.dbPath), printCallback);
-        ContractProcess.instance.handler.registerMangerPort(wrap("", Integer.valueOf(config.cPort)), printCallback);
+        ContractProcess.instance.handler.registerMangerPort(wrap("", Integer.valueOf(config.cPort)),
+                printCallback);
 
-        ContractProcess.instance.handler.setContractBundle(wrap("", config.contract), printCallback);
+        ContractProcess.instance.handler.setContractBundle(wrap("", config.contract),
+                printCallback);
 
         String urlFormat = "http://%s/SCIDE/SCManager?action=reconnectPort&owner=%s&port=%d%s";
         String cpHost = "";
         if (config.cpHost != null && config.cpHost.length() > 0)
             cpHost = "&host=" + config.cpHost;
-        String url = String.format(urlFormat, config.agentAddress,
-                config.publicKey, ContractProcess.instance.server.mainPort.get(), cpHost);
+        String url = String.format(urlFormat, config.agentAddress, config.publicKey,
+                ContractProcess.instance.server.mainPort.get(), cpHost);
         Map<String, Object> resp = HttpUtil.httpGet(url);
 
         String data = (String) resp.get("response");
@@ -101,7 +108,8 @@ public class DebugMain {
         config.cPort = jsonObject.get("cPort").getAsInt();
         config.port = jsonObject.get("port").getAsInt();
         JsonObject ownerAndScript = new JsonObject();
-        String arg = "abc&owner=" + config.publicKey + "&script=" + config.ypkPath;
+        String arg = "abc&owner=" + config.publicKey + "&script=" + config.ypkPath
+                + "&doipStartPort=" + config.doipStartPort;
         url = String.format(urlFormat, config.agentAddress, "allocateKeyPair", arg);
         resp = HttpUtil.httpGet(url);
         LOGGER.info(url);
@@ -131,7 +139,8 @@ public class DebugMain {
         String killBeforeStart;
         String ypkPath;
         String cpHost;
-        //AutoAppend
+        int doipStartPort;
+        // AutoAppend
         int port;
         String cmi;
         String dbPath;

src/main/java/org/bdware/sc/ContractProcess.java

@@ -3,7 +3,6 @@ package org.bdware.sc;
 import com.google.gson.*;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.MalformedJsonException;
-import groovy.util.logging.Log;
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.core.config.Configurator;
 import org.bdware.analysis.BasicBlock;
@@ -17,6 +16,7 @@ import org.bdware.analysis.gas.PPCount;
 import org.bdware.analysis.taint.TaintBB;
 import org.bdware.analysis.taint.TaintCFG;
 import org.bdware.analysis.taint.TaintResult;
+import org.bdware.doip.audit.EndpointConfig;
 import org.bdware.sc.ContractResult.Status;
 import org.bdware.sc.bean.*;
 import org.bdware.sc.boundry.JavaScriptEntry;
@@ -31,9 +31,10 @@ import org.bdware.sc.engine.DesktopEngine;
 import org.bdware.sc.engine.JSONTool;
 import org.bdware.sc.engine.hook.*;
 import org.bdware.sc.handler.ContractHandler;
+import org.bdware.sc.handler.DOOPRequestHandler;
 import org.bdware.sc.index.TimeSerialIndex;
 import org.bdware.sc.node.*;
-import org.bdware.sc.server.DoipServerTest;
+import org.bdware.sc.server.DoipClusterServer;
 import org.bdware.sc.trace.ProgramPointCounter;
 import org.bdware.sc.util.FileUtil;
 import org.bdware.sc.util.HashUtil;
@@ -41,6 +42,8 @@ import org.bdware.sc.util.JsonUtil;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.tree.ClassNode;
 import org.objectweb.asm.tree.MethodNode;
+import org.zz.gmhelper.SM2KeyPair;
+import org.zz.gmhelper.SM2Util;
 
 import javax.script.ScriptContext;
 import javax.script.ScriptEngine;
@@ -53,8 +56,8 @@ import java.util.*;
 import java.util.zip.ZipFile;
 
 public class ContractProcess {
-    private static final byte[] ZIP_HEADER_1 = new byte[]{80, 75, 3, 4};
-    private static final byte[] ZIP_HEADER_2 = new byte[]{80, 75, 5, 6};
+    private static final byte[] ZIP_HEADER_1 = new byte[] {80, 75, 3, 4};
+    private static final byte[] ZIP_HEADER_2 = new byte[] {80, 75, 5, 6};
     private static final org.apache.logging.log4j.Logger LOGGER =
             org.apache.logging.log4j.LogManager.getLogger(ContractProcess.class);
     public static ContractProcess instance;
@@ -80,6 +83,7 @@ public class ContractProcess {
     private TimeSerialIndex logIndex;
     private RocksDBUtil edion;
     private String pid;
+    public DOOPRequestHandler doopRequestHandler;
 
     public ContractProcess(int port, String cmi) {
         handler = new ContractHandler(this);
@@ -107,7 +111,7 @@ public class ContractProcess {
             }
         }
         Scanner sc = new Scanner(pidInput);
-        for (String str; sc.hasNextLine(); ) {
+        for (String str; sc.hasNextLine();) {
             str = sc.nextLine();
             LOGGER.info("[CP From STDIN] " + str);
             if (str.contains("CP PID:")) {
@@ -135,9 +139,8 @@ public class ContractProcess {
             byte[] buffer = new byte[4];
             int length = input.read(buffer, 0, 4);
             if (length == 4) {
-                isArchive =
-                        (Arrays.equals(ZIP_HEADER_1, buffer))
-                                || (Arrays.equals(ZIP_HEADER_2, buffer));
+                isArchive = (Arrays.equals(ZIP_HEADER_1, buffer))
+                        || (Arrays.equals(ZIP_HEADER_2, buffer));
             }
         } catch (IOException e) {
             e.printStackTrace();
@@ -192,9 +195,8 @@ public class ContractProcess {
 
                 cn = czb.mergeContractNode();
             } else {
-                cn =
-                        compiler.compile(
-                                new ByteArrayInputStream(script.getBytes()), "contract_main.yjs");
+                cn = compiler.compile(new ByteArrayInputStream(script.getBytes()),
+                        "contract_main.yjs");
             }
             DesktopEngine engine = new DesktopEngine(); // engine.loadJar(zf);
             engine.loadContract(c, cn, ret.isInsnLimit);
@@ -214,8 +216,8 @@ public class ContractProcess {
 
                 MethodNode mn = methods.get(fn.functionName);
                 if (mn != null) {
-                    System.out.println(
-                            "[ContractManager] getMethodNode, verify:" + fn.functionName);
+                    System.out
+                            .println("[ContractManager] getMethodNode, verify:" + fn.functionName);
                     TaintResult.nLocals = mn.maxLocals;
                     TaintResult.nStack = mn.maxStack;
                     TaintCFG cfg = new TaintCFG(mn);
@@ -273,22 +275,17 @@ public class ContractProcess {
                 MethodNode mn = methods.get(fn.functionName);
                 if (mn != null) {
                     /*
-                                        * CFGraph cfg = new CFGraph(mn) {
-                                        *
-                                        * @Override public BasicBlock getBasicBlock(int id) { return new
-                                        * BasicBlock(id); } }; FrontCF frontCF = new FrontCF(graph); String[]
-                    data =
-                                        * fn.plainText().split("\n"); for (int i = 0; i <
-                    graph.getBasicBlockSize();
-                                        * i++) { BasicBlock bb = graph.getBasicBlockAt(i); String decompiled =
-                    ""; if
-                                        * (bb.lineNum - 1 < data.length && bb.lineNum > 0) { decompiled =
-                                        * data[bb.lineNum - 1]; } frontCF.addBB(bb, decompiled); Set<BasicBlock>
-                    suc =
-                                        * graph.getSucBlocks(bb); for (BasicBlock sucBB : suc)
-                    frontCF.addEdge(bb,
-                                        * sucBB); }
-                                        */
+                     * CFGraph cfg = new CFGraph(mn) {
+                     *
+                     * @Override public BasicBlock getBasicBlock(int id) { return new
+                     * BasicBlock(id); } }; FrontCF frontCF = new FrontCF(graph); String[] data =
+                     * fn.plainText().split("\n"); for (int i = 0; i < graph.getBasicBlockSize();
+                     * i++) { BasicBlock bb = graph.getBasicBlockAt(i); String decompiled = ""; if
+                     * (bb.lineNum - 1 < data.length && bb.lineNum > 0) { decompiled =
+                     * data[bb.lineNum - 1]; } frontCF.addBB(bb, decompiled); Set<BasicBlock> suc =
+                     * graph.getSucBlocks(bb); for (BasicBlock sucBB : suc) frontCF.addEdge(bb,
+                     * sucBB); }
+                     */
                     TaintResult.nLocals = mn.maxLocals;
                     TaintResult.nStack = mn.maxStack;
                     TaintCFG cfg = new TaintCFG(mn);
@@ -309,55 +306,56 @@ public class ContractProcess {
                         List<Integer> ids = map.get(i);
                         frontCF.addBB(bb, decompiled, ids, cfg);
                         Set<BasicBlock> suc = cfg.getSucBlocks(bb);
-                        for (BasicBlock sucBB : suc) frontCF.addEdge(bb, sucBB);
+                        for (BasicBlock sucBB : suc)
+                            frontCF.addEdge(bb, sucBB);
                     }
                     // get result
                     // TaintBB lastBlock = cfg.getLastBlock();
-                    //                    if (lastBlock != null) {
-                    //                        frontCF.ret = lastBlock.getResultWithTaintBit();
-                    //                        // System.out.println(frontCF.ret);
-                    //                        if (parameters != null && parameters != "") {
-                    //                            // System.out.println(parameters);
-                    //                            // frontCF.finalRet = "yes";
-                    //                            Gson gson = JsonUtil;
-                    //                            JsonParser jsonParser = new JsonParser();
-                    //                            JsonArray jsonArray =
+                    // if (lastBlock != null) {
+                    // frontCF.ret = lastBlock.getResultWithTaintBit();
+                    // // System.out.println(frontCF.ret);
+                    // if (parameters != null && parameters != "") {
+                    // // System.out.println(parameters);
+                    // // frontCF.finalRet = "yes";
+                    // Gson gson = JsonUtil;
+                    // JsonParser jsonParser = new JsonParser();
+                    // JsonArray jsonArray =
                     // jsonParser.parse(parameters).getAsJsonArray();
-                    //                            List<String> listConstraint = new ArrayList<>();
-                    //                            List<String> listResource = new ArrayList<>();
-                    //                            for (JsonElement je : jsonArray) {
-                    //                                Bean bean = gson.fromJson(je, Bean.class);
-                    //                                switch (bean.name) {
-                    //                                    case "open":
-                    //                                        listConstraint.add("open");
-                    //                                        break;
-                    //                                    case "byValue":
-                    //                                        listConstraint.add("byValue");
-                    //                                        break;
-                    //                                    case "control":
-                    //                                        listConstraint.add("control");
-                    //                                        break;
-                    //                                    case "close":
-                    //                                        listConstraint.add("close");
-                    //                                        break;
-                    //                                    case "originalData":
-                    //                                        listResource.add("originalData");
-                    //                                        break;
-                    //                                    case "contractCall":
-                    //                                        listResource.add("contractCall");
-                    //                                        break;
-                    //                                }
-                    //                            }
-                    ////                            String dep =
+                    // List<String> listConstraint = new ArrayList<>();
+                    // List<String> listResource = new ArrayList<>();
+                    // for (JsonElement je : jsonArray) {
+                    // Bean bean = gson.fromJson(je, Bean.class);
+                    // switch (bean.name) {
+                    // case "open":
+                    // listConstraint.add("open");
+                    // break;
+                    // case "byValue":
+                    // listConstraint.add("byValue");
+                    // break;
+                    // case "control":
+                    // listConstraint.add("control");
+                    // break;
+                    // case "close":
+                    // listConstraint.add("close");
+                    // break;
+                    // case "originalData":
+                    // listResource.add("originalData");
+                    // break;
+                    // case "contractCall":
+                    // listResource.add("contractCall");
+                    // break;
+                    // }
+                    // }
+                    //// String dep =
                     // frontCF.blocks.get(frontCF.blocks.size() - 1).blockDep;
-                    ////                            if ((listConstraint.contains("open")
-                    ////                                            ||
+                    //// if ((listConstraint.contains("open")
+                    //// ||
                     // listConstraint.contains("close"))
-                    ////                                    && (frontCF.ret != null || dep != null))
-                    ////                                frontCF.finalRet = "不通过";
-                    ////                             else frontCF.finalRet = "通过";
-                    //                         }
-                    //                    }
+                    //// && (frontCF.ret != null || dep != null))
+                    //// frontCF.finalRet = "不通过";
+                    //// else frontCF.finalRet = "通过";
+                    // }
+                    // }
                     result.put(fn.functionName, frontCF);
                 }
             }
@@ -402,10 +400,8 @@ public class ContractProcess {
             String yancloud_desktop = "";
             isOpen.put(pmList[0], pmList[1]);
             yancloud_desktop += UtilRegistry.getInitStr(pmList[0], pmList[1].equals("open"));
-            engine.getNashornEngine()
-                    .getContext()
-                    .setAttribute(
-                            ScriptEngine.FILENAME, yancloud_desktop, ScriptContext.ENGINE_SCOPE);
+            engine.getNashornEngine().getContext().setAttribute(ScriptEngine.FILENAME,
+                    yancloud_desktop, ScriptContext.ENGINE_SCOPE);
             engine.getNashornEngine().eval(yancloud_desktop);
         } catch (ScriptException e) {
             e.printStackTrace();
@@ -427,25 +423,20 @@ public class ContractProcess {
     // 判断是否满足Oracle和Contact的执行要求
     public String verifyOracleAndContractPermission(Contract contract) {
         // 权限校验 如果是Oracle 启动方式只能是Sole 否则报错
-        if (cn.getYjsType() == YjsType.Oracle && contract.getType() != ContractExecType.Sole && contract.getType() != ContractExecType.Sharding) {
+        if (cn.getYjsType() == YjsType.Oracle && contract.getType() != ContractExecType.Sole
+                && contract.getType() != ContractExecType.Sharding) {
             LOGGER.info("Oracle only support Sole ContractType!");
-            return JsonUtil.toJson(
-                    new ContractResult(
-                            Status.Error,
-                            new JsonPrimitive("Oracle only support Sole ContractType!")));
+            return JsonUtil.toJson(new ContractResult(Status.Error,
+                    new JsonPrimitive("Oracle only support Sole ContractType!")));
         }
         // 权限校验 如果是contract 申请了MySQL等权限 报错
         if (cn.getYjsType() == YjsType.Contract) {
             for (Permission per : cn.getPermission()) {
-                if (per == Permission.SQL
-                        || per == Permission.Http
-                        || per == Permission.RocksDB
+                if (per == Permission.SQL || per == Permission.Http || per == Permission.RocksDB
                         || per == Permission.MongoDB) {
                     LOGGER.debug("Contract can not have permissions of IO!");
-                    return JsonUtil.toJson(
-                            new ContractResult(
-                                    Status.Error,
-                                    new JsonPrimitive("Contract can not have permissions of IO|")));
+                    return JsonUtil.toJson(new ContractResult(Status.Error,
+                            new JsonPrimitive("Contract can not have permissions of IO|")));
                 }
             }
         }
@@ -456,45 +447,45 @@ public class ContractProcess {
         JavaScriptEntry.members = members;
         if (members != null)
             return members.size() + "";
-        else return "0";
+        else
+            return "0";
     }
 
     public String setContractBundle(Contract contract) {
         try {
-            //            long start = System.currentTimeMillis();
-            //            long start0 = start;
+            fixContractIfNecessary(contract);
+            // long start = System.currentTimeMillis();
+            // long start0 = start;
             this.contract = contract;
+
             JavaScriptEntry.random = new Random();
             JavaScriptEntry.invokeID = 0L;
             JavaScriptEntry.random.setSeed(Integer.parseInt(contract.getID()));
             JavaScriptEntry.numOfCopies = this.contract.getNumOfCopies();
-            JavaScriptEntry.shardingID =
-                    this.contract.getShardingId(); // 设置javaScriptEntry中的shardingID
+            JavaScriptEntry.shardingID = this.contract.getShardingId(); // 设置javaScriptEntry中的shardingID
             // JavaScriptEntry
+            // contract.getCreateParam().get("repoId").getAsString()-->去获取repoId。
+            // 知道自己的BDOID --> repo的id。+contract.getID()
             String zipPath = contract.getScriptStr();
             if (isArchiveFile(new File(zipPath))) {
                 ZipFile zf = new ZipFile(zipPath);
                 ContractZipBundle zipBundle = new YJSCompiler().compile(zf);
                 cn = zipBundle.mergeContractNode();
                 // check functionNodes
-                List<FunctionNode> functionNodes = cn.getFunctions();
                 injectHandlers();
 
                 this.contract.setYjsType(cn.getYjsType());
                 memorySet = cn.memorySet;
                 this.contract.sourcePath = zipBundle.getManifest().sourcePath;
 
-                LOGGER.debug(
-                        "check sourcePath\n\tin-contract="
-                                + this.contract.sourcePath
-                                + "\n\tin-manifest="
-                                + zipBundle.getManifest().sourcePath);
+                LOGGER.debug("check sourcePath\n\tin-contract=" + this.contract.sourcePath
+                        + "\n\tin-manifest=" + zipBundle.getManifest().sourcePath);
                 // zhanghongwei
 
-                /*                if (ret.getManifest().getInsnLimit() != 0) {
-                    gasLimit=ret.getManifest().getInsnLimit();
-                    isInsnLimit = true;
-                }*/
+                /*
+                 * if (ret.getManifest().getInsnLimit() != 0) {
+                 * gasLimit=ret.getManifest().getInsnLimit(); isInsnLimit = true; }
+                 */
                 String ver = verifyOracleAndContractPermission(contract);
                 if (!ver.isEmpty()) {
                     return ver;
@@ -505,10 +496,8 @@ public class ContractProcess {
                 }
 
                 handleLog();
-
                 // System.out.println("[ret.getManifest().getInsnLimit()]" +
                 // ret.getManifest().getInsnLimit());
-
                 engine = new DesktopEngine(zipBundle.getManifest(), zipPath, contract);
                 engine.loadJar(zf);
                 engine.registerResource(new Resources(zf, engine.getClassLoad()));
@@ -519,12 +508,12 @@ public class ContractProcess {
                 jo.add("loadContract", JsonUtil.parseObject(result));
                 jo.addProperty("status", result.status.merge(onCreate.status).toString());
                 LOGGER.debug("result: " + jo.toString());
-
-                if(cn.getYjsType() == YjsType.DoipModule) {
-                    LOGGER.info("the doipServer has started");
-                    DoipServerTest.main(new String[]{"8080"});
+                // doipModule的话，拉起DoipServer服务端口
+                if (cn.hasDoipModule()) {
+                    // 只有一台机器去更新Router中的repoInfo就可以了
+                    updateRepoInfo(contract.getCreateParam());
+                    invokeOnStartingDoipServer(cn, contract.getCreateParam(), jo);
                 }
-
                 return jo.toString();
             } else {
                 contract.setScript(FileUtil.getFileContent(zipPath));
@@ -532,19 +521,27 @@ public class ContractProcess {
             }
 
         } catch (MalformedJsonException | JsonSyntaxException e) {
-            return JsonUtil.toJson(
-                    new ContractResult(
-                            Status.Error,
-                            new JsonPrimitive("parse manifest.json error, not json format!")));
+            return JsonUtil.toJson(new ContractResult(Status.Error,
+                    new JsonPrimitive("parse manifest.json error, not json format!")));
         } catch (Exception e) {
             ByteArrayOutputStream bo = new ByteArrayOutputStream();
             e.printStackTrace(new PrintStream(bo));
-            return JsonUtil.toJson(
-                    new ContractResult(Status.Error, new JsonPrimitive(bo.toString())));
+            return JsonUtil
+                    .toJson(new ContractResult(Status.Error, new JsonPrimitive(bo.toString())));
         }
     }
 
-    private void injectHandlers() {
+    private void fixContractIfNecessary(Contract contract) {
+        if (contract.getID() == null)
+            contract.setID(contract.getScriptStr().hashCode() + "");
+        if (contract.getPublicKey() == null) {
+            SM2KeyPair pair = SM2Util.generateSM2KeyPair();
+            contract.setKey(pair.getPrivateKeyStr());
+            contract.setPublicKey(pair.getPublicKeyStr());
+        }
+    }
+
+    private void injectHandlers() throws Exception {
         // 正式启动
         if (!this.contract.isDebug()) {
             // this.engine.getResources().loadAsString("/maskConfig.json");
@@ -557,35 +554,40 @@ public class ContractProcess {
                 }
             }
         }
+        DOOPBeforeExecHandler doopBeforeExecHandler = null;
+        DOOPAfterExecHandler doopAfterExecHandler = null;
+        doopRequestHandler = null;
         for (FunctionNode fun : cn.getFunctions()) {
             if (fun.isConfidential()) {
                 fun.appendBeforeInvokeHandler(new ConfidentialHandler(fun));
             }
-            ArgSchemaHandler argSchemaHandler = createHandlerIfExist(fun, fun.annotations, ArgSchemaHandler.class);
+            ArgSchemaHandler argSchemaHandler = createHandlerIfExist(fun, ArgSchemaHandler.class);
             if (argSchemaHandler != null) {
                 fun.appendBeforeInvokeHandler(argSchemaHandler);
             }
 
-            if (fun.isDoipOperation()) {
-                fun.appendBeforeInvokeHandler(DOOPHandler.createDOOPHandler());
-            }
 
             if (fun.isExport()) {
-                //if(fun.annotations...)
-                AccessHandler accessHandler = createHandlerIfExist(fun,fun.annotations,AccessHandler.class);
+                // if(fun.annotations...)
+                AccessHandler accessHandler = createHandlerIfExist(fun, AccessHandler.class);
                 if (accessHandler != null) {
                     fun.appendBeforeInvokeHandler(accessHandler);
                 }
                 fun.appendAfterInvokeHandler(new ObjToJsonHandler());
+                ResultSchemaHandler resultSchemaHandler =
+                        createHandlerIfExist(fun, ResultSchemaHandler.class);
+                if (resultSchemaHandler != null) {
+                    fun.appendAfterInvokeHandler(resultSchemaHandler);
+                }
                 // fun.appendBeforeInvokeHandler(new ReadMeHandler());
                 // Mask是用于返回真正结果之后，做一些偏移，以保护数据隐私。
                 // if (fun.isMask()) {
 
                 // String maskConfig =
-                //        engine.getResources().loadAsString("/maskConfig.json");
+                // engine.getResources().loadAsString("/maskConfig.json");
                 // System.out.println("injectMask"+maskConfig);
                 // System.out.println("injectMask"+this.contract.Mask);
-                fun.appendAfterInvokeHandler(new MaskHandler());
+                // fun.appendAfterInvokeHandler(new MaskHandler());
                 // }
             }
             if (fun.isHomomorphicEncrypt()) {
@@ -596,23 +598,33 @@ public class ContractProcess {
                 fun.appendAfterInvokeHandler(new HomomorphicDecryptHandler(fun));
             }
 
+            if (fun.isDoipOperation()) {
+                if (doopRequestHandler == null) {
+                    doopRequestHandler = new DOOPRequestHandler();
+                }
+                fun.appendBeforeInvokeHandler(
+                        new DOOPBeforeExecHandler(fun.getDoipOperationInfo().operation));
+                fun.appendAfterInvokeHandler(
+                        new DOOPAfterExecHandler(fun.getDoipOperationInfo().operation));
+                doopRequestHandler.addDoipOperation(fun);
+            }
         }
     }
 
-    <T extends AnnotationHook> T createHandlerIfExist(FunctionNode function, List<AnnotationNode> annotations, Class<T> clz) {
+    <T extends AnnotationHook> T createHandlerIfExist(FunctionNode function, Class<T> clz) {
         YJSAnnotation annotation = clz.getAnnotation(YJSAnnotation.class);
-        if (annotation == null) return null;
-        if (annotations == null) return null;
-        for (AnnotationNode node : annotations) {
-            if (annotation.name().equals(node.getType())) {
-                try {
-                    Method m = clz.getDeclaredMethod("fromAnnotationNode", FunctionNode.class, AnnotationNode.class);
-                    T result = (T) m.invoke(null, function, node);
-                    return result;
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
+        if (annotation == null)
+            return null;
+        try {
+            AnnotationNode node = function.getAnnotation(annotation.name());
+            if (node == null)
+                return null;
+            Method m = clz.getDeclaredMethod("fromAnnotationNode", FunctionNode.class,
+                    AnnotationNode.class);
+            T result = (T) m.invoke(null, function, node);
+            return result;
+        } catch (Exception e) {
+            e.printStackTrace();
         }
         return null;
     }
@@ -630,9 +642,13 @@ public class ContractProcess {
 
     public String setContract(Contract contract) {
         try {
+            fixContractIfNecessary(contract);
             JavaScriptEntry.random = new Random();
             JavaScriptEntry.invokeID = 0L;
-            JavaScriptEntry.random.setSeed(Integer.parseInt(contract.getID()));
+            if (contract.getID() == null)
+                JavaScriptEntry.random.setSeed(contract.getScriptStr().hashCode());
+            else
+                JavaScriptEntry.random.setSeed(Integer.parseInt(contract.getID()));
             JavaScriptEntry.numOfCopies = contract.getNumOfCopies();
             // TODO Optimize, 4 seconds takes to create an Engine.
             engine = new DesktopEngine();
@@ -650,8 +666,7 @@ public class ContractProcess {
             handleLog();
             LOGGER.info("load script, contract:" + JsonUtil.toJson(contract.getScriptStr()));
             LOGGER.info("load cn:" + JsonUtil.toJson(cn));
-            ContractResult ret =
-                    engine.loadContract(contract, cn, cn.getInstrumentBranch());
+            ContractResult ret = engine.loadContract(contract, cn, cn.getInstrumentBranch());
             ContractResult onCreate = invokeOnCreate(contract.getCreateParam());
             JsonObject jo = new JsonObject();
             jo.add("onCreate", JsonUtil.parseObject(onCreate));
@@ -660,17 +675,95 @@ public class ContractProcess {
             LOGGER.debug("result: " + jo.toString());
 
             // doipModule的话，拉起DoipServer服务端口
-            if(cn.getYjsType() == YjsType.DoipModule) {
-                LOGGER.info("the doipServer has started");
-                DoipServerTest.main(new String[]{"8080"});
+            if (cn.getYjsType() == YjsType.DoipModule) {
+                updateRepoInfo(contract.getCreateParam());
+                invokeOnStartingDoipServer(cn, contract.getCreateParam(), jo);
             }
 
             return jo.toString();
         } catch (Exception e) {
             ByteArrayOutputStream bo = new ByteArrayOutputStream();
             e.printStackTrace(new PrintStream(bo));
-            return JsonUtil.toJson(
-                    new ContractResult(Status.Error, new JsonPrimitive(bo.toString())));
+            return JsonUtil
+                    .toJson(new ContractResult(Status.Error, new JsonPrimitive(bo.toString())));
+        }
+    }
+
+    public void updateRepoInfo(JsonElement arg) throws Exception {
+        // 只有0号节点需要初始化IRP连接去updateRepoInfo
+        // just disable this part
+        if (JavaScriptEntry.shardingID == -1) {
+            // DOOP relevant logic
+            DoipClusterServer server = DoipClusterServer.getDOOPServerInstance();
+            if (server == null) {
+                JsonObject createParams = arg.getAsJsonObject();
+                if (createParams.has("router")) {
+                    JsonElement routerInfo = createParams.get("router");
+                    if (!routerInfo.isJsonObject())
+                        throw new Exception(
+                                "Provide wrong router info in create params to DoipModule");
+                    else {
+                        EndpointConfig endpointConfig = JsonUtil.GSON
+                                .fromJson(routerInfo.getAsJsonObject(), EndpointConfig.class);
+                        DoipClusterServer.createDOOPServerInstance(endpointConfig);
+                    }
+                } else {
+                    throw new Exception("DoipModule should provide router info in create params");
+                }
+
+                server = DoipClusterServer.getDOOPServerInstance();
+            }
+            // 只有一台机器去更新Router中的repoInfo就可以了
+
+            server.updateRepoInfo(contract, cn);
+        }
+    }
+
+    public void invokeOnStartingDoipServer(ContractNode cn, JsonElement arg,
+            JsonObject returnValue) {
+        ContractRequest onStartingDoipServer = new ContractRequest();
+        onStartingDoipServer.setAction("onServerStart");
+        if (arg == null) {
+            if (engine != null && engine.getManifest() != null
+                    && engine.getManifest().createParam != null)
+                arg = engine.getManifest().createParam;
+            else
+                arg = new JsonPrimitive("");
+        }
+        onStartingDoipServer.setArg(arg);
+        LOGGER.debug(
+                "invoke onStartingDoipServer, param:" + onStartingDoipServer.getArg().toString());
+        onStartingDoipServer.setRequester(contract.getOwner());
+        FunctionNode funNode = cn.getFunction("onServerStart");
+
+        try {
+            JsonElement onStartingDoipServerRes = invoke(onStartingDoipServer, funNode).result;
+            returnValue.add("doipModuleStartResult", onStartingDoipServerRes);
+            int startPort = ContractProcess.instance.server.getPort() + 1;
+            if (arg.isJsonObject() && arg.getAsJsonObject().has("doipStartPort")) {
+                startPort = arg.getAsJsonObject().get("doipStartPort").getAsInt();
+            }
+            LOGGER.info("Fetch the onStartingDoipServerRes from router successfully, the result is "
+                    + onStartingDoipServerRes);
+            int doipListenPort =
+                    DoipClusterServer.startDoipServer(startPort, onStartingDoipServerRes);
+            returnValue.addProperty("doipListenPort", doipListenPort);
+            this.contract.setDoipPort(doipListenPort);
+            returnValue.addProperty("doipStartPort", startPort);
+        } catch (Exception e) {
+            LOGGER.error(
+                    "DoipLocalSingleton cannot starts properly, plz check the onServerStart function");
+            e.printStackTrace();
+        }
+        funNode = cn.getFunction("onInitSharableVars");
+
+        if (funNode != null) {
+            ContractRequest requestForInitVar = new ContractRequest();
+            requestForInitVar.setAction("onInitSharableVars");
+            requestForInitVar.setArg(onStartingDoipServer.getArg());
+            requestForInitVar.setRequester(onStartingDoipServer.getRequester());
+            JsonElement onInitSharableVars = invoke(requestForInitVar, funNode).result;
+            returnValue.add("onInitSharableVars", onInitSharableVars);
         }
     }
 
@@ -694,7 +787,8 @@ public class ContractProcess {
                 }
             }
 
-            if (fun.getLogToBDContract()) detail.append("bdcontract;");
+            if (fun.getLogToBDContract())
+                detail.append("bdcontract;");
             if (fun.getLogToNamedLedger()) {
                 for (String str : fun.getLedgerNames()) {
                     detail.append("bdledger:").append(str).append(";");
@@ -732,9 +826,6 @@ public class ContractProcess {
         }
 
         JavaScriptEntry.setSM2KeyPair(contract.getPublicKey(), contract.getKey());
-        if (null != contract.getDOI() && !contract.getDOI().isEmpty()) {
-            JavaScriptEntry.doi = contract.getDOI();
-        }
         if (null != contract.getAuthInfoPersistDOI()
                 && !contract.getAuthInfoPersistDOI().isEmpty()) {
             JavaScriptEntry.authInfoPersistDOI = contract.getAuthInfoPersistDOI();
@@ -743,7 +834,8 @@ public class ContractProcess {
         ContractRequest onCreate = new ContractRequest();
         onCreate.setAction("onCreate");
         if (arg == null) {
-            if (engine != null && engine.getManifest() != null && engine.getManifest().createParam != null)
+            if (engine != null && engine.getManifest() != null
+                    && engine.getManifest().createParam != null)
                 arg = engine.getManifest().createParam;
             else
                 arg = new JsonPrimitive("");
@@ -751,11 +843,6 @@ public class ContractProcess {
         onCreate.setArg(arg);
         LOGGER.debug("invoke onCreate, param:" + onCreate.getArg().toString());
         onCreate.setRequester(contract.getOwner());
-        if (contract.getDoipFlag() && null != contract.getDOI() && !contract.getDOI().isEmpty()) {
-            onCreate.setRequesterDOI(contract.getDOI());
-        } else {
-            onCreate.setRequesterDOI("empty");
-        }
         FunctionNode funNode = cn.getFunction("onCreate");
         return invoke(onCreate, funNode);
     }
@@ -773,13 +860,6 @@ public class ContractProcess {
         else
             onRecover.setArg(arg);
         onRecover.setRequester(contract.getOwner());
-        if (contract.getDoipFlag()
-                && (contract.getDOI() != null)
-                && (contract.getDOI().length() > 0)) {
-            onRecover.setRequesterDOI(contract.getDOI());
-        } else {
-            onRecover.setRequesterDOI("empty");
-        }
         FunctionNode funNode = cn.getFunction("onRecover");
         return invoke(onRecover, funNode);
     }
@@ -828,8 +908,7 @@ public class ContractProcess {
         List<Long> hashes = logIndex.request(offset, size);
         List<Map<String, String>> jo = new ArrayList<>();
 
-        TypeToken<Map<String, String>> token = new TypeToken<Map<String, String>>() {
-        };
+        TypeToken<Map<String, String>> token = new TypeToken<Map<String, String>>() {};
         for (Long hash : hashes)
             try {
                 Map<String, String> obj =
@@ -844,8 +923,7 @@ public class ContractProcess {
     public String requestLast(int count) {
         List<Long> hashes = logIndex.requestLast(count);
         List<Map<String, String>> jo = new ArrayList<>();
-        TypeToken<Map<String, String>> token = new TypeToken<Map<String, String>>() {
-        };
+        TypeToken<Map<String, String>> token = new TypeToken<Map<String, String>>() {};
         String log;
         for (Long hash : hashes)
             try {
@@ -855,8 +933,8 @@ public class ContractProcess {
                 }
                 Map<String, String> obj = JsonUtil.fromJson(log, token.getType());
                 if (obj == null) {
-                    System.out.println(
-                            "[ContractProcess] requestLast, parseJsonError:" + log + "==");
+                    System.out
+                            .println("[ContractProcess] requestLast, parseJsonError:" + log + "==");
                     continue;
                 }
                 obj.put("hash", hash + "");
@@ -899,9 +977,8 @@ public class ContractProcess {
         try {
             request = JsonUtil.fromJson(arg, ContractRequest.class);
         } catch (Exception ignored) {
-            result =
-                    new ContractResult(
-                            ContractResult.Status.Error, new JsonPrimitive("Illegal Arguments!"));
+            result = new ContractResult(ContractResult.Status.Error,
+                    new JsonPrimitive("Illegal Arguments!"));
             return JsonUtil.toJson(result);
         }
         String reqID = request.getRequestID();
@@ -922,9 +999,9 @@ public class ContractProcess {
                 engine.redirectTracePS(new Logger(bo, this));
                 result = engine.executeContract(request);
                 result.analysis = bo.toString();
-                System.out.println(
-                        "[ContractProcess] result.analysis = "
-                                + result.analysis); // 动态分析bug null pointer
+                System.out.println("[ContractProcess] result.analysis = " + result.analysis); // 动态分析bug
+                // null
+                // pointer
                 // branchResult = JsonUtil.toJson(result);
                 // branchTrace = result.analysis;
                 engine.redirectTracePS(previous);
@@ -943,16 +1020,8 @@ public class ContractProcess {
                     evaluatesAnalysis(request.getAction());
                 }
 
-                engine.redirectTracePS(
-                        new ProgramPointCounter(
-                                bo,
-                                this,
-                                gasLimit,
-                                functionIndex,
-                                request.getValue(),
-                                0L,
-                                request.getAction(),
-                                ppCountMap));
+                engine.redirectTracePS(new ProgramPointCounter(bo, this, gasLimit, functionIndex,
+                        request.getValue(), 0L, request.getAction(), ppCountMap));
                 result = engine.executeContract(request);
 
                 result.analysis = bo.toString();
@@ -993,13 +1062,12 @@ public class ContractProcess {
         for (String s : function) {
             MethodNode mn = methods.get(s);
             if (mn != null) {
-                CFGraph cfg =
-                        new CFGraph(mn) {
-                            @Override
-                            public BasicBlock getBasicBlock(int id) {
-                                return new BasicBlock(id);
-                            }
-                        };
+                CFGraph cfg = new CFGraph(mn) {
+                    @Override
+                    public BasicBlock getBasicBlock(int id) {
+                        return new BasicBlock(id);
+                    }
+                };
                 // cfg.printSelf();
                 CFGmap.put(s, cfg);
                 PPCount countFee = new PPCount(cfg, flag);
@@ -1061,11 +1129,8 @@ public class ContractProcess {
 
             TaintBB bb = cfg.getLastBlock();
             result.analysis = bb.getResultWithTaintBit();
-            System.out.println(
-                    "[ContractProcess] dynamically verify: "
-                            + ac.getAction()
-                            + "-->"
-                            + result.analysis);
+            System.out.println("[ContractProcess] dynamically verify: " + ac.getAction() + "-->"
+                    + result.analysis);
         }
     }
 
@@ -1087,8 +1152,7 @@ public class ContractProcess {
         return !JavaScriptEntry.topic_handlers.isEmpty();
     }
 
-    public void beforeSuicide() {
-    }
+    public void beforeSuicide() {}
 
     public String redo(String path) {
         return engine.syncUtil.redo(path);
@@ -1127,7 +1191,7 @@ public class ContractProcess {
     public void writeContractDB(Map<String, String> data) {
         String path = dbPath;
         if (path == null) {
-            //            return "nopath";
+            // return "nopath";
             return;
         }
         try {
@@ -1137,14 +1201,13 @@ public class ContractProcess {
             edion.put(String.valueOf(hash), result);
         } catch (Exception e) {
             e.printStackTrace();
-            //            return "failed";
+            // return "failed";
         }
-        //        return "success";
+        // return "success";
     }
 
     @Override
-    protected void finalize() {
-    }
+    protected void finalize() {}
 
     public String getDeclaredEvents() {
         return JsonUtil.toJson(cn.events);
@@ -1159,8 +1222,8 @@ public class ContractProcess {
         for (FunctionNode fn : cn.getFunctions()) {
             if (fn.isExport() && !fn.functionName.equals("onCreate")) {
                 function.add(fn.functionName);
-                FunctionDesp desp =
-                        new FunctionDesp(fn.functionName, fn.annotations, fn.getRouteInfo(), fn.getJoinInfo(), fn.isView());
+                FunctionDesp desp = new FunctionDesp(fn.functionName, fn.annotations,
+                        fn.getRouteInfo(), fn.getJoinInfo(), fn.isView());
                 ret.add(desp);
             }
         }
@@ -1181,11 +1244,8 @@ public class ContractProcess {
 
     public String startAutoDump() {
         String dumpPeriod = projectConfig.getDumpPeriod();
-        System.out.println(
-                "[ContractProcess] startAutoDump : "
-                        + cn.getContractName()
-                        + " period = "
-                        + dumpPeriod);
+        System.out.println("[ContractProcess] startAutoDump : " + cn.getContractName()
+                + " period = " + dumpPeriod);
         String status = "startAutoDump status 0";
         if (null != dt) {
             if (null == dumpPeriod || dumpPeriod.isEmpty()) {
@@ -1290,21 +1350,21 @@ public class ContractProcess {
         if (period != null && period.length() > 0) {
             changeDumpPeriod(period);
         }
-        //        System.out.println("ContractProcessMask");
-        //        JsonObject argsJS = JsonParser.parseString(args).getAsJsonObject();
-        //        String contractID = "";
-        //        String operation = "";
-        //        JsonElement mask = JsonParser.parseString("");
-        //        if (argsJS.has("contractID") && argsJS.has("operation") && argsJS.has("maskInfo"))
+        // System.out.println("ContractProcessMask");
+        // JsonObject argsJS = JsonParser.parseString(args).getAsJsonObject();
+        // String contractID = "";
+        // String operation = "";
+        // JsonElement mask = JsonParser.parseString("");
+        // if (argsJS.has("contractID") && argsJS.has("operation") && argsJS.has("maskInfo"))
         // {
-        //            contractID = argsJS.get("contractID").getAsString();
-        //            System.out.println(contractID);
-        //            operation = argsJS.get("operation").getAsString();
-        //            System.out.println(operation);
-        //            mask = argsJS.get("maskInfo");
-        //            System.out.println("mask" + mask);
-        //            this.contract.setMask(operation, mask);
-        //        }
+        // contractID = argsJS.get("contractID").getAsString();
+        // System.out.println(contractID);
+        // operation = argsJS.get("operation").getAsString();
+        // System.out.println(operation);
+        // mask = argsJS.get("maskInfo");
+        // System.out.println("mask" + mask);
+        // this.contract.setMask(operation, mask);
+        // }
     }
 
     public String getDependentContracts() {
@@ -1366,9 +1426,8 @@ public class ContractProcess {
     private class DumpTask extends TimerTask {
         @Override
         public void run() {
-            System.out.println(
-                    "[ContractProcess  DumpTask] auto dump period : "
-                            + projectConfig.getDumpPeriod());
+            System.out.println("[ContractProcess  DumpTask] auto dump period : "
+                    + projectConfig.getDumpPeriod());
             File file1 = new File(dir);
             File file2 = new File(file1.getParent());
             String dir2 = file2.getParent() + "/memory/";

src/main/java/org/bdware/sc/SM2Helper.java

@@ -31,11 +31,13 @@ public class SM2Helper {
                 backupFile(new File("./cmconfig.json"));
                 System.out.println("Generate file: cmconfig.json");
                 String content = FileUtil.getFileContent("./cmconfig.json.template");
-                JsonObject jo = JsonParser.parseReader(new FileReader("cmvar.json")).getAsJsonObject();
+                JsonObject jo =
+                        JsonParser.parseReader(new FileReader("cmvar.json")).getAsJsonObject();
                 for (String key : jo.keySet()) {
                     content = content.replaceAll(key, jo.get(key).getAsString());
                 }
-                JsonObject keypair = JsonParser.parseReader(new FileReader("manager.keypair")).getAsJsonObject();
+                JsonObject keypair =
+                        JsonParser.parseReader(new FileReader("manager.keypair")).getAsJsonObject();
                 content = content.replaceAll("_PRIVKEY", keypair.get("privateKey").getAsString());
                 content = content.replaceAll("_PUBKEY", keypair.get("publicKey").getAsString());
                 content = content.replaceAll("CMI", System.currentTimeMillis() + "");
@@ -58,15 +60,18 @@ public class SM2Helper {
     }
 
     private static void backupFile(File file) {
-        if (!file.exists()) return;
+        if (!file.exists())
+            return;
         File backup = null;
         for (int i = 0; i <= 100; i++) {
-            if (i == 100) throw new IllegalArgumentException("failed to backup:" + file.getAbsolutePath());
+            if (i == 100)
+                throw new IllegalArgumentException("failed to backup:" + file.getAbsolutePath());
             backup = new File(file.getParent(), file.getName() + "." + i);
             if (!backup.exists())
                 break;
         }
         FileUtil.copyFile(file, backup);
-        System.out.println("Backup: " + file.getAbsolutePath() + " --> " + backup.getAbsolutePath());
+        System.out
+                .println("Backup: " + file.getAbsolutePath() + " --> " + backup.getAbsolutePath());
     }
 }

src/main/java/org/bdware/sc/analysis/dynamic/FSAnalysis.java

@@ -14,7 +14,6 @@ import org.objectweb.asm.tree.ClassNode;
 import org.objectweb.asm.tree.MethodNode;
 
 import java.io.ByteArrayInputStream;
-import java.io.FileInputStream;
 import java.util.*;
 import java.util.zip.ZipFile;
 
@@ -44,11 +43,8 @@ public class FSAnalysis extends BreadthFirstSearch<TaintResult, TaintBB> {
         setToAnalysis(toAnalysis);
         if (isDebug) {
             System.out.println("===Method:" + cfg.getMethodNode().name + cfg.getMethodNode().desc);
-            System.out.println(
-                    "===Local:"
-                            + cfg.getMethodNode().maxLocals
-                            + " "
-                            + cfg.getMethodNode().maxStack);
+            System.out.println("===Local:" + cfg.getMethodNode().maxLocals + " "
+                    + cfg.getMethodNode().maxStack);
         }
     }
 
@@ -81,9 +77,8 @@ public class FSAnalysis extends BreadthFirstSearch<TaintResult, TaintBB> {
                 ContractZipBundle czb = compiler.compile(zf);
                 cn = czb.mergeContractNode();
             } else {
-                cn =
-                        compiler.compile(
-                                new ByteArrayInputStream(script.getBytes()), "contract_main.yjs");
+                cn = compiler.compile(new ByteArrayInputStream(script.getBytes()),
+                        "contract_main.yjs");
             }
             DesktopEngine engine = new DesktopEngine(); // engine.loadJar(zf);
             engine.loadContract(c, cn, false);
@@ -109,7 +104,8 @@ public class FSAnalysis extends BreadthFirstSearch<TaintResult, TaintBB> {
                     FSAnalysis analysis = new FSAnalysis(cfg);
                     analysis.analysis();
                     TaintBB bb = cfg.getLastBlock();
-                    if (bb != null) result.put(fn.functionName, bb.getResult());
+                    if (bb != null)
+                        result.put(fn.functionName, bb.getResult());
                     cfg.printSelf();
                 }
             }

src/main/java/org/bdware/sc/boundry/AccountIndex.java

@@ -126,7 +126,8 @@ public class AccountIndex {
         }
 
         try {
-            LenVarTimeSerialIndex2 index = getIndexFile(getString(args, "account") + getString(args, "file"));
+            LenVarTimeSerialIndex2 index =
+                    getIndexFile(getString(args, "account") + getString(args, "file"));
             long startTime = getLong(args, "startTime");
             long endTime = getLong(args, "endTime");
             List<byte[]> result = index.requestByTime(startTime, endTime);
@@ -183,7 +184,8 @@ public class AccountIndex {
         }
 
         try {
-            LenVarTimeSerialIndex2 index = getIndexFile(getString(args, "account") + getString(args, "file"));
+            LenVarTimeSerialIndex2 index =
+                    getIndexFile(getString(args, "account") + getString(args, "file"));
             long date = getLong(args, "date");
             String content = getString(args, "content");
             index.manullyIndex(date, HashUtil.str16ToBytes(content));

src/main/java/org/bdware/sc/boundry/JavaScriptEntry.java

@@ -44,15 +44,14 @@ import java.util.concurrent.locks.ReentrantLock;
 import static org.bdware.sc.event.REvent.REventType.*;
 
 public class JavaScriptEntry {
-    //    private static final HostnameVerifier DO_NOT_VERIFY = (hostname, session) -> true;
+    // private static final HostnameVerifier DO_NOT_VERIFY = (hostname, session) -> true;
     public static final Map<String, ScriptFunction> topic_handlers = new HashMap<>();
     private static final Logger LOGGER = LogManager.getLogger(JavaScriptEntry.class);
     public static NashornScriptEngine currentEngine;
     public static SyncMechUtil currentSyncUtil;
-    //    public static int contractManagerPort;
+    // public static int contractManagerPort;
     public static Random random;
     public static long invokeID;
-    public static String doi;
     public static String authInfoPersistDOI;
     public static SocketGet get; // public static CloseableHttpClient httpClient = getHttpClient();
     public static int numOfCopies;
@@ -79,9 +78,8 @@ public class JavaScriptEntry {
     }
 
     public static void setSM2KeyPair(String pubKey, String privKey) {
-        keyPair =
-                new SM2KeyPair(
-                        SM2KeyPair.publicKeyStr2ECPoint(pubKey), new BigInteger(privKey, 16));
+        keyPair = new SM2KeyPair(SM2KeyPair.publicKeyStr2ECPoint(pubKey),
+                new BigInteger(privKey, 16));
     }
 
     public static SM2KeyPair getKeyPair() {
@@ -127,17 +125,17 @@ public class JavaScriptEntry {
         return "success";
     }
 
-    //	public static String http(String baseUrl, String method, Map<String, String> header,
+    // public static String http(String baseUrl, String method, Map<String, String> header,
     // Map<String, String> argMap,
-    //			List<String> reservedList) {
-    //		return HttpUtil.request(baseUrl, method, header, argMap, reservedList);
-    //	}
+    // List<String> reservedList) {
+    // return HttpUtil.request(baseUrl, method, header, argMap, reservedList);
+    // }
 
     public static byte[] inputStreamToBytes(InputStream in) {
         ByteArrayOutputStream bo = new ByteArrayOutputStream();
         byte[] buff = new byte[4 * 1024 * 1024];
         try {
-            for (int count; (count = in.read(buff)) > 0; ) {
+            for (int count; (count = in.read(buff)) > 0;) {
                 bo.write(buff, 0, count);
             }
         } catch (IOException e) {
@@ -169,8 +167,8 @@ public class JavaScriptEntry {
         return new ApiGate(ip, Integer.parseInt(port));
     }
 
-    public static String executeContractWithSig(
-            String contractID, String action, String arg, String pubkey, String sig) {
+    public static String executeContractWithSig(String contractID, String action, String arg,
+            String pubkey, String sig) {
         try {
             ContractRequest app = new ContractRequest();
             app.setContractID(contractID).setAction(action).setArg(arg);
@@ -180,26 +178,14 @@ public class JavaScriptEntry {
             if (!app.verifySignature()) {
                 return "{\"status\":\"Exception\",\"data\":\"invalid signature\"}";
             }
-            app.setRequesterDOI(doi);
             app.setFromDebug(isDebug);
             if (numOfCopies > 1) {
                 // The caller is special.
-                app.setRequestID(
-                        app.getPublicKey().hashCode()
-                                + "_"
-                                + numOfCopies
-                                + "_"
-                                + (invokeID++)
-                                + "_"
-                                + random.nextInt()
-                                + "_mul");
+                app.setRequestID(app.getPublicKey().hashCode() + "_" + numOfCopies + "_"
+                        + (invokeID++) + "_" + random.nextInt() + "_mul");
             } else {
-                app.setRequestID(
-                        app.getPublicKey().hashCode()
-                                + "_"
-                                + (invokeID++)
-                                + "_"
-                                + random.nextInt());
+                app.setRequestID(app.getPublicKey().hashCode() + "_" + (invokeID++) + "_"
+                        + random.nextInt());
             }
             return get.syncGet("dd", "executeContract", JsonUtil.toJson(app));
 
@@ -212,9 +198,8 @@ public class JavaScriptEntry {
 
     public static Object executeContract(String contractID, String action, Object arg) {
         if (currentSyncUtil.engine.recovering) {
-            String str =
-                    currentSyncUtil.transRecoverUtil.curRecoverRecord.getExecuteResult(
-                            invokeID + "");
+            String str = currentSyncUtil.transRecoverUtil.curRecoverRecord
+                    .getExecuteResult(invokeID + "");
             String[] strs = str.split("<seperate>");
             String flag1 = strs[0];
             String flag = strs[1];
@@ -235,30 +220,22 @@ public class JavaScriptEntry {
 
         try {
             ContractRequest app = new ContractRequest();
-            app.setContractID(contractID).setAction(action).setArg(JSONTool.convertMirrorToJson(arg));
+            app.setContractID(contractID).setAction(action)
+                    .setArg(JSONTool.convertMirrorToJson(arg));
             app.doSignature(keyPair);
-            app.setRequesterDOI(doi);
             app.setFromDebug(isDebug);
             ContractExecType type = ContractProcess.instance.getContract().getType();
             if (type.needSeq()) {
                 app.setRequestID(
-                        String.format(
-                                "%d_%d_%d_%d_mul",
-                                keyPair.getPublicKeyStr().hashCode(),
-                                numOfCopies,
-                                (invokeID++),
-                                random.nextInt()));
+                        String.format("%d_%d_%d_%d_mul", keyPair.getPublicKeyStr().hashCode(),
+                                numOfCopies, (invokeID++), random.nextInt()));
                 // The caller is special.
                 flag = 1;
                 flag1 = 1;
                 LOGGER.warn("invoke contractExecution! " + JsonUtil.toJson(app));
             } else {
-                app.setRequestID(
-                        String.format(
-                                "%d_%d_%d",
-                                keyPair.getPublicKeyStr().hashCode(),
-                                (invokeID++),
-                                random.nextInt()));
+                app.setRequestID(String.format("%d_%d_%d", keyPair.getPublicKeyStr().hashCode(),
+                        (invokeID++), random.nextInt()));
                 flag = 1;
                 flag1 = 1;
             }
@@ -267,76 +244,64 @@ public class JavaScriptEntry {
             ByteArrayOutputStream bo = new ByteArrayOutputStream();
             e.printStackTrace(new PrintStream(bo));
             String result = bo.toString();
-            if (currentSyncUtil.startFlag
-                    && currentSyncUtil.currType == SyncType.Trans
+            if (currentSyncUtil.startFlag && currentSyncUtil.currType == SyncType.Trans
                     && !currentSyncUtil.engine.recovering) {
-                currentSyncUtil.transRecordUtil.recordExecutes(
-                        formerInvokeID + "", flag1 + "<seperate>" + flag + "<seperate>" + result);
+                currentSyncUtil.transRecordUtil.recordExecutes(formerInvokeID + "",
+                        flag1 + "<seperate>" + flag + "<seperate>" + result);
             }
             return result;
         }
     }
 
-    private static Object executeContract(long formerInvokeID, int flag1, int flag, ContractRequest app) {
+    private static Object executeContract(long formerInvokeID, int flag1, int flag,
+            ContractRequest app) {
         String result = get.syncGet("dd", "executeContract", JsonUtil.toJson(app));
-        if (currentSyncUtil.startFlag
-                && currentSyncUtil.currType == SyncType.Trans
+        if (currentSyncUtil.startFlag && currentSyncUtil.currType == SyncType.Trans
                 && !currentSyncUtil.engine.recovering) {
-            currentSyncUtil.transRecordUtil.recordExecutes(
-                    formerInvokeID + "",
+            currentSyncUtil.transRecordUtil.recordExecutes(formerInvokeID + "",
                     flag1 + "<seperate>" + flag + "<seperate>" + result);
         }
         JsonObject jo = JsonUtil.parseStringAsJsonObject(result);
         return JSONTool.convertJsonElementToMirror(jo);
     }
 
-    public static void executeContractAsyncWithoutSig(
-            String contractID, String action, String arg, final ScriptFunction cb) {
+    public static void executeContractAsyncWithoutSig(String contractID, String action, String arg,
+            final ScriptFunction cb) {
         try {
             ContractRequest app = new ContractRequest();
             app.setContractID(contractID).setAction(action).setArg(arg);
             app.setRequestID((invokeID++) + "_" + random.nextInt());
-            get.asyncGet(
-                    "dd",
-                    "executeContract",
-                    JsonUtil.toJson(app),
-                    new ResultCallback() {
-                        @Override
-                        public void onResult(String str) {
-                            if (null != cb) {
-                                DesktopEngine.applyWithGlobal(
-                                        cb, currentEngine.getNashornGlobal(), str);
-                            }
-                        }
-                    });
+            get.asyncGet("dd", "executeContract", JsonUtil.toJson(app), new ResultCallback() {
+                @Override
+                public void onResult(String str) {
+                    if (null != cb) {
+                        DesktopEngine.applyWithGlobal(cb, currentEngine.getNashornGlobal(), str);
+                    }
+                }
+            });
         } catch (Exception e) {
             ByteArrayOutputStream bo = new ByteArrayOutputStream();
             e.printStackTrace(new PrintStream(bo));
         }
     }
 
-    public static String executeContractAsync(
-            String contractID, String action, String arg, final ScriptFunction cb) {
+    public static String executeContractAsync(String contractID, String action, String arg,
+            final ScriptFunction cb) {
         try {
 
             ContractRequest app = new ContractRequest();
             app.setContractID(contractID).setAction(action).setArg(arg);
             app.doSignature(keyPair);
             app.setRequestID((invokeID++) + "_" + random());
-            app.setRequesterDOI(doi);
-            get.asyncGet(
-                    "dd",
-                    "executeContract",
-                    JsonUtil.toJson(app),
-                    new ResultCallback() {
-                        @Override
-                        public void onResult(String str) {
-                            if (cb != null) {
-                                DesktopEngine.applyWithGlobal(
-                                        cb, currentEngine.getNashornGlobal(), str, arg);
-                            }
-                        }
-                    });
+            get.asyncGet("dd", "executeContract", JsonUtil.toJson(app), new ResultCallback() {
+                @Override
+                public void onResult(String str) {
+                    if (cb != null) {
+                        DesktopEngine.applyWithGlobal(cb, currentEngine.getNashornGlobal(), str,
+                                arg);
+                    }
+                }
+            });
             return "success";
         } catch (Exception e) {
             ByteArrayOutputStream bo = new ByteArrayOutputStream();
@@ -345,7 +310,7 @@ public class JavaScriptEntry {
         }
     }
 
-    //YancloudUtil.exceptionReturn({"msg":"missing arguments repoId ","code":1});
+    // YancloudUtil.exceptionReturn({"msg":"missing arguments repoId ","code":1});
     public static void exceptionReturn(Object obj) throws ScriptReturnException {
         throw new ScriptReturnException(JSONTool.convertMirrorToJson(obj));
     }
@@ -353,7 +318,7 @@ public class JavaScriptEntry {
     /**
      * publish an event with semantic AT_LEAST_ONCE
      *
-     * @param topic   the topic
+     * @param topic the topic
      * @param content the content
      * @author Kaidong Wu
      */
@@ -364,16 +329,14 @@ public class JavaScriptEntry {
     /**
      * publish an event with some semantic
      *
-     * @param topic      the topic
-     * @param content    the content
+     * @param topic the topic
+     * @param content the content
      * @param constraint the constraint, AT_LEAST_ONCE, AT_MOST_ONCE, and ONLY_ONCE
      * @author Kaidong Wu
      */
     public static void pubEventConstraint(String topic, String content, String constraint) {
-        String reqID =
-                String.format(
-                        "%d_%d_%d_%s_pe",
-                        keyPair.getPublicKeyStr().hashCode(), numOfCopies, invokeID, random());
+        String reqID = String.format("%d_%d_%d_%s_pe", keyPair.getPublicKeyStr().hashCode(),
+                numOfCopies, invokeID, random());
         REvent msg = new REvent(topic, PUBLISH, content, reqID);
         if (null != constraint) {
             msg.setSemantics(REvent.REventSemantics.valueOf(constraint));
@@ -385,7 +348,7 @@ public class JavaScriptEntry {
      * subscribe a topic
      *
      * @param topic event topic
-     * @param fun   related handler function
+     * @param fun related handler function
      * @author Kaidong Wu
      */
     public static String subscribe(String topic, ScriptFunction fun) {
@@ -401,8 +364,8 @@ public class JavaScriptEntry {
      * subscribe a local event
      *
      * @param contractID contractID
-     * @param event      local event topic
-     * @param fun        related handler function
+     * @param event local event topic
+     * @param fun related handler function
      * @author Kaidong Wu
      */
     public static String subscribe(String contractID, String event, ScriptFunction fun) {
@@ -416,19 +379,13 @@ public class JavaScriptEntry {
     }
 
     private static void subscribe(String topic, ScriptFunction fun, boolean fromPreSub) {
-        String reqID =
-                String.format(
-                        "%d_%d_%d_%s_se",
-                        keyPair.getPublicKeyStr().hashCode(), numOfCopies, invokeID, random());
+        String reqID = String.format("%d_%d_%d_%s_se", keyPair.getPublicKeyStr().hashCode(),
+                numOfCopies, invokeID, random());
 
-        REvent msg =
-                new REvent(
-                        topic,
-                        SUBSCRIBE,
-                        String.format(
-                                "{\"subscriber\":\"%s\",\"handler\":\"%s\"}",
-                                ContractProcess.instance.getContractName(), fun.getName()),
-                        reqID);
+        REvent msg = new REvent(topic, SUBSCRIBE,
+                String.format("{\"subscriber\":\"%s\",\"handler\":\"%s\"}",
+                        ContractProcess.instance.getContractName(), fun.getName()),
+                reqID);
         if (fromPreSub) {
             msg.setSemantics(REvent.REventSemantics.ONLY_ONCE);
         }
@@ -438,10 +395,8 @@ public class JavaScriptEntry {
     }
 
     public static void unsubscribe(String topic) {
-        String reqID =
-                String.format(
-                        "%d_%d_%d_%s_us",
-                        keyPair.getPublicKeyStr().hashCode(), numOfCopies, invokeID, random());
+        String reqID = String.format("%d_%d_%d_%s_us", keyPair.getPublicKeyStr().hashCode(),
+                numOfCopies, invokeID, random());
         String content;
         if (null == topic) {
             content = "{\"subscriber\":\"" + ContractProcess.instance.getContractName() + "\"}";
@@ -451,10 +406,8 @@ public class JavaScriptEntry {
             });
         } else {
             String handler = topic_handlers.get(topic).getName();
-            content =
-                    String.format(
-                            "{\"subscriber\":\"%s\",\"handler\":\"%s\"}",
-                            ContractProcess.instance.getContractName(), handler);
+            content = String.format("{\"subscriber\":\"%s\",\"handler\":\"%s\"}",
+                    ContractProcess.instance.getContractName(), handler);
             topic_handlers.remove(topic);
             ContractProcess.instance.unSubscribe(handler);
         }
@@ -465,17 +418,15 @@ public class JavaScriptEntry {
     /**
      * pre-sub in ONLY_ONCE
      *
-     * @param topic   the topic
+     * @param topic the topic
      * @param content the content
      * @author Kaidong Wu
      */
     public static void preSub(String topic, String content) {
         String newTopic = topic + "|" + content + "|" + ContractProcess.instance.getContractName();
         subscribe(newTopic, topic_handlers.get(topic), true);
-        String reqID =
-                String.format(
-                        "%d_%d_%d_%s_pse",
-                        keyPair.getPublicKeyStr().hashCode(), numOfCopies, (invokeID++), random());
+        String reqID = String.format("%d_%d_%d_%s_pse", keyPair.getPublicKeyStr().hashCode(),
+                numOfCopies, (invokeID++), random());
         REvent msg = new REvent(topic, REvent.REventType.PRESUB, newTopic, reqID);
         msg.setSemantics(REvent.REventSemantics.ONLY_ONCE);
         msgList.add(msg);
@@ -486,7 +437,8 @@ public class JavaScriptEntry {
      * @author Kaidong Wu
      */
     public static String random() {
-        String seed = String.valueOf(null == random ? System.currentTimeMillis() : random.nextInt());
+        String seed =
+                String.valueOf(null == random ? System.currentTimeMillis() : random.nextInt());
         return HashUtil.sha3(seed);
     }
 

src/main/java/org/bdware/sc/boundry/Resources.java

@@ -10,7 +10,6 @@ import java.util.Scanner;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
-import java.util.zip.ZipInputStream;
 public class Resources {
     private final ZipFile zf;
     YJSClassLoader loader;
@@ -49,7 +48,7 @@ public class Resources {
             InputStream sc = loadAsInputStream(path);
             ByteArrayOutputStream bo = new ByteArrayOutputStream();
             byte[] buff = new byte[1024];
-            for (int k = 0; (k = sc.read(buff)) > 0; ) {
+            for (int k = 0; (k = sc.read(buff)) > 0;) {
                 bo.write(buff, 0, k);
             }
             return new String(bo.toByteArray());
@@ -67,7 +66,8 @@ public class Resources {
             ZipEntry entry = zf.getEntry(path);
             if (entry == null)
                 return null;
-            reader = new BufferedReader(new InputStreamReader(zf.getInputStream(entry), StandardCharsets.UTF_8));
+            reader = new BufferedReader(
+                    new InputStreamReader(zf.getInputStream(entry), StandardCharsets.UTF_8));
             String line = null;
             while ((line = reader.readLine()) != null) {
                 fileList.add(line);
@@ -84,7 +84,8 @@ public class Resources {
     public String unzipToDir(String path) {
         ZipEntry entry = zf.getEntry(path);
         try {
-            return loader.unzipLibrary(zf.getInputStream(entry), entry.getName().replaceAll(".*/", ""));
+            return loader.unzipLibrary(zf.getInputStream(entry),
+                    entry.getName().replaceAll(".*/", ""));
         } catch (IOException e) {
             e.printStackTrace();
         }

src/main/java/org/bdware/sc/boundry/utils/AESUtil.java

@@ -16,13 +16,16 @@ import java.security.NoSuchAlgorithmException;
 
 @PermissionStub(permission = Permission.AES)
 public class AESUtil {
-    public static ScriptObject encrypt(String key, String plaintext) throws NoSuchPaddingException, NoSuchAlgorithmException, BadPaddingException, IllegalBlockSizeException, InvalidAlgorithmParameterException, InvalidKeyException {
+    public static ScriptObject encrypt(String key, String plaintext)
+            throws NoSuchPaddingException, NoSuchAlgorithmException, BadPaddingException,
+            IllegalBlockSizeException, InvalidAlgorithmParameterException, InvalidKeyException {
         JO ret = new JO(PropertyMap.newMap());
         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
         String iv = generateKey(128);
         IvParameterSpec ivSpec = new IvParameterSpec(DatatypeConverter.parseHexBinary(iv));
         byte[] byteContent = plaintext.getBytes();
-        SecretKeySpec secretKeySpecSpec = new SecretKeySpec(DatatypeConverter.parseHexBinary(key), "AES");
+        SecretKeySpec secretKeySpecSpec =
+                new SecretKeySpec(DatatypeConverter.parseHexBinary(key), "AES");
         cipher.init(Cipher.ENCRYPT_MODE, secretKeySpecSpec, ivSpec);
         byte[] result = cipher.doFinal(byteContent);
         ret.put("iv", iv, false);
@@ -30,12 +33,16 @@ public class AESUtil {
         return ret;
     }
 
-    public static String decrypt(String key, String ciphertext, String iv) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
-//        JO ret = new JO(PropertyMap.newMap());
+    public static String decrypt(String key, String ciphertext, String iv)
+            throws NoSuchPaddingException, NoSuchAlgorithmException,
+            InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException,
+            IllegalBlockSizeException {
+        // JO ret = new JO(PropertyMap.newMap());
         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
         IvParameterSpec ivSpec = new IvParameterSpec(DatatypeConverter.parseHexBinary(iv));
         byte[] byteContent = DatatypeConverter.parseHexBinary(ciphertext);
-        SecretKeySpec secretKeySpecSpec = new SecretKeySpec(DatatypeConverter.parseHexBinary(key), "AES");
+        SecretKeySpec secretKeySpecSpec =
+                new SecretKeySpec(DatatypeConverter.parseHexBinary(key), "AES");
         cipher.init(Cipher.DECRYPT_MODE, secretKeySpecSpec, ivSpec);
         byte[] result = cipher.doFinal(byteContent);
         return new String(result);

src/main/java/org/bdware/sc/boundry/utils/AsyncUtil.java

@@ -18,7 +18,7 @@ import java.util.TimerTask;
 @PermissionStub(permission = Permission.Async)
 public class AsyncUtil {
     private static final Timer TIMER = new Timer();
-//    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
+    // public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
     public static String sleep(long sleep) {
         try {
@@ -30,53 +30,47 @@ public class AsyncUtil {
     }
 
     public static String postFunction(final ScriptFunction callback, Object wrapper) {
-        ServiceServer.executor.execute(
-                () -> JavaScriptEntry.executeFunction(callback, wrapper));
+        ServiceServer.executor.execute(() -> JavaScriptEntry.executeFunction(callback, wrapper));
         return "success";
     }
 
-    public static TimerTask setTimeOut(
-            final ScriptFunction callback, long delay, final Object arg) {
-        TimerTask task =
-                new TimerTask() {
-                    @Override
-                    public void run() {
-                        JavaScriptEntry.executeFunction(callback, arg);
-                    }
-                };
+    public static TimerTask setTimeOut(final ScriptFunction callback, long delay,
+            final Object arg) {
+        TimerTask task = new TimerTask() {
+            @Override
+            public void run() {
+                JavaScriptEntry.executeFunction(callback, arg);
+            }
+        };
         TIMER.schedule(task, delay);
         return task;
     }
 
-    public static TimerTask setInterval(
-            final ScriptFunction callback, long delay, long interval, final Object arg) {
-        TimerTask task =
-                new TimerTask() {
-                    @Override
-                    public void run() {
-                        JavaScriptEntry.executeFunction(callback, arg);
-                    }
-                };
+    public static TimerTask setInterval(final ScriptFunction callback, long delay, long interval,
+            final Object arg) {
+        TimerTask task = new TimerTask() {
+            @Override
+            public void run() {
+                JavaScriptEntry.executeFunction(callback, arg);
+            }
+        };
         TIMER.schedule(task, delay, interval);
         return task;
     }
 
-    public static void executeContractAsyncWithoutSig(
-            String contractID, String action, String arg, final ScriptFunction cb) {
+    public static void executeContractAsyncWithoutSig(String contractID, String action, String arg,
+            final ScriptFunction cb) {
         try {
             ContractRequest app = new ContractRequest();
             app.setContractID(contractID).setAction(action).setArg(arg);
             app.setRequestID((JavaScriptEntry.invokeID++) + "_" + JavaScriptEntry.random.nextInt());
-            JavaScriptEntry.get.asyncGet(
-                    "dd",
-                    "executeContract",
-                    JsonUtil.toJson(app),
+            JavaScriptEntry.get.asyncGet("dd", "executeContract", JsonUtil.toJson(app),
                     new ResultCallback() {
                         @Override
                         public void onResult(String str) {
                             if (null != cb) {
-                                DesktopEngine.applyWithGlobal(
-                                        cb, JavaScriptEntry.currentEngine.getNashornGlobal(), str);
+                                DesktopEngine.applyWithGlobal(cb,
+                                        JavaScriptEntry.currentEngine.getNashornGlobal(), str);
                             }
                         }
                     });
@@ -85,25 +79,22 @@ public class AsyncUtil {
             e.printStackTrace(new PrintStream(bo));
         }
     }
-    public static String executeContractAsync(
-            String contractID, String action, String arg, final ScriptFunction cb) {
+
+    public static String executeContractAsync(String contractID, String action, String arg,
+            final ScriptFunction cb) {
         try {
 
             ContractRequest app = new ContractRequest();
             app.setContractID(contractID).setAction(action).setArg(arg);
             app.doSignature(JavaScriptEntry.getKeyPair());
             app.setRequestID((JavaScriptEntry.invokeID++) + "_" + JavaScriptEntry.random());
-            app.setRequesterDOI(JavaScriptEntry.doi);
-            JavaScriptEntry.get.asyncGet(
-                    "dd",
-                    "executeContract",
-                    JsonUtil.toJson(app),
+            JavaScriptEntry.get.asyncGet("dd", "executeContract", JsonUtil.toJson(app),
                     new ResultCallback() {
                         @Override
                         public void onResult(String str) {
                             if (cb != null) {
-                                DesktopEngine.applyWithGlobal(
-                                        cb, JavaScriptEntry.currentEngine.getNashornGlobal(), str, arg);
+                                DesktopEngine.applyWithGlobal(cb,
+                                        JavaScriptEntry.currentEngine.getNashornGlobal(), str, arg);
                             }
                         }
                     });

src/main/java/org/bdware/sc/boundry/utils/BDWareTimeSeriesDBUtil.java

@@ -2,7 +2,6 @@ package org.bdware.sc.boundry.utils;
 
 import org.bdware.sc.ContractProcess;
 import org.bdware.sc.compiler.PermissionStub;
-import org.bdware.sc.db.TimeDBUtil;
 import org.bdware.sc.db.TimeRocksDBUtil;
 import org.bdware.sc.node.Permission;
 

src/main/java/org/bdware/sc/boundry/utils/ClusterUtil.java

@@ -1,23 +1,9 @@
 package org.bdware.sc.boundry.utils;
 
-import com.google.gson.JsonArray;
 import org.bdware.sc.boundry.JavaScriptEntry;
 import org.bdware.sc.compiler.PermissionStub;
-import org.bdware.sc.engine.JSONTool;
 import org.bdware.sc.node.Permission;
-import org.bdware.sc.util.JsonUtil;
 import wrp.jdk.nashorn.internal.objects.NativeArray;
-import wrp.jdk.nashorn.internal.runtime.PropertyMap;
-import wrp.jdk.nashorn.internal.runtime.ScriptObject;
-import wrp.jdk.nashorn.internal.scripts.JO;
-
-import javax.crypto.*;
-import javax.crypto.spec.IvParameterSpec;
-import javax.crypto.spec.SecretKeySpec;
-import javax.xml.bind.DatatypeConverter;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
 
 @PermissionStub(permission = Permission.Cluster)
 public class ClusterUtil {

src/main/java/org/bdware/sc/boundry/utils/DOIPUtil.java

@@ -77,7 +77,8 @@ public class DOIPUtil {
                 msg = ret.get(0);
             if (msg != null) {
                 return msg;
-            } else return DoipMessageFactory.createTimeoutResponse(message.requestID);
+            } else
+                return DoipMessageFactory.createTimeoutResponse(message.requestID, "timeout");
         } catch (Exception ie) {
             ie.printStackTrace();
             return DoipMessageFactory.createConnectFailedResponse(message.requestID);
@@ -97,13 +98,14 @@ public class DOIPUtil {
     }
 
     public String hello(String repoID) {
-        DoipMessage msg = (new DoipMessageFactory.DoipMessageBuilder()).createRequest(repoID, BasicOperations.Hello.getName()).create();
+        DoipMessage msg = (new DoipMessageFactory.DoipMessageBuilder())
+                .createRequest(repoID, BasicOperations.Hello.getName()).create();
         return convertDoipMsgToString(syncGetMessage(msg));
     }
 
     public String retrieve(String doi, String args) {
-        DoipMessage msg = (new DoipMessageFactory.DoipMessageBuilder()).createRequest(doi, BasicOperations.Retrieve.getName())
-                .create();
+        DoipMessage msg = (new DoipMessageFactory.DoipMessageBuilder())
+                .createRequest(doi, BasicOperations.Retrieve.getName()).create();
         msg.header.parameters.addAttribute("element", "");
         return convertDoipMsgToString(syncGetMessage(msg));
     }
@@ -126,27 +128,21 @@ public class DOIPUtil {
             }
             e.dataString = null;
         }
-        DoipMessage msg =
-                new DoipMessageFactory.DoipMessageBuilder()
-                        .createRequest(repoID, BasicOperations.Create.getName())
-                        .setBody(digitalObject)
-                        .create();
+        DoipMessage msg = new DoipMessageFactory.DoipMessageBuilder()
+                .createRequest(repoID, BasicOperations.Create.getName()).setBody(digitalObject)
+                .create();
         return convertDoipMsgToString(syncGetMessage(msg));
     }
 
     public String delete(String doID) {
-        DoipMessage msg =
-                new DoipMessageFactory.DoipMessageBuilder()
-                        .createRequest(doID, BasicOperations.Delete.getName())
-                        .create();
+        DoipMessage msg = new DoipMessageFactory.DoipMessageBuilder()
+                .createRequest(doID, BasicOperations.Delete.getName()).create();
         return convertDoipMsgToString(syncGetMessage(msg));
     }
 
     public String listOperation(String doID) {
-        DoipMessage msg =
-                new DoipMessageFactory.DoipMessageBuilder()
-                        .createRequest(doID, BasicOperations.ListOps.getName())
-                        .create();
+        DoipMessage msg = new DoipMessageFactory.DoipMessageBuilder()
+                .createRequest(doID, BasicOperations.ListOps.getName()).create();
         return convertDoipMsgToString(syncGetMessage(msg));
     }
 
@@ -222,7 +218,8 @@ public class DOIPUtil {
         return createIrpClient(uri, null, null, null);
     }
 
-    public static IRPClientWrapper createIrpClient(String uri, String pubkey, String privateKey, String repoName) {
+    public static IRPClientWrapper createIrpClient(String uri, String pubkey, String privateKey,
+            String repoName) {
         EndpointConfig config = new EndpointConfig();
         config.routerURI = uri;
         config.repoName = repoName;

src/main/java/org/bdware/sc/boundry/utils/DOMUtil.java

@@ -7,4 +7,4 @@ public class DOMUtil {
     public static Document parse(String html) {
         return Jsoup.parse(html);
     }
-}
+}

src/main/java/org/bdware/sc/boundry/utils/DigestUtil.java

@@ -0,0 +1,15 @@
+package org.bdware.sc.boundry.utils;
+
+import org.bdware.sc.compiler.PermissionStub;
+import org.bdware.sc.node.Permission;
+
+@PermissionStub(permission = Permission.Digest)
+public class DigestUtil {
+    public static String md5Hex(String arg) {
+        return org.apache.commons.codec.digest.DigestUtils.md5Hex(arg);
+    }
+
+    public static String sha256Hex(String arg) {
+        return org.apache.commons.codec.digest.DigestUtils.sha256Hex(arg);
+    }
+}

src/main/java/org/bdware/sc/boundry/utils/EmailUtil.java

@@ -25,24 +25,20 @@ public class EmailUtil {
             props.setProperty("mail.smtp.socketFactory.class", SSL_FACTORY);
             props.setProperty("mail.smtp.socketFactory.fallback", "false");
             props.setProperty("mail.smtp.socketFactory.port", jo.get("port").getAsString());
-            Session session =
-                    Session.getDefaultInstance(
-                            props,
-                            new Authenticator() {
-                                public PasswordAuthentication getPasswordAuthentication() {
-                                    return new PasswordAuthentication(
-                                            jo.get("from").getAsString(),
-                                            jo.get("pwd").getAsString()); // 发件人邮件用户名、密码
-                                }
-                            });
+            Session session = Session.getDefaultInstance(props, new Authenticator() {
+                public PasswordAuthentication getPasswordAuthentication() {
+                    return new PasswordAuthentication(jo.get("from").getAsString(),
+                            jo.get("pwd").getAsString()); // 发件人邮件用户名、密码
+                }
+            });
             // 创建邮件对象
 
             Message msg = new MimeMessage(session);
             msg.setSubject(jo.get("subject").getAsString());
             msg.setText(jo.get("content").getAsString());
             msg.setFrom(new InternetAddress(jo.get("from").getAsString()));
-            msg.addRecipient(
-                    Message.RecipientType.TO, new InternetAddress(jo.get("to").getAsString()));
+            msg.addRecipient(Message.RecipientType.TO,
+                    new InternetAddress(jo.get("to").getAsString()));
             Transport.send(msg);
         } catch (Exception e) {
             e.printStackTrace();

src/main/java/org/bdware/sc/boundry/utils/HttpUtil.java

@@ -48,7 +48,8 @@ public class HttpUtil {
                 ScriptObjectMirror som = (ScriptObjectMirror) headers;
                 for (String key : som.getOwnKeys(true)) {
                     Object val = som.get(key);
-                    if (val instanceof String) connection.setRequestProperty(key, (String) val);
+                    if (val instanceof String)
+                        connection.setRequestProperty(key, (String) val);
                 }
             } else {
                 connection.setRequestProperty("Accept", "application/json");
@@ -64,7 +65,7 @@ public class HttpUtil {
             InputStream input = connection.getInputStream();
             Scanner sc = new Scanner(input);
             StringBuilder sb = new StringBuilder();
-            for (; sc.hasNextLine(); ) {
+            for (; sc.hasNextLine();) {
                 sb.append(sc.nextLine()).append("\n");
             }
             sc.close();
@@ -77,10 +78,12 @@ public class HttpUtil {
         }
         return ret;
     }
-    public static String encodeURI(String str){
+
+    public static String encodeURI(String str) {
         return URLEncoder.encode(str);
     }
-    public static String decodeURI(String str){
+
+    public static String decodeURI(String str) {
         return URLDecoder.decode(str);
     }
 
@@ -131,7 +134,8 @@ public class HttpUtil {
                 connection.setRequestProperty("Content-Type", "application/json");
             }
             connection.connect();
-            OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream(), StandardCharsets.UTF_8);
+            OutputStreamWriter out =
+                    new OutputStreamWriter(connection.getOutputStream(), StandardCharsets.UTF_8);
             out.append((String) str.get("data"));
             out.flush();
             out.close();
@@ -156,74 +160,67 @@ public class HttpUtil {
     private static CloseableHttpClient getHttpClient(String url) {
         try {
             SSLContext sslcontext =
-                    SSLContexts.custom()
-                            .loadTrustMaterial(
-                                    null,
-                                    (arg0, arg1) -> true)
-                            .build();
+                    SSLContexts.custom().loadTrustMaterial(null, (arg0, arg1) -> true).build();
 
-            SSLConnectionSocketFactory sslSf =
-                    new SSLConnectionSocketFactory(
-                            sslcontext, null, null, new NoopHostnameVerifier());
+            SSLConnectionSocketFactory sslSf = new SSLConnectionSocketFactory(sslcontext, null,
+                    null, new NoopHostnameVerifier());
             int tle = 10;
             if (url.contains("data.tj.gov.cn")) {
                 tle = 3;
             }
-            return HttpClients.custom()
-                    .setSSLSocketFactory(sslSf)
+            return HttpClients.custom().setSSLSocketFactory(sslSf)
                     .setKeepAliveStrategy((arg0, arg1) -> 0)
-                    .setConnectionTimeToLive(tle, TimeUnit.SECONDS)
-                    .build();
+                    .setConnectionTimeToLive(tle, TimeUnit.SECONDS).build();
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }
 
-    //	public static String httpPost(String str) {
-    //		System.out.println("JavaSScriptEntry httpPost:" + str);
-    //		PostRequest req = new PostRequest();
-    //		req = JsonUtil.fromJson(str, PostRequest.class);
-    //		// System.out.println("url========>" + req.url);
-    //		// System.out.println("data=======>" + req.data);
+    // public static String httpPost(String str) {
+    // System.out.println("JavaSScriptEntry httpPost:" + str);
+    // PostRequest req = new PostRequest();
+    // req = JsonUtil.fromJson(str, PostRequest.class);
+    // // System.out.println("url========>" + req.url);
+    // // System.out.println("data=======>" + req.data);
     //
-    //		Result r = new Result();
-    //		try {
-    //			URL url = new URL(req.url);//
-    //			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
-    //			connection.setDoOutput(true);
-    //			connection.setDoInput(true);
-    //			connection.setUseCaches(false);
-    //			connection.setInstanceFollowRedirects(true);
-    //			connection.setRequestMethod("POST");
-    //			connection.setRequestProperty("Accept", "application/json");
-    //			connection.setRequestProperty("Content-Type", "application/json");
-    //			connection.connect();
-    //			OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream(), "UTF-8"); //
+    // Result r = new Result();
+    // try {
+    // URL url = new URL(req.url);//
+    // HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+    // connection.setDoOutput(true);
+    // connection.setDoInput(true);
+    // connection.setUseCaches(false);
+    // connection.setInstanceFollowRedirects(true);
+    // connection.setRequestMethod("POST");
+    // connection.setRequestProperty("Accept", "application/json");
+    // connection.setRequestProperty("Content-Type", "application/json");
+    // connection.connect();
+    // OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream(), "UTF-8"); //
     // utf-8缂栫爜
-    //			out.append(req.data);
-    //			out.flush();
-    //			out.close();
+    // out.append(req.data);
+    // out.flush();
+    // out.close();
     //
-    //			r.resposeCode = connection.getResponseCode();
-    //			InputStream input = connection.getInputStream();
+    // r.resposeCode = connection.getResponseCode();
+    // InputStream input = connection.getInputStream();
     //
-    //			Scanner sc = new Scanner(input);
-    //			StringBuilder sb = new StringBuilder();
-    //			for (; sc.hasNextLine();) {
-    //				sb.append(sc.nextLine()).append("\n");
-    //			}
-    //			sc.close();
-    //			r.response = sb.toString();
-    //			return JsonUtil.toJson(r);
-    //		} catch (Throwable e) {
-    //			r.resposeCode = 505;
-    //			// ByteArrayOutputStream bo = new ByteArrayOutputStream();
-    //			// e.printStackTrace(new PrintStream(bo));
-    //			r.response = e.getMessage();
-    //			return JsonUtil.toJson(r);
-    //		}
-    //	}
+    // Scanner sc = new Scanner(input);
+    // StringBuilder sb = new StringBuilder();
+    // for (; sc.hasNextLine();) {
+    // sb.append(sc.nextLine()).append("\n");
+    // }
+    // sc.close();
+    // r.response = sb.toString();
+    // return JsonUtil.toJson(r);
+    // } catch (Throwable e) {
+    // r.resposeCode = 505;
+    // // ByteArrayOutputStream bo = new ByteArrayOutputStream();
+    // // e.printStackTrace(new PrintStream(bo));
+    // r.response = e.getMessage();
+    // return JsonUtil.toJson(r);
+    // }
+    // }
 
     public static String postTask(String args, final ScriptFunction callback) {
         System.out.println("[JavaScriptEntry]" + args);
@@ -235,62 +232,59 @@ public class HttpUtil {
                 RequestBody.create(MediaType.parse("application/json; charset=utf-8"), req.data);
         Request request = new Request.Builder().url(req.url).post(body).build(); // 2.瀹氫箟涓<E7AE9F>涓猺equest
         Call call = okHttpClient.newCall(request); //
-        call.enqueue(
-                new Callback() { //
-                    @Override
-                    public void onFailure(Call call, IOException e) {
-                    }
+        call.enqueue(new Callback() { //
+            @Override
+            public void onFailure(Call call, IOException e) {}
 
-                    @Override
-                    public void onResponse(Call call, Response response) throws IOException {
-                        String result = response.body().string(); //
-                        System.out.println("currentEngine:");
-                        DesktopEngine.applyWithGlobal(
-                                callback, currentEngine.getNashornGlobal(), result);
-                    }
-                });
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                String result = response.body().string(); //
+                System.out.println("currentEngine:");
+                DesktopEngine.applyWithGlobal(callback, currentEngine.getNashornGlobal(), result);
+            }
+        });
         return "success";
     }
 
-    //	public static String httpGet(String str) {
-    //		// System.out.println("JavaScriptEntry httpGet:" + str);
-    //		Result r = new Result();
-    //		try {
-    //			HttpGet httpGet = new HttpGet(str);
-    //			RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(60000)
-    //					.setConnectTimeout(60000).setSocketTimeout(60000).build();
-    //			httpGet.setConfig(requestConfig);
-    //			httpGet.addHeader("Pragma", "no-cache");
-    //			httpGet.addHeader("Cache-Control", "no-cache");
-    //			httpGet.addHeader("Upgrade-Insecure-Requests", "1");
-    //			httpGet.addHeader("User-Agent",
-    //					"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko)
+    // public static String httpGet(String str) {
+    // // System.out.println("JavaScriptEntry httpGet:" + str);
+    // Result r = new Result();
+    // try {
+    // HttpGet httpGet = new HttpGet(str);
+    // RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(60000)
+    // .setConnectTimeout(60000).setSocketTimeout(60000).build();
+    // httpGet.setConfig(requestConfig);
+    // httpGet.addHeader("Pragma", "no-cache");
+    // httpGet.addHeader("Cache-Control", "no-cache");
+    // httpGet.addHeader("Upgrade-Insecure-Requests", "1");
+    // httpGet.addHeader("User-Agent",
+    // "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko)
     // Chrome/78.0.3904.97 Safari/537.36");
-    //			httpGet.addHeader("Sec-Fetch-User", "?1");
-    //			httpGet.addHeader("Accept",
+    // httpGet.addHeader("Sec-Fetch-User", "?1");
+    // httpGet.addHeader("Accept",
     //
-    //	"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3");
-    //			httpGet.addHeader("Sec-Fetch-Site", "none");
-    //			httpGet.addHeader("Sec-Fetch-Mode", "navigate");
-    //			httpGet.addHeader("Accept-Encoding", "gzip, deflate, br");
-    //			httpGet.addHeader("Accept-Language", "zh-CN,zh;q=0.9");
-    //			CloseableHttpResponse response1 = getHttpClient(str).execute(httpGet);
-    //			InputStream content = response1.getEntity().getContent();
-    //			ByteArrayOutputStream bo = new ByteArrayOutputStream();
-    //			byte[] buff = new byte[4096];
-    //			for (int k = 0; (k = content.read(buff)) > 0;) {
-    //				bo.write(buff, 0, k);
-    //			}
-    //			r.response = bo.toString();
-    //			return JsonUtil.toJson(r);
-    //		} catch (Throwable e) {
-    //			r.resposeCode = 505;
-    //			// ByteArrayOutputStream bo = new ByteArrayOutputStream();
-    //			// e.printStackTrace(new PrintStream(bo));
-    //			r.response = e.getMessage();
-    //			return JsonUtil.toJson(r);
-    //		}
-    //	}
+    // "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3");
+    // httpGet.addHeader("Sec-Fetch-Site", "none");
+    // httpGet.addHeader("Sec-Fetch-Mode", "navigate");
+    // httpGet.addHeader("Accept-Encoding", "gzip, deflate, br");
+    // httpGet.addHeader("Accept-Language", "zh-CN,zh;q=0.9");
+    // CloseableHttpResponse response1 = getHttpClient(str).execute(httpGet);
+    // InputStream content = response1.getEntity().getContent();
+    // ByteArrayOutputStream bo = new ByteArrayOutputStream();
+    // byte[] buff = new byte[4096];
+    // for (int k = 0; (k = content.read(buff)) > 0;) {
+    // bo.write(buff, 0, k);
+    // }
+    // r.response = bo.toString();
+    // return JsonUtil.toJson(r);
+    // } catch (Throwable e) {
+    // r.resposeCode = 505;
+    // // ByteArrayOutputStream bo = new ByteArrayOutputStream();
+    // // e.printStackTrace(new PrintStream(bo));
+    // r.response = e.getMessage();
+    // return JsonUtil.toJson(r);
+    // }
+    // }
 
     public static ApiGate createAPIGate(String ip) {
         return new ApiGate(ip);

src/main/java/org/bdware/sc/boundry/utils/IRPUtil.java

@@ -1,33 +1,17 @@
 package org.bdware.sc.boundry.utils;
 
-import com.google.api.client.json.Json;
 import com.google.gson.JsonObject;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.bdware.doip.audit.EndpointConfig;
 import org.bdware.doip.audit.client.AuditIrpClient;
 import org.bdware.doip.audit.config.TempConfigStorage;
-import org.bdware.doip.codec.digitalObject.DigitalObject;
-import org.bdware.doip.codec.digitalObject.Element;
-import org.bdware.doip.codec.doipMessage.DoipMessage;
-import org.bdware.doip.codec.doipMessage.DoipMessageFactory;
-import org.bdware.doip.codec.operations.BasicOperations;
-import org.bdware.doip.endpoint.client.ClientConfig;
-import org.bdware.doip.endpoint.client.DoipClientImpl;
-import org.bdware.doip.endpoint.client.DoipMessageCallback;
-import org.bdware.irp.exception.IrpClientException;
 import org.bdware.irp.stateinfo.StateInfoBase;
 import org.bdware.sc.compiler.PermissionStub;
 import org.bdware.sc.engine.JSONTool;
 import org.bdware.sc.node.Permission;
-import org.bdware.sc.util.JsonUtil;
 import wrp.jdk.nashorn.api.scripting.ScriptObjectMirror;
 
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.List;
 
 @PermissionStub(permission = Permission.IRP)
 public class IRPUtil {
@@ -40,7 +24,8 @@ public class IRPUtil {
         EndpointConfig endpointConfig = configStorage.loadAsEndpointConfig();
 
         if (jo.has("clientDoId")) {
-            this.auditIrpClient = new AuditIrpClient(jo.get("clientDoId").getAsString(), endpointConfig);
+            this.auditIrpClient =
+                    new AuditIrpClient(jo.get("clientDoId").getAsString(), endpointConfig);
         } else {
             this.auditIrpClient = new AuditIrpClient(endpointConfig);
         }

src/main/java/org/bdware/sc/boundry/utils/LedgerUtil.java

@@ -27,7 +27,7 @@ public class LedgerUtil {
     static SecureRandom random = new SecureRandom((System.currentTimeMillis() + "").getBytes());
 
     public static Object getLedgerParams() {
-        //format:{nodes:[{ip:ip,port:port}]}
+        // format:{nodes:[{ip:ip,port:port}]}
         String ledgerParam = JavaScriptEntry.get.syncGet("", "getLedgerParams", "");
         JsonElement jo = JsonParser.parseString(ledgerParam);
         return JSONTool.convertJsonElementToMirror(jo);
@@ -36,7 +36,8 @@ public class LedgerUtil {
     public static Client getDefaultClient() {
         String ledgerParam = JavaScriptEntry.get.syncGet("", "getLedgerParams", "");
         JsonElement jo = JsonParser.parseString(ledgerParam);
-        JsonObject param = jo.getAsJsonObject().get("nodes").getAsJsonArray().get(0).getAsJsonObject();
+        JsonObject param =
+                jo.getAsJsonObject().get("nodes").getAsJsonArray().get(0).getAsJsonObject();
         return new Client(param.get("ip").getAsString(), param.get("port").getAsInt());
     }
 
@@ -57,7 +58,8 @@ public class LedgerUtil {
         ret.put("to", HashUtil.byteArray2Str(transaction.getTo().toByteArray(), 0), false);
         ret.put("type", transaction.getType().toString(), false);
         ret.put("data", new String(transaction.getData().toByteArray()), false);
-        ret.put("blockHsah", HashUtil.byteArray2Str(transaction.getBlockHash().toByteArray(), 0), false);
+        ret.put("blockHsah", HashUtil.byteArray2Str(transaction.getBlockHash().toByteArray(), 0),
+                false);
         return ret;
     }
 
@@ -66,14 +68,8 @@ public class LedgerUtil {
         String from = str.get("from").toString();
         String to = str.get("to").toString();
         String data = str.get("data").toString();
-        SendTransactionResponse result =
-                c.sendTransactionSync(
-                        ledger,
-                        TransactionType.MESSAGE,
-                        from,
-                        random.nextLong(),
-                        to,
-                        data.getBytes());
+        SendTransactionResponse result = c.sendTransactionSync(ledger, TransactionType.MESSAGE,
+                from, random.nextLong(), to, data.getBytes());
         return HashUtil.byteArray2Str(result.getHash().toByteArray(), 0);
     }
 }

src/main/java/org/bdware/sc/boundry/utils/MongoDBUtil.java

@@ -18,12 +18,8 @@ public class MongoDBUtil {
             List addrs = new ArrayList<>();
             addrs.add(serverAddress);
             Method createeScramSha1 =
-                    Class.forName("com.mongodb.MongoCredential")
-                            .getDeclaredMethod(
-                                    "createScramSha1Credential",
-                                    String.class,
-                                    String.class,
-                                    char[].class);
+                    Class.forName("com.mongodb.MongoCredential").getDeclaredMethod(
+                            "createScramSha1Credential", String.class, String.class, char[].class);
             Object credential = createeScramSha1.invoke(null, usrName, dbName, pwd.toCharArray());
             List credentials = new ArrayList<>();
             credentials.add(credential);

src/main/java/org/bdware/sc/boundry/utils/MultiTagIndexDBUtil.java

@@ -116,7 +116,8 @@ public class MultiTagIndexDBUtil {
 
     public List<Long> countInInterval(String tag, long startTime, long endTime, long interval) {
         List<Long> ret = new ArrayList<>();
-        if (interval <= 0) return ret;
+        if (interval <= 0)
+            return ret;
         long start = rocksDB.queryOffset(tag, startTime);
         long delta;
         startTime += interval;

src/main/java/org/bdware/sc/boundry/utils/RocksDBUtil.java

@@ -35,7 +35,7 @@ public class RocksDBUtil {
         options.setCreateIfMissing(true);
         File parent = new File("./ContractDB/" + ContractProcess.getContractDir());
         File dir = new File(parent, path);
-        //LOGGER.info("init RocksDB in " + dir.getAbsolutePath());
+        // LOGGER.info("init RocksDB in " + dir.getAbsolutePath());
         if (!dir.exists()) {
             LOGGER.info("create directory " + dir.getAbsolutePath() + ": " + dir.mkdirs());
         }

src/main/java/org/bdware/sc/boundry/utils/SM2Util.java

@@ -46,14 +46,13 @@ public class SM2Util {
         JO ret = new JO(PropertyMap.newMap());
         try {
             byte[] sig = ByteUtils.fromHexString(signature);
-            ECPublicKeyParameters pubKey =
-                    BCECUtil.createECPublicKeyFromStrParameters(
-                            pubKeyStr,
-                            org.zz.gmhelper.SM2Util.CURVE,
-                            org.zz.gmhelper.SM2Util.DOMAIN_PARAMS);
+            ECPublicKeyParameters pubKey = BCECUtil.createECPublicKeyFromStrParameters(pubKeyStr,
+                    org.zz.gmhelper.SM2Util.CURVE, org.zz.gmhelper.SM2Util.DOMAIN_PARAMS);
             boolean value = org.zz.gmhelper.SM2Util.verify(pubKey, content.getBytes(), sig);
-            if (value) ret.put("status", "success", false);
-            else ret.put("status", "failed", false);
+            if (value)
+                ret.put("status", "success", false);
+            else
+                ret.put("status", "failed", false);
             ret.put("result", value, false);
         } catch (Exception e) {
             ret.put("status", "failed", false);
@@ -65,9 +64,8 @@ public class SM2Util {
 
     public static String encrypt(String content, String pubkey) {
         try {
-            return ByteUtils.toHexString(
-                    org.zz.gmhelper.SM2Util.encrypt(
-                            SM2KeyPair.publicKeyStr2ECPoint(pubkey), content.getBytes()));
+            return ByteUtils.toHexString(org.zz.gmhelper.SM2Util
+                    .encrypt(SM2KeyPair.publicKeyStr2ECPoint(pubkey), content.getBytes()));
         } catch (InvalidCipherTextException e) {
             e.printStackTrace();
         }
@@ -76,12 +74,10 @@ public class SM2Util {
 
     public static String decrypt(String content, String privateKey) {
         try {
-            ECPrivateKeyParameters privateKeyParam =
-                    new ECPrivateKeyParameters(
-                            new BigInteger(privateKey, 16), org.zz.gmhelper.SM2Util.DOMAIN_PARAMS);
-            return new String(
-                    org.zz.gmhelper.SM2Util.decrypt(
-                            privateKeyParam, ByteUtils.fromHexString(content)));
+            ECPrivateKeyParameters privateKeyParam = new ECPrivateKeyParameters(
+                    new BigInteger(privateKey, 16), org.zz.gmhelper.SM2Util.DOMAIN_PARAMS);
+            return new String(org.zz.gmhelper.SM2Util.decrypt(privateKeyParam,
+                    ByteUtils.fromHexString(content)));
         } catch (InvalidCipherTextException e) {
             e.printStackTrace();
         }

src/main/java/org/bdware/sc/boundry/utils/SQLUtil.java

@@ -16,9 +16,8 @@ public class SQLUtil {
                     .setContextClassLoader(ContractProcess.instance.engine.getClassLoad());
             Class.forName(driver, true, ContractProcess.instance.engine.getClassLoad());
         } catch (Exception e) {
-            System.out.println(
-                    "Still can't find class! Cl of SQLUtil:\n\t\t"
-                            + SQLUtil.class.getClassLoader());
+            System.out.println("Still can't find class! Cl of SQLUtil:\n\t\t"
+                    + SQLUtil.class.getClassLoader());
             System.out.println(
                     "Cl of DEgine:\n\t\t" + ContractProcess.instance.engine.getClassLoad());
             e.printStackTrace();
@@ -40,18 +39,15 @@ public class SQLUtil {
             if (password != null && !"undefined".equals(password)) {
                 info.put("password", password);
             }
-            if (url.startsWith("jdbc:postgresql")) info.put("sslmode", "allow");
+            if (url.startsWith("jdbc:postgresql"))
+                info.put("sslmode", "allow");
 
-            Class<?> clz =
-                    Class.forName(
-                            "java.sql.DriverManager",
-                            true,
-                            ContractProcess.instance.engine.getClassLoad());
+            Class<?> clz = Class.forName("java.sql.DriverManager", true,
+                    ContractProcess.instance.engine.getClassLoad());
             // set caller class into null, thus use YJSClassLoader in
             // DriverManager.isDriverAllowed(driver,classloader);
-            Method m =
-                    clz.getDeclaredMethod(
-                            "getConnection", String.class, Properties.class, Class.class);
+            Method m = clz.getDeclaredMethod("getConnection", String.class, Properties.class,
+                    Class.class);
             m.setAccessible(true);
             return (Connection) m.invoke(null, url, info, null);
         } catch (Exception e) {

src/main/java/org/bdware/sc/boundry/utils/UtilRegistry.java

@@ -23,7 +23,8 @@ public class UtilRegistry {
             for (String name : allName) {
                 Class<?> clz;
                 try {
-                    clz = Class.forName(String.format("%s.%sUtil", UtilRegistry.class.getPackage().getName(), name));
+                    clz = Class.forName(String.format("%s.%sUtil",
+                            UtilRegistry.class.getPackage().getName(), name));
                     ret.add(clz);
                 } catch (Throwable e) {
                     e.printStackTrace();
@@ -52,10 +53,8 @@ public class UtilRegistry {
 
     public static String getInitStr(String s, boolean open) {
         if (stubClzNameMap.containsKey(s)) {
-            String ret =
-                    String.format(
-                            "%sUtil = %s.%sUtil%s;\n",
-                            s, UtilRegistry.class.getPackage().getName(), s, open ? "" : "Stub");
+            String ret = String.format("%sUtil = %s.%sUtil%s;\n", s,
+                    UtilRegistry.class.getPackage().getName(), s, open ? "" : "Stub");
             return ret;
         }
         return "";

src/main/java/org/bdware/sc/compiler/AnnotationProcessor.java

@@ -3,14 +3,20 @@ package org.bdware.sc.compiler;
 import org.bdware.sc.node.AnnotationNode;
 import org.bdware.sc.node.ContractNode;
 import org.bdware.sc.node.FunctionNode;
+import org.bdware.sc.node.InterfaceNode;
 
 public abstract class AnnotationProcessor {
     public void processContract(AnnotationNode anno, ContractNode contractNode) {
         return;
     }
 
-    public void processFunction(
-            AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) throws Exception {
+        return;
+    }
+
+    public void processInterface(AnnotationNode anno, ContractNode contractNode,
+            InterfaceNode functionNode) throws Exception {
         return;
     }
 }

src/main/java/org/bdware/sc/compiler/PermissionStub.java

@@ -12,4 +12,4 @@ import java.lang.annotation.Target;
 public @interface PermissionStub {
     Permission permission();
 
-}
+}

src/main/java/org/bdware/sc/compiler/PermissionStubGenerator.java

@@ -34,7 +34,8 @@ public class PermissionStubGenerator extends ClassVisitor implements Opcodes {
         return null;
     }
 
-    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+    public void visit(int version, int access, String name, String signature, String superName,
+            String[] interfaces) {
         if (cv != null) {
             cv.visit(version, access, name + "Stub", null, "java/lang/Object", null);
         }
@@ -53,7 +54,8 @@ public class PermissionStubGenerator extends ClassVisitor implements Opcodes {
         mv.visitEnd();
     }
 
-    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature,
+            String[] exceptions) {
         if (cv != null) {
             if (name.equals("<clinit>"))
                 return null;
@@ -62,14 +64,15 @@ public class PermissionStubGenerator extends ClassVisitor implements Opcodes {
             }
 
             MethodVisitor mv = cv.visitMethod(access, name, desc, signature,
-                    new String[]{"javax/script/ScriptException"});
+                    new String[] {"javax/script/ScriptException"});
             mv.visitCode();
             Label l0 = new Label();
             mv.visitLabel(l0);
             mv.visitTypeInsn(NEW, "javax/script/ScriptException");
             mv.visitInsn(DUP);
             mv.visitLdcInsn("Do not have " + p + " Permission");
-            mv.visitMethodInsn(INVOKESPECIAL, "javax/script/ScriptException", "<init>", "(Ljava/lang/String;)V");
+            mv.visitMethodInsn(INVOKESPECIAL, "javax/script/ScriptException", "<init>",
+                    "(Ljava/lang/String;)V");
             mv.visitInsn(ATHROW);
             mv.visitMaxs(5, 20);
             mv.visitEnd();

src/main/java/org/bdware/sc/compiler/YJSCompiler.java

@@ -21,6 +21,7 @@ import wrp.jdk.nashorn.internal.runtime.options.Options;
 
 import java.io.*;
 import java.nio.charset.StandardCharsets;
+import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -33,8 +34,7 @@ public class YJSCompiler {
     ContractNode contract;
     private static final Logger LOGGER = LogManager.getLogger(YJSCompiler.class);
 
-    public YJSCompiler() {
-    }
+    public YJSCompiler() {}
 
     public static ScriptFunction compileWithGlobal(Source source, Global global, Context context) {
         Global oldGlobal = Context.getGlobal();
@@ -54,8 +54,8 @@ public class YJSCompiler {
         }
     }
 
-    private static Context makeContext(
-            final InputStream in, final OutputStream out, final OutputStream err) {
+    private static Context makeContext(final InputStream in, final OutputStream out,
+            final OutputStream err) {
         final PrintStream pout =
                 out instanceof PrintStream ? (PrintStream) out : new PrintStream(out);
         final PrintStream perr =
@@ -67,7 +67,7 @@ public class YJSCompiler {
         final ErrorManager errors = new ErrorManager(werr);
         // Set up options.
         final Options options = new Options("nashorn", werr);
-        options.process(new String[]{});
+        options.process(new String[] {});
         // detect scripting mode by any source's first character being '#'
         options.set("persistent.code.cache", true);
         options.set("print.code", "true");
@@ -91,14 +91,8 @@ public class YJSCompiler {
                 }
             }
         }
-        return new Context(
-                options,
-                errors,
-                wout,
-                werr,
-                Thread.currentThread().getContextClassLoader(),
-                new YJSFilter(),
-                null);
+        return new Context(options, errors, wout, werr,
+                Thread.currentThread().getContextClassLoader(), new YJSFilter(), null);
     }
 
     public ContractZipBundle compile(ZipFile zf) throws Exception {
@@ -114,10 +108,8 @@ public class YJSCompiler {
         // Gson gson = new GsonBuilder().registerTypeAdapter(Contract.Type.class,
         // typeAdapter)
 
-        ContractManifest cm =
-                JsonUtil.GSON.fromJson(
-                        new InputStreamReader(manifestInput), ContractManifest.class);
-
+        ContractManifest cm = JsonUtil.GSON.fromJson(new InputStreamReader(manifestInput),
+                ContractManifest.class);
         // 如果没有就不限制，根据gas进行插装
         if (0L != cm.getInsnLimit()) {
             LOGGER.info("++++++++++++++++++++++true");
@@ -126,25 +118,49 @@ public class YJSCompiler {
         Set<String> toParse = new HashSet<>();
         toParse.add(cm.main);
         Set<String> todo = new HashSet<>();
+        Set<String> allEntries = new HashSet<>();
+        Enumeration<? extends ZipEntry> iter = zf.entries();
+        for (; iter.hasMoreElements();) {
+            ZipEntry ele = iter.nextElement();
+            if (ele != null)
+                allEntries.add(ele.getName());
+        }
         while (toParse.size() > 0) {
             for (String str : toParse) {
                 if (czb.containsPath(str)) {
                     continue;
                 }
-                ZipEntry entry = zf.getEntry("/" + str);
+                ZipEntry entry = zf.getEntry(str.startsWith("/") ? str : "/" + str);
+                LOGGER.info("load yjs:" + str);
                 if (null == entry) {
                     throw new IllegalStateException("missing import:" + str);
                 }
                 ContractNode cn = compile(zf.getInputStream(entry), str);
+                String cnPath = entry.getName();
+                int i = cnPath.lastIndexOf("/");
+                String cnDir = "";
+                if (i != -1)
+                    cnDir = cnPath.substring(0, i);
                 czb.put(str, cn);
                 for (ImportNode in : cn.getImports()) {
-                    todo.add(in.getPath());
+                    String path = in.getPath();
+                    if (!path.startsWith("/"))
+                        path = cnDir + "/" + path;
+                    path = path.replaceAll("/\\./", "/");
+                    todo.add(path);
                 }
             }
             toParse.clear();
             for (String str : todo) {
-                if (!czb.containsPath(str)) {
+                if (allEntries.contains(str))
                     toParse.add(str);
+                else {
+                    // TODO parse manifest.json first?
+                    for (String entry : allEntries)
+                        if (!czb.containsPath(entry) && entry.startsWith(str)
+                                && entry.endsWith(".yjs")) {
+                            toParse.add(entry);
+                        }
                 }
             }
             todo.clear();
@@ -152,30 +168,30 @@ public class YJSCompiler {
         // add function _preSub
         // Kaidong Wu
         String preSubConName = cm.main.substring(0, cm.main.length() - 4) + "PreSub";
-        String preSubContract =
-                "contract "
-                        + preSubConName
-                        + " { function _preSub (e) { YancloudUtil.preSub(e.topic, e.content); }}";
+        String preSubContract = "contract " + preSubConName
+                + " { function _preSub (e) { YancloudUtil.preSub(e.topic, e.content); }}";
         ContractNode preSubNode =
-                compile(
-                        new ByteArrayInputStream(preSubContract.getBytes(StandardCharsets.UTF_8)),
+                compile(new ByteArrayInputStream(preSubContract.getBytes(StandardCharsets.UTF_8)),
                         preSubConName + ".yjs");
         czb.put(preSubConName + ".yjs", preSubNode);
         LOGGER.info("--compile-- " + preSubConName);
 
         String globalBeanName = cm.main.substring(0, cm.main.length() - 4) + "GlobalBean";
-        String globalBeanContract =
-                "contract " + globalBeanName + "{ function setGlobal (_global) { Global = _global; }\n" +
-                        " function getGlobal () { return Global; }}";
+        String globalBeanContract = "contract " + globalBeanName
+                + "{ function setGlobal (_global) { Global = _global; }\n"
+                + " function getGlobal () { return Global; }}";
         czb.put(globalBeanName + ".yjs",
-                compile(new ByteArrayInputStream(globalBeanContract.getBytes(StandardCharsets.UTF_8)),
+                compile(new ByteArrayInputStream(
+                        globalBeanContract.getBytes(StandardCharsets.UTF_8)),
                         globalBeanName + ".yjs"));
         LOGGER.info("--compile-- " + globalBeanName);
-
+        czb.setMergedContractNode();
+        ContractNode node = czb.mergeContractNode();
+        handleFunctionAnnotation(node);
         return czb;
     }
 
-    public ContractNode compile(InputStream input, String fileName) throws IOException {
+    public ContractNode compile(InputStream input, String fileName) throws Exception {
         // 词法分析
         JavaScriptLexer lexer = new JavaScriptLexer(new ANTLRInputStream(input));
         lexer.setUseStrictDefault(true);
@@ -191,19 +207,24 @@ public class YJSCompiler {
         contract = reader.visitProgram(tree);
         // 遍历完 获取 contract 里的 yjs type
         contract.initPlainText(cts);
-        handleAnnotation(contract);//处理注解
+        handleModuleAnnotation(contract);// 处理注解
+        handleFunctionAnnotation(contract);
         return contract;
     }
 
-    private void handleAnnotation(ContractNode contractNode) {
+    private void handleModuleAnnotation(ContractNode contractNode) throws Exception {
         for (AnnotationNode node : contract.annotations) {
             AnnotationProcessor processor = findProcessor(node);
             if (processor != null) {
                 processor.processContract(node, contractNode);
             }
         }
+
+    }
+
+    private void handleFunctionAnnotation(ContractNode contractNode) throws Exception {
         for (FunctionNode functionNode : contractNode.getFunctions()) {
-            List<AnnotationNode> annos = functionNode.annotations;//函数里的annotation
+            List<AnnotationNode> annos = functionNode.annotations;// 函数里的annotation
             if (annos != null)
                 for (AnnotationNode anno : annos) {
                     AnnotationProcessor processor = findProcessor(anno);
@@ -211,9 +232,19 @@ public class YJSCompiler {
                         processor.processFunction(anno, contractNode, functionNode);
                 }
         }
+
+        for (InterfaceNode interfaceNode : contractNode.getInterfaces()) {
+            List<AnnotationNode> annos = interfaceNode.annotations;// 函数里的annotation
+            if (annos != null)
+                for (AnnotationNode anno : annos) {
+                    AnnotationProcessor processor = findProcessor(anno);
+                    if (processor != null)
+                        processor.processInterface(anno, contractNode, interfaceNode);
+                }
+        }
     }
 
-    private AnnotationProcessor findProcessor(AnnotationNode node) {
+    public static AnnotationProcessor findProcessor(AnnotationNode node) {
         try {
             String clzName = YJSCompiler.class.getPackage().getName();
             clzName += ".ap." + node.getType();

src/main/java/org/bdware/sc/compiler/ap/Confidential.java

@@ -7,6 +7,8 @@ import org.bdware.sc.node.FunctionNode;
 
 public class Confidential extends AnnotationProcessor {
     @Override
-    public void processFunction(AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
-        functionNode.setConfidential(true);    }
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
+        functionNode.setConfidential(true);
+    }
 }

src/main/java/org/bdware/sc/compiler/ap/Cost.java

@@ -9,8 +9,8 @@ import org.bdware.sc.util.JsonUtil;
 
 public class Cost extends AnnotationProcessor {
     @Override
-    public void processFunction(
-            AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
         CostDetail detail = JsonUtil.fromJson(anno.getArgs().get(0), CostDetail.class);
         functionNode.setCost(detail);
         if (detail.isCountGas())

src/main/java/org/bdware/sc/compiler/ap/DOOP.java

@@ -1,37 +1,28 @@
 package org.bdware.sc.compiler.ap;
 
-import org.bdware.doip.codec.operations.BasicOperations;
 import org.bdware.sc.bean.DoipOperationInfo;
 import org.bdware.sc.compiler.AnnotationProcessor;
-import org.bdware.sc.engine.hook.DOOPHandler;
-import org.bdware.sc.handler.DOOPRequestHandler;
 import org.bdware.sc.node.AnnotationNode;
 import org.bdware.sc.node.ContractNode;
 import org.bdware.sc.node.FunctionNode;
-
-import java.util.List;
+import org.bdware.sc.node.InterfaceNode;
 
 
 // DOOP is designed for DoipModule which contains specific functions for RepositoryHandler
 public class DOOP extends AnnotationProcessor {
     @Override
-    public void processFunction(AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) throws Exception {
         // 通过DOOP注解，解析对应的值，并放进对应的FunctionNode中
-        // 注解必须暴露出来昂！！！
         functionNode.setIsExport(true);
         functionNode.setIsDoipOperation(true);
         functionNode.setDoipOperationInfo(DoipOperationInfo.create(anno, contractNode));
-        // functionNode.setFunctionName(functionNode.getDoipOperationInfo().operationName);
+    }
 
-        // 维护DOOPRequestHandler
-        DOOPRequestHandler.createHandler();
-        DOOPRequestHandler.instance.addDoipOperation(functionNode);
-
-        // 维护DOOPHandler
-        DOOPHandler.createDOOPHandler();
-        DOOPHandler.instance.putFuncNameAndDoipOperationsMapping(functionNode);
-
-        // 维护ContractNode，functionName is useless, use BasicOperation to map the corresponding functionNode
-         // contractNode.updateFunctionMap(functionNode.functionName, functionNode.getDoipOperationInfo().operationName);
+    @Override
+    public void processInterface(AnnotationNode anno, ContractNode contractNode,
+            InterfaceNode interfaceNode) throws Exception {
+        interfaceNode.setIsDoipOperation(true);
+        interfaceNode.setDoipOperationInfo(DoipOperationInfo.create(anno, contractNode));
     }
 }

src/main/java/org/bdware/sc/compiler/ap/Fork.java

@@ -0,0 +1,22 @@
+package org.bdware.sc.compiler.ap;
+
+import org.bdware.sc.bean.ForkInfo;
+import org.bdware.sc.compiler.AnnotationProcessor;
+import org.bdware.sc.node.AnnotationNode;
+import org.bdware.sc.node.ContractNode;
+import org.bdware.sc.node.FunctionNode;
+import org.bdware.sc.node.InterfaceNode;
+
+public class Fork extends AnnotationProcessor {
+    @Override
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
+        functionNode.setForkInfo(ForkInfo.create(anno, contractNode));
+    }
+
+    @Override
+    public void processInterface(AnnotationNode anno, ContractNode contractNode,
+            InterfaceNode interfaceNode) {
+        interfaceNode.setForkInfo(ForkInfo.create(anno, contractNode));
+    }
+}

src/main/java/org/bdware/sc/compiler/ap/HomomorphicDecrypt.java

@@ -8,7 +8,8 @@ import org.bdware.sc.node.FunctionNode;
 
 public class HomomorphicDecrypt extends AnnotationProcessor {
     @Override
-    public void processFunction(AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
         functionNode.setHomomorphicDecrypt(true);
         functionNode.setKeyManagerID(anno.getArgs().get(0));
         functionNode.setSecretID(anno.getArgs().get(1));

src/main/java/org/bdware/sc/compiler/ap/HomomorphicEncrypt.java

@@ -8,7 +8,8 @@ import org.bdware.sc.node.FunctionNode;
 
 public class HomomorphicEncrypt extends AnnotationProcessor {
     @Override
-    public void processFunction(AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
         functionNode.setHomomorphicEncrypt(true);
         functionNode.setKeyManagerID(anno.getArgs().get(0));
         functionNode.setSecretID(anno.getArgs().get(1));

src/main/java/org/bdware/sc/compiler/ap/Join.java

@@ -5,13 +5,20 @@ import org.bdware.sc.compiler.AnnotationProcessor;
 import org.bdware.sc.node.AnnotationNode;
 import org.bdware.sc.node.ContractNode;
 import org.bdware.sc.node.FunctionNode;
+import org.bdware.sc.node.InterfaceNode;
 
 public class Join extends AnnotationProcessor {
     @Override
-    public void processFunction(
-            AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
-       // functionNode.setRouteInfo(RouteInfo.create(anno,contractNode));
-        //增加标记，在ContractNode中记录Join相关的函数和Join规则
-        functionNode.setJoinInfo(JoinInfo.create(anno,contractNode));
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
+        // functionNode.setRouteInfo(RouteInfo.create(anno,contractNode));
+        // 增加标记，在ContractNode中记录Join相关的函数和Join规则
+        functionNode.setJoinInfo(JoinInfo.create(anno, contractNode));
+    }
+
+    @Override
+    public void processInterface(AnnotationNode anno, ContractNode contractNode,
+            InterfaceNode interfaceNode) {
+        interfaceNode.setJoinInfo(JoinInfo.create(anno, contractNode));
     }
 }

src/main/java/org/bdware/sc/compiler/ap/LogLocation.java

@@ -14,12 +14,11 @@ public class LogLocation extends AnnotationProcessor {
     }
 
     @Override
-    public void processFunction(
-            AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
         if (anno != null && anno.getArgs() != null)
             for (String s : anno.getArgs()) {
-                if (s.equals("\"dataware\"")
-                        || s.equals("\"bdledger\"")
+                if (s.equals("\"dataware\"") || s.equals("\"bdledger\"")
                         || s.equals("\"bdledger:\"")) {
                     functionNode.setLogToBDContract(true);
                 } else if (s.startsWith("\"bdledger:") && s.length() > 11) {

src/main/java/org/bdware/sc/compiler/ap/LogType.java

@@ -15,12 +15,13 @@ public class LogType extends AnnotationProcessor {
     }
 
     @Override
-    public void processFunction(
-            AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
         for (String str : anno.getArgs()) {
             org.bdware.sc.node.LogType type = org.bdware.sc.node.LogType.parse(str);
             functionNode.addLogType(type);
-            if (type == org.bdware.sc.node.LogType.Branch) contractNode.setInstrumentBranch(true);
+            if (type == org.bdware.sc.node.LogType.Branch)
+                contractNode.setInstrumentBranch(true);
         }
     }
 }

src/main/java/org/bdware/sc/compiler/ap/Route.java

@@ -1,17 +1,22 @@
 package org.bdware.sc.compiler.ap;
 
-import com.google.gson.Gson;
 import org.bdware.sc.bean.RouteInfo;
 import org.bdware.sc.compiler.AnnotationProcessor;
 import org.bdware.sc.node.AnnotationNode;
 import org.bdware.sc.node.ContractNode;
-import org.bdware.sc.node.CostDetail;
 import org.bdware.sc.node.FunctionNode;
+import org.bdware.sc.node.InterfaceNode;
 
 public class Route extends AnnotationProcessor {
     @Override
-    public void processFunction(
-            AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
-        functionNode.setRouteInfo(RouteInfo.create(anno,contractNode));
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
+        functionNode.setRouteInfo(RouteInfo.create(anno, contractNode));
+    }
+
+    @Override
+    public void processInterface(AnnotationNode anno, ContractNode contractNode,
+            InterfaceNode interfaceNode) {
+        interfaceNode.setRouteInfo(RouteInfo.create(anno, contractNode));
     }
 }

src/main/java/org/bdware/sc/compiler/ap/Split.java

@@ -9,8 +9,8 @@ import org.bdware.sc.node.FunctionNode;
 public class Split extends AnnotationProcessor {
 
     @Override
-    public void processFunction(
-            AnnotationNode anno, ContractNode contractNode, FunctionNode functionNode) {
-        functionNode.setRouteInfo(RouteInfo.create(anno,contractNode));
+    public void processFunction(AnnotationNode anno, ContractNode contractNode,
+            FunctionNode functionNode) {
+        functionNode.setRouteInfo(RouteInfo.create(anno, contractNode));
     }
 }

src/main/java/org/bdware/sc/crdt/SharableVarManager.java

@@ -0,0 +1,171 @@
+package org.bdware.sc.crdt;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bdware.crdt.basic.Constants;
+import org.bdware.crdt.basic.JoinableCRDT;
+import org.bdware.doip.audit.AuditDoaClient;
+import org.bdware.doip.audit.EndpointConfig;
+import org.bdware.doip.audit.client.AuditDoipClient;
+import org.bdware.doip.audit.client.AuditIrpClient;
+import org.bdware.doip.codec.JsonDoipMessage;
+import org.bdware.doip.codec.doipMessage.DoipMessage;
+import org.bdware.doip.codec.doipMessage.DoipMessageFactory;
+import org.bdware.doip.codec.doipMessage.DoipResponseCode;
+import org.bdware.doip.endpoint.client.DoipMessageCallback;
+import org.bdware.irp.client.IrpClient;
+import org.bdware.irp.stateinfo.StateInfoBase;
+import org.bdware.sc.crdt.proxy.*;
+import org.bdware.sc.util.JsonUtil;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class SharableVarManager {
+    static Logger LOGGER = LogManager.getLogger(SharableVarManager.class);
+    public static SharableVarManager instance;
+    public final String cpId;
+    Map<String, SharableVar> allVars;
+    IrpClient client;
+    AuditDoaClient doaClient;
+
+    public static final String SHARABLEOP = "86.100871/SyncVar";
+
+    public SharableVarManager(String cpId, EndpointConfig config) {
+        this.allVars = new ConcurrentHashMap<>();
+        this.client = new AuditIrpClient(config);
+        this.doaClient = new AuditDoaClient("", config, null);
+        this.cpId = cpId;
+    }
+
+    public static void initSharableVarManager(String id, EndpointConfig config) {
+        if (instance == null) {
+            instance = new SharableVarManager(id, config);
+        }
+    }
+
+    public DoipMessage handleSyncMessage(DoipMessage message) {
+        try {
+            String varId = message.header.parameters.attributes.get("varId").getAsString();
+            String content = message.header.parameters.attributes.get("content").getAsString();
+            String type = message.header.parameters.attributes.get("type").getAsString();
+            SharableVar var = allVars.get(varId);
+            if (var != null) {
+                if (Objects.equals(type, "r2r") || Objects.equals(type, "w2r")) {
+                    JoinableCRDT delta = JsonUtil.fromJson(content, var.readerVar.getClass());
+                    var.readerVar.join(delta);
+                    var.readerVarDeltaQueue.add(delta);
+                } else if (Objects.equals(type, "w2w")) {
+                    JoinableCRDT delta = JsonUtil.fromJson(content, var.writerVar.getClass());
+                    var.writerVar.join(delta);
+                    var.writerVarDeltaQueue.add(delta);
+                }
+            }
+            DoipMessageFactory.DoipMessageBuilder builder =
+                    new DoipMessageFactory.DoipMessageBuilder();
+            builder.createResponse(DoipResponseCode.Success, message);
+            builder.addAttributes("msg", "success");
+            return builder.create();
+        } catch (Exception e) {
+            ByteArrayOutputStream bo = new ByteArrayOutputStream();
+            e.printStackTrace();
+            e.printStackTrace(new PrintStream(bo));
+            DoipMessageFactory.DoipMessageBuilder builder =
+                    new DoipMessageFactory.DoipMessageBuilder();
+            builder.createResponse(DoipResponseCode.UnKnownError, message);
+            builder.addAttributes("exception", bo.toString());
+            return builder.create();
+        }
+    }
+
+    private DoipMessage createSyncMessage(String target, String varId, String content,
+            String type) {
+        DoipMessageFactory.DoipMessageBuilder builder = new DoipMessageFactory.DoipMessageBuilder();
+        builder.createRequest(target, SHARABLEOP);
+        builder.addAttributes("varId", varId);
+        builder.addAttributes("content", content);
+        builder.addAttributes("type", type);
+        return builder.create();
+    }
+
+    public void broadcastSyncMessage(String varId, List<String> sendTo, String content,
+            String type) {
+        for (String target : sendTo) {
+            DoipMessage doipMessage = createSyncMessage(target, varId, content, type);
+            if (target.equals(cpId)) {
+                LOGGER.info("Handle Sync locally:"
+                        + JsonUtil.toJson(JsonDoipMessage.fromDoipMessage(doipMessage)));
+                handleSyncMessage(doipMessage);
+            } else {
+                AuditDoipClient client = getClient(target);
+                client.sendMessage(doipMessage, new DoipMessageCallback() {
+                    @Override
+                    public void onResult(DoipMessage doipMessage) {
+                        LOGGER.info("RECV Sync:"
+                                + JsonUtil.toJson(JsonDoipMessage.fromDoipMessage(doipMessage)));
+                    }
+                });
+            }
+        }
+    }
+
+    private AuditDoipClient getClient(String id) {
+        return doaClient.convertDoidToRepo(id);
+    }
+
+    public synchronized SharableVar createVar(String identifier, String type) {
+        try {
+            if (allVars.containsKey(identifier)) {
+                return allVars.get(identifier);
+            }
+            StateInfoBase stateInfoBase = client.resolve(identifier);
+            if (stateInfoBase.handleValues.has("bdwType") && stateInfoBase.handleValues
+                    .get("bdwType").getAsString().equals("SharableVar")) {
+                SharableVarState.SharableVarConfiguration sharableVarConf =
+                        JsonUtil.fromJson(stateInfoBase.handleValues,
+                                SharableVarState.SharableVarConfiguration.class);
+                SharableVar sharableVar = createSharableVar(sharableVarConf, identifier, type);
+                if (sharableVar != null) {
+                    allVars.put(identifier, sharableVar);
+                }
+                return sharableVar;
+            } else
+                return null;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private SharableVar createSharableVar(SharableVarState.SharableVarConfiguration conf,
+            String identifier, String type) {
+        switch (type) {
+            case Constants.TypeName.G_COUNTER:
+                return new GCounterProxy(identifier, cpId, conf);
+            case Constants.TypeName.PN_COUNTER:
+                return new PNCounterProxy(identifier, cpId, conf);
+            case Constants.TypeName.DW_FLAG:
+                return new DWFlagProxy(identifier, cpId, conf);
+            case Constants.TypeName.LWW_REGISTER:
+                return new LWWRegisterProxy(identifier, cpId, conf);
+            case Constants.TypeName.MV_REGISTER:
+                return new MVRegisterProxy(identifier, cpId, conf);
+            case Constants.TypeName.G_SET:
+                return new GSetProxy(identifier, cpId, conf);
+            case Constants.TypeName.TP_SET:
+                return new TPSetProxy(identifier, cpId, conf);
+            case Constants.TypeName.AW_OR_SET:
+                return new AWORSetProxy(identifier, cpId, conf);
+            case Constants.TypeName.RW_OR_SET:
+                return new RWORSetProxy(identifier, cpId, conf);
+            case Constants.TypeName.RW_LWW_SET:
+                return new RWLWWSetProxy(identifier, cpId, conf);
+        }
+        return null;
+    }
+
+}

src/main/java/org/bdware/sc/crdt/SharableVarState.java

@@ -0,0 +1,304 @@
+package org.bdware.sc.crdt;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class SharableVarState {
+    private String myId;
+
+    private SharableVarConfiguration sharableVarConfiguration;
+
+    private Integer myIndex;
+
+    // 是reader
+    private boolean readerFlag;
+
+    // 是writer
+    private boolean writerFlag;
+
+    // 是reader的根结点
+    private boolean readerRootFlag;
+
+    // 是writer的根结点
+    private boolean writerRootFlag;
+
+    // 作为writer的话，非根节点具有parent。根结点为null
+    private String writerParent;
+
+    // 作为reader的话，非叶子节点具有children，叶子节点为null
+    private List<String> readerChildren;
+
+    // reader森林的根结点们,用来给writer根结点同步数据用
+    private List<String> readerRoots;
+
+    private Long writeInterval;
+
+    private Long readerInterval;
+
+    public SharableVarState(String myId, SharableVarConfiguration sharableVarConfiguration) {
+        this.myId = myId;
+        this.sharableVarConfiguration = sharableVarConfiguration;
+        parseProperties();
+    }
+
+    private void parseProperties() {
+        for (int i = 0; i < sharableVarConfiguration.getNodeIds().length; i++) {
+            if (Objects.equals(sharableVarConfiguration.getNodeIds()[i], myId)) {
+                this.myIndex = i;
+                break;
+            }
+        }
+        if (this.myIndex == null) {
+            return;
+        }
+        int writerParentIdx = sharableVarConfiguration.writerParents[this.myIndex];
+        if (writerParentIdx == -1) {
+            writerFlag = true;
+            writerRootFlag = true;
+        } else if (writerParentIdx >= 0) {
+            writerFlag = true;
+            writerParent = sharableVarConfiguration.nodeIds[writerParentIdx];
+        }
+
+        int readerParentIdx = sharableVarConfiguration.readerParents[this.myIndex];
+        if (readerParentIdx == -1) {
+            readerFlag = true;
+            readerRootFlag = true;
+        } else if (readerParentIdx >= 0) {
+            readerFlag = true;
+        }
+        if (readerFlag) {
+            readerChildren = new ArrayList<>();
+            for (int i = 0; i < sharableVarConfiguration.readerParents.length; i++) {
+                if (sharableVarConfiguration.readerParents[i] == myIndex) {
+                    readerChildren.add(sharableVarConfiguration.nodeIds[i]);
+                }
+            }
+            readerInterval = sharableVarConfiguration.readerIntervals[myIndex];
+        }
+        if (writerFlag) {
+            writeInterval = sharableVarConfiguration.writerIntervals[myIndex];
+        }
+        if (writerRootFlag) {
+            readerRoots = new ArrayList<>();
+            for (int i = 0; i < sharableVarConfiguration.readerParents.length; i++) {
+                if (sharableVarConfiguration.readerParents[i] == -1) {
+                    readerRoots.add(sharableVarConfiguration.nodeIds[i]);
+                }
+            }
+        }
+    }
+
+    public String getMyId() {
+        return myId;
+    }
+
+    public void setMyId(String myId) {
+        this.myId = myId;
+    }
+
+    public SharableVarConfiguration getSharableVarConfiguration() {
+        return sharableVarConfiguration;
+    }
+
+    public void setSharableVarConfiguration(SharableVarConfiguration sharableVarConfiguration) {
+        this.sharableVarConfiguration = sharableVarConfiguration;
+    }
+
+    public Integer getMyIndex() {
+        return myIndex;
+    }
+
+    public void setMyIndex(Integer myIndex) {
+        this.myIndex = myIndex;
+    }
+
+    public boolean isReaderFlag() {
+        return readerFlag;
+    }
+
+    public void setReaderFlag(boolean readerFlag) {
+        this.readerFlag = readerFlag;
+    }
+
+    public boolean isWriterFlag() {
+        return writerFlag;
+    }
+
+    public void setWriterFlag(boolean writerFlag) {
+        this.writerFlag = writerFlag;
+    }
+
+    public boolean isReaderRootFlag() {
+        return readerRootFlag;
+    }
+
+    public void setReaderRootFlag(boolean readerRootFlag) {
+        this.readerRootFlag = readerRootFlag;
+    }
+
+    public boolean isWriterRootFlag() {
+        return writerRootFlag;
+    }
+
+    public void setWriterRootFlag(boolean writerRootFlag) {
+        this.writerRootFlag = writerRootFlag;
+    }
+
+    public String getWriterParent() {
+        return writerParent;
+    }
+
+    public void setWriterParent(String writerParent) {
+        this.writerParent = writerParent;
+    }
+
+    public List<String> getReaderChildren() {
+        return readerChildren;
+    }
+
+    public void setReaderChildren(List<String> readerChildren) {
+        this.readerChildren = readerChildren;
+    }
+
+    public List<String> getReaderRoots() {
+        return readerRoots;
+    }
+
+    public void setReaderRoots(List<String> readerRoots) {
+        this.readerRoots = readerRoots;
+    }
+
+    public Long getWriteInterval() {
+        return writeInterval;
+    }
+
+    public void setWriteInterval(Long writeInterval) {
+        this.writeInterval = writeInterval;
+    }
+
+    public Long getReaderInterval() {
+        return readerInterval;
+    }
+
+    public void setReaderInterval(Long readerInterval) {
+        this.readerInterval = readerInterval;
+    }
+
+    public static class SharableVarConfiguration {
+        // ["/bdrepo1/var/0", "/bdrepo1/var/1", "/bdrepo1/var/2", "/bdrepo1/var/3"]
+        // 0(w) -> 2(w) -> 1(r) -> 3(r)
+        // |
+        // 1(w) -
+
+        // ["/bdrepo1/var/0", "/bdrepo1/var/1", "/bdrepo1/var/2", "/bdrepo1/var/3"]
+        String[] nodeIds;
+        long maxDelay;
+        int[] writerIndexes;
+        int[] readerIndexes;
+
+        // [2, 2, -1, -2] -2表示该节点为非writer节点，-1表示该结点为writer根结点
+        int[] writerParents;
+        // [-2, -1, -2, 1] -2表示该节点为非reader节点，-1表示该结点为reader根结点
+        int[] readerParents;
+        // [5, 5, 6, -1] -1为无需同步
+        long[] writerIntervals;
+        // [-1, 4, -1, -1]
+        long[] readerIntervals;
+
+        public String[] getNodeIds() {
+            return nodeIds;
+        }
+
+        public void setNodeIds(String[] nodeIds) {
+            this.nodeIds = nodeIds;
+        }
+
+        public long getMaxDelay() {
+            return maxDelay;
+        }
+
+        public void setMaxDelay(long maxDelay) {
+            this.maxDelay = maxDelay;
+        }
+
+        public int[] getWriterIndexes() {
+            return writerIndexes;
+        }
+
+        public void setWriterIndexes(int[] writerIndexes) {
+            this.writerIndexes = writerIndexes;
+        }
+
+        public int[] getReaderIndexes() {
+            return readerIndexes;
+        }
+
+        public void setReaderIndexes(int[] readerIndexes) {
+            this.readerIndexes = readerIndexes;
+        }
+
+        public int[] getWriterParents() {
+            return writerParents;
+        }
+
+        public void setWriterParents(int[] writerParents) {
+            this.writerParents = writerParents;
+        }
+
+        public int[] getReaderParents() {
+            return readerParents;
+        }
+
+        public void setReaderParents(int[] readerParents) {
+            this.readerParents = readerParents;
+        }
+
+        public long[] getWriterIntervals() {
+            return writerIntervals;
+        }
+
+        public void setWriterIntervals(long[] writerIntervals) {
+            this.writerIntervals = writerIntervals;
+        }
+
+        public long[] getReaderIntervals() {
+            return readerIntervals;
+        }
+
+        public void setReaderIntervals(long[] readerIntervals) {
+            this.readerIntervals = readerIntervals;
+        }
+    }
+
+    public static void main(String[] args) {
+        // ["/bdrepo1/var/0", "/bdrepo1/var/1", "/bdrepo1/var/2", "/bdrepo1/var/3"]
+        // 0(w) -> 2(w) -> 1(r) -> 3(r)
+        // |
+        // 1(w) -
+
+
+        SharableVarConfiguration sharableVarConfiguration = new SharableVarConfiguration();
+        sharableVarConfiguration.setNodeIds(new String[] {"/bdrepo1/var/0", "/bdrepo1/var/1",
+                "/bdrepo1/var/2", "/bdrepo1/var/3"});
+        sharableVarConfiguration.setWriterParents(new int[] {2, 2, -1, -2});
+        sharableVarConfiguration.setReaderParents(new int[] {-2, -1, -2, 1});
+        sharableVarConfiguration.setWriterIntervals(new long[] {5, 5, 6, -1});
+        sharableVarConfiguration.setReaderIntervals(new long[] {-1, 4, -1, -1});
+
+
+        SharableVarState sharableVarState0 =
+                new SharableVarState("/bdrepo1/var/0", sharableVarConfiguration);
+        SharableVarState sharableVarState1 =
+                new SharableVarState("/bdrepo1/var/1", sharableVarConfiguration);
+        SharableVarState sharableVarState2 =
+                new SharableVarState("/bdrepo1/var/2", sharableVarConfiguration);
+        SharableVarState sharableVarState3 =
+                new SharableVarState("/bdrepo1/var/3", sharableVarConfiguration);
+        System.out.println(sharableVarState0);
+        System.out.println(sharableVarState1);
+        System.out.println(sharableVarState2);
+        System.out.println(sharableVarState3);
+    }
+}

src/main/java/org/bdware/sc/crdt/planning/PlanningTest.java

@@ -0,0 +1,54 @@
+package org.bdware.sc.crdt.planning;
+
+public class PlanningTest {
+    public static void main(String[] args) {
+
+        final int nodeIdsCount = 1000;
+        final int writerCount = 500;
+        final int readerCount = 500;
+        String[] nodeIds = new String[nodeIdsCount];
+        int[] writers = new int[writerCount];
+        int[] readers = new int[readerCount];
+        for (int i = 0; i < nodeIdsCount; ++i) {
+            nodeIds[i] = "node_" + i;
+            if (i < writerCount) {
+                writers[i] = i;
+            }
+            if (i >= nodeIdsCount - readerCount) {
+                readers[i - nodeIdsCount + readerCount] = i;
+            }
+        }
+        long maxDelay = 300;
+        int bandwidthUpload = 30;
+        int bandwidthDownload = 30;
+        int datasize = 10;
+        double domainSize = 100 * datasize;
+
+        PlanningWith0Expansivity planning0 = new PlanningWith0Expansivity(nodeIds, writers, readers,
+                maxDelay, bandwidthDownload, bandwidthUpload, datasize);
+        PlanningWithkExpansivity planningK = new PlanningWithkExpansivity(nodeIds, writers, readers,
+                maxDelay, bandwidthDownload, bandwidthUpload, datasize, domainSize);
+        PlanningWith1Expansivity planning1 = new PlanningWith1Expansivity(nodeIds, writers, readers,
+                maxDelay, bandwidthDownload, bandwidthUpload, datasize);
+
+        long start = System.currentTimeMillis();
+        planning0.adjustAndCalc();
+        planning0.allocate();
+        long end = System.currentTimeMillis();
+        System.out.println("took " + (end - start));
+        System.out.println();
+
+        start = System.currentTimeMillis();
+        planningK.adjustAndCalc();
+        planningK.allocate();
+        end = System.currentTimeMillis();
+        System.out.println("took " + (end - start));
+        System.out.println();
+
+        start = System.currentTimeMillis();
+        planning1.adjustAndCalc();
+        planning1.allocate();
+        end = System.currentTimeMillis();
+        System.out.println("took " + (end - start));
+    }
+}

src/main/java/org/bdware/sc/crdt/planning/PlanningWith0Expansivity.java

@@ -0,0 +1,70 @@
+package org.bdware.sc.crdt.planning;
+
+public class PlanningWith0Expansivity extends SharableNetworkPlanning {
+    public PlanningWith0Expansivity(String[] nodeIds, int[] writers, int[] readers, long maxDelay,
+            int bandwidthDownload, int bandwidthUpload, int dataSize) {
+        this.nodeIds = nodeIds;
+        this.writers = writers;
+        this.readers = readers;
+        this.maxDelay = maxDelay;
+        this.bandwidthDownload = bandwidthDownload;
+        this.bandwidthUpload = bandwidthUpload;
+        this.dataSize = dataSize;
+        this.totalCountW = writers.length;
+        this.totalCountR = readers.length;
+    }
+
+    public boolean writerTreeConstraint() {
+        if (frequencySyncW > 0) {
+            double common = frequencySyncW * dataSize;
+            // 非叶子节点下载带宽
+            boolean result1 = bandwidthDownload >= common * treeDegreeW;
+            // 非根节点上行带宽
+            boolean result2 = bandwidthUpload >= common;
+            return result1 && result2;
+        }
+        return true;
+    }
+
+    public boolean writer2ReaderConstraint() {
+        double common = frequencySyncWR * dataSize;
+        // Writer根节点上行带宽
+        boolean result1 = bandwidthUpload >= common * rootCountR;
+        // Reader根节点下载带宽
+        boolean result2 = bandwidthDownload >= common * rootCountW;
+        return result1 && result2;
+    }
+
+    public boolean readerTreeConstraint() {
+        if (frequencySyncR > 0) {
+            double common = frequencySyncR * dataSize;
+            // Reader非叶子节点上行带宽
+            boolean result1 = bandwidthUpload >= common * treeDegreeR;
+            // Reader非根节点下载带宽
+            boolean result2 = bandwidthDownload >= common;
+            return result1 && result2;
+        }
+        return true;
+    }
+
+    public void calcOptimizedResult() {
+        double a = (treeHeightW - 1) * (totalCountW - rootCountW);
+        double b = rootCountR * rootCountW;
+        double c = (treeHeightR - 1) * (totalCountR - rootCountR);
+
+        double A = Math.sqrt(a);
+        double B = Math.sqrt(b);
+        double C = Math.sqrt(c);
+
+        wDelay = (long) (maxDelay * (A / (A + B + C)));
+        w2rDelay = (long) (maxDelay * (B / (A + B + C)));
+        rDelay = (long) (maxDelay * (C / (A + B + C)));
+
+        frequencySyncW = wDelay > 0 ? (treeHeightW - 1) / wDelay : 0;
+        frequencySyncR = rDelay > 0 ? (treeHeightR - 1) / rDelay : 0;
+        frequencySyncWR = w2rDelay > 0 ? (1.0 / w2rDelay) : 0;
+
+        totalData =
+                (long) (dataSize * (frequencySyncW * a + frequencySyncWR * b + frequencySyncR * c));
+    }
+}

src/main/java/org/bdware/sc/crdt/planning/PlanningWith1Expansivity.java

@@ -0,0 +1,83 @@
+package org.bdware.sc.crdt.planning;
+
+public class PlanningWith1Expansivity extends SharableNetworkPlanning {
+    public PlanningWith1Expansivity(String[] nodeIds, int[] writers, int[] readers, long maxDelay,
+            int bandwidthDownload, int bandwidthUpload, int dataSize) {
+        this.nodeIds = nodeIds;
+        this.writers = writers;
+        this.readers = readers;
+        this.maxDelay = maxDelay;
+        this.bandwidthDownload = bandwidthDownload;
+        this.bandwidthUpload = bandwidthUpload;
+        this.dataSize = dataSize;
+        this.totalCountW = writers.length;
+        this.totalCountR = readers.length;
+    }
+
+    public boolean writerTreeConstraint() {
+        if (frequencySyncW > 0) {
+            double common = frequencySyncW * (treeNodeCountW - 1) * dataSize;
+            // 非叶子节点下载带宽
+            boolean result1 = bandwidthDownload >= common;
+            // 非根节点上行带宽
+            boolean result2 = bandwidthUpload >= common / treeDegreeW;
+            return result1 && result2;
+        }
+        return true;
+    }
+
+    public boolean writer2ReaderConstraint() {
+        double common = frequencySyncWR * totalCountW * dataSize;
+        // Writer根节点上行带宽
+        boolean result1 = bandwidthUpload >= common * rootCountR / rootCountW;
+        // Reader根节点下载带宽
+        boolean result2 = bandwidthDownload >= common;
+        return result1 && result2;
+    }
+
+    public boolean readerTreeConstraint() {
+        if (frequencySyncR > 0) {
+            double common = frequencySyncR * totalCountW * dataSize;
+            // Reader非叶子节点上行带宽
+            boolean result1 = bandwidthUpload >= common * treeDegreeR;
+            // Reader非根节点下载带宽
+            boolean result2 = bandwidthDownload >= common;
+            return result1 && result2;
+        }
+        return true;
+    }
+
+    public void calcOptimizedResult() {
+        double a = 0;
+        if (treeHeightW > 1) {
+            if (treeDegreeW > 1) {
+                a = (treeHeightW - 1)
+                        * (treeHeightW * Math.pow(treeDegreeW, treeHeightW) / (treeDegreeW - 1)
+                                + (treeDegreeW - Math.pow(treeDegreeW, treeHeightW + 1))
+                                        / (treeDegreeW - 1) / (treeDegreeW - 1))
+                        * rootCountW;
+            } else {
+                // treeDegreeW = 1
+                a = (treeHeightW - 1) * (treeHeightW - 1) * treeHeightW / 2;
+            }
+        }
+        double b = rootCountR * totalCountW;
+        double c = (totalCountR - rootCountR) * (treeHeightR - 1) * totalCountW;
+
+        double A = Math.sqrt(a);
+        double B = Math.sqrt(b);
+        double C = Math.sqrt(c);
+
+        wDelay = (long) Math.ceil(maxDelay * (A / (A + B + C)));
+        w2rDelay = (long) Math.ceil(maxDelay * (B / (A + B + C)));
+        rDelay = (long) Math.ceil(maxDelay * (C / (A + B + C)));
+
+
+        frequencySyncW = wDelay > 0 ? (treeHeightW - 1) / wDelay : 0;
+        frequencySyncR = rDelay > 0 ? (treeHeightR - 1) / rDelay : 0;
+        frequencySyncWR = w2rDelay > 0 ? (1.0 / w2rDelay) : 0;
+
+        totalData =
+                (long) (dataSize * (frequencySyncW * a + frequencySyncWR * b + frequencySyncR * c));
+    }
+}

src/main/java/org/bdware/sc/crdt/planning/PlanningWithkExpansivity.java

@@ -0,0 +1,122 @@
+package org.bdware.sc.crdt.planning;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class PlanningWithkExpansivity extends SharableNetworkPlanning {
+    Map<Integer, Map<Integer, Double>> accumulationsCache;
+    private final double k;
+    private final double domainSize;
+
+    public PlanningWithkExpansivity(String[] nodeIds, int[] writers, int[] readers, long maxDelay,
+            int bandwidthDownload, int bandwidthUpload, int dataSize, double domainSize) {
+        this.nodeIds = nodeIds;
+        this.writers = writers;
+        this.readers = readers;
+        this.maxDelay = maxDelay;
+        this.bandwidthDownload = bandwidthDownload;
+        this.bandwidthUpload = bandwidthUpload;
+        this.dataSize = dataSize;
+        this.totalCountW = writers.length;
+        this.totalCountR = readers.length;
+        this.domainSize = domainSize;
+        this.k = (domainSize - dataSize) / domainSize;
+    }
+
+    public boolean writerTreeConstraint() {
+        if (frequencySyncW > 0) {
+            if (treeDegreeW > 1) {
+                double common = frequencySyncW * domainSize * (1 - Math.pow(k,
+                        (Math.pow(treeDegreeW, treeHeightW - 1) - 1) / (treeDegreeW - 1)));
+                // 非叶子节点下载带宽
+                boolean result1 = bandwidthDownload >= common * treeDegreeW;
+                // 非根节点上行带宽
+                boolean result2 = bandwidthUpload >= common;
+                return result1 && result2;
+            } else if (treeDegreeW == 1) {
+                double common = frequencySyncW * domainSize * (1 - Math.pow(k, treeHeightW - 1));
+                boolean result1 = bandwidthDownload >= common;
+                // 非根节点上行带宽
+                boolean result2 = bandwidthUpload >= common;
+                return result1 && result2;
+            }
+        }
+        return true;
+    }
+
+    public boolean writer2ReaderConstraint() {
+        double common = frequencySyncWR * domainSize * (1 - Math.pow(k, treeNodeCountW));
+        // Writer根节点上行带宽
+        boolean result1 = bandwidthUpload >= common * rootCountR;
+        // Reader根节点下载带宽
+        boolean result2 = bandwidthDownload >= common * rootCountW;
+        return result1 && result2;
+    }
+
+    public boolean readerTreeConstraint() {
+        if (frequencySyncR > 0) {
+            double common = frequencySyncR * domainSize * (1 - Math.pow(k, totalCountW));
+            // Reader非叶子节点上行带宽
+            boolean result1 = bandwidthUpload >= common * treeDegreeR;
+            // Reader非根节点下载带宽
+            boolean result2 = bandwidthDownload >= common;
+            return result1 && result2;
+        }
+        return true;
+    }
+
+    double calcAccumulationWithK() {
+        if (accumulationsCache == null) {
+            accumulationsCache = new HashMap<>();
+        }
+        int H1 = (int) treeHeightW;
+        int D1 = (int) treeDegreeW;
+        if (accumulationsCache.get(H1) != null && accumulationsCache.get(H1).get(D1) != null) {
+            return accumulationsCache.get(H1).get(D1);
+        }
+        double result = 0;
+        for (int h = 1; h < H1; ++h) {
+            result += (Math.pow(D1, h) * (1 - Math.pow(k, (Math.pow(D1, H1 - h) - 1) / (D1 - 1))));
+        }
+        accumulationsCache.computeIfAbsent(H1, k -> new HashMap<>()).put(D1, result);
+        return result;
+    }
+
+    double calcAccumulation() {
+        int H1 = (int) treeHeightW;
+        double result = 0;
+        for (int h = 1; h < H1; ++h) {
+            result += (1 - Math.pow(k, H1 - h));
+        }
+        return result;
+    }
+
+    public void calcOptimizedResult() {
+        double a = 0;
+        if (treeDegreeW > 1) {
+            a = treeHeightW > 1 ? (treeHeightW - 1) * calcAccumulationWithK() * rootCountW : 0;
+        } else if (treeDegreeW == 1) {
+            a = treeHeightW > 1 ? (treeHeightW - 1) * calcAccumulation() * rootCountW : 0;
+        }
+
+        double b = rootCountR * rootCountW * (1 - Math.pow(k, treeNodeCountW));
+        double c = treeHeightR > 1
+                ? (treeHeightR - 1) * (totalCountR - rootCountR) * (1 - Math.pow(k, totalCountW))
+                : 0;
+
+        double A = Math.sqrt(a);
+        double B = Math.sqrt(b);
+        double C = Math.sqrt(c);
+        wDelay = (long) Math.ceil(maxDelay * (A / (A + B + C)));
+        w2rDelay = (long) Math.ceil(maxDelay * (B / (A + B + C)));
+        rDelay = (long) Math.ceil(maxDelay * (C / (A + B + C)));
+
+
+        frequencySyncW = wDelay > 0 ? (treeHeightW - 1) / wDelay : 0;
+        frequencySyncR = rDelay > 0 ? (treeHeightR - 1) / rDelay : 0;
+        frequencySyncWR = w2rDelay > 0 ? (1.0 / w2rDelay) : 0;
+
+        totalData = (long) (domainSize
+                * (frequencySyncW * a + frequencySyncWR * b + frequencySyncR * c));
+    }
+}

src/main/java/org/bdware/sc/crdt/planning/SharableNetworkPlanning.java

@@ -0,0 +1,197 @@
+package org.bdware.sc.crdt.planning;
+
+import java.util.*;
+
+public class SharableNetworkPlanning {
+    protected String[] nodeIds;
+    protected int[] writers;
+    protected int[] readers;
+    protected long maxDelay;
+
+    protected int bandwidthDownload;
+    protected int bandwidthUpload;
+    protected int dataSize;
+
+
+    protected long wDelay;
+    protected long rDelay;
+    protected long w2rDelay;
+
+
+    protected double totalCountW;
+    protected double rootCountW;
+    protected double treeNodeCountW;
+    protected double treeDegreeW;
+    protected double treeHeightW;
+    protected double frequencySyncW;
+
+
+    protected double totalCountR;
+    protected double rootCountR;
+    protected double treeNodeCountR;
+    protected double treeDegreeR;
+    protected double treeHeightR;
+    protected double frequencySyncR;
+
+    protected double frequencySyncWR;
+
+    protected long totalData;
+
+    protected static double logNM(double n, double m) {
+        return Math.log(m) / Math.log(n);
+    }
+
+    public void adjustWriterTree(int rootCountW, int treeDegreeW) {
+        this.rootCountW = rootCountW;
+        this.treeDegreeW = treeDegreeW;
+        this.treeNodeCountW = Math.ceil(totalCountW / rootCountW);
+        if (treeDegreeW > 1) {
+            this.treeHeightW =
+                    Math.ceil(logNM(treeDegreeW, treeNodeCountW * (treeDegreeW - 1) + 1));
+        } else {
+            this.treeHeightW = treeNodeCountW;
+        }
+    }
+
+    public void adjustReaderTree(int rootCountR, int treeDegreeR) {
+        this.rootCountR = rootCountR;
+        this.treeDegreeR = treeDegreeR;
+        this.treeNodeCountR = Math.ceil(totalCountR / rootCountR);
+        if (treeDegreeR > 1) {
+            this.treeHeightR =
+                    Math.ceil(logNM(treeDegreeR, treeNodeCountR * (treeDegreeR - 1) + 1));
+        } else {
+            this.treeHeightR = treeNodeCountR;
+        }
+    }
+
+    protected void adjustAndCalc() {
+        long minTotalData = Long.MAX_VALUE;
+        String result = "";
+        for (int rootCountW = 1; rootCountW <= writers.length; ++rootCountW) {
+            int nodeCountPerTree = (int) Math.ceil(writers.length * 1.0 / rootCountW);
+            for (int treeDegreeW = 1; treeDegreeW <= nodeCountPerTree; ++treeDegreeW) {
+                adjustWriterTree(rootCountW, treeDegreeW);
+                for (int rootCountR = 1; rootCountR <= readers.length; ++rootCountR) {
+                    int maxTreeDegreeR = (int) Math.ceil(readers.length * 1.0 / rootCountR);
+                    for (int treeDegreeR = 1; treeDegreeR <= maxTreeDegreeR; ++treeDegreeR) {
+                        adjustReaderTree(rootCountR, treeDegreeR);
+                        calcOptimizedResult();
+                        if (!readerTreeConstraint()) {
+                            // System.out.println("reader");
+                            continue;
+                        }
+                        if (!writerTreeConstraint()) {
+                            // System.out.println("writer");
+                            continue;
+                        }
+                        if (!writer2ReaderConstraint()) {
+                            // System.out.println("writer2Reader");
+                            continue;
+                        }
+                        if (totalData > 0 && minTotalData > totalData) {
+                            minTotalData = totalData;
+                            result = toString();
+                        }
+                    }
+                }
+            }
+        }
+
+        System.out.println(minTotalData);
+        System.out.println(result);
+    }
+
+    protected void calcOptimizedResult() {}
+
+    protected boolean writer2ReaderConstraint() {
+        return true;
+    }
+
+    protected boolean writerTreeConstraint() {
+        return true;
+    }
+
+    protected boolean readerTreeConstraint() {
+        return true;
+    }
+
+    public void allocate() {
+        Set<Integer> writerOnlySet = new LinkedHashSet<>();
+        for (int i : writers) {
+            writerOnlySet.add(i);
+        }
+        Set<Integer> readerOnlySet = new LinkedHashSet<>();
+        Set<Integer> rwSet = new LinkedHashSet<>();
+        for (int i : readers) {
+            if (writerOnlySet.contains(i)) {
+                rwSet.add(i);
+                writerOnlySet.remove(i);
+            } else {
+                readerOnlySet.add(i);
+            }
+        }
+        int[] writerParents = allocateTreeNode(writerOnlySet, rwSet, (int) rootCountW,
+                (int) treeDegreeW, wDelay, (int) treeHeightW);
+        int[] readerParents = allocateTreeNode(readerOnlySet, rwSet, (int) rootCountR,
+                (int) treeDegreeR, rDelay, (int) treeHeightR);
+        System.out.println(readerParents);
+    }
+
+    private int[] allocateTreeNode(Set<Integer> onlySet, Set<Integer> rwSet, int rootCount,
+            int degree, long delay, int height) {
+        int[] result = new int[nodeIds.length];
+        long[] writerInterval = new long[nodeIds.length];
+        Arrays.fill(result, -2);
+
+        Map<Integer, List<Integer>> children = new HashMap<>();
+        Deque<Integer> notFullNodesIdx = new LinkedList<>();
+        for (Integer idx : onlySet) {
+            if (children.size() < rootCount) {
+                children.put(idx, new ArrayList<>());
+                notFullNodesIdx.add(idx);
+                result[idx] = -1;
+            } else {
+                int parentIdx = notFullNodesIdx.peek();
+                children.computeIfAbsent(parentIdx, k -> new ArrayList<>()).add(idx);
+                notFullNodesIdx.addLast(idx);
+                if (children.get(parentIdx).size() >= degree) {
+                    notFullNodesIdx.pop();
+                }
+                writerInterval[idx] = delay / (height - 1);
+            }
+        }
+
+        // 读写节点放在尽量靠近叶子节点，以便带宽的平衡
+        for (Integer idx : rwSet) {
+            if (children.size() < rootCount) {
+                children.put(idx, new ArrayList<>());
+                notFullNodesIdx.add(idx);
+                result[idx] = -1;
+            } else {
+                int parentIdx = notFullNodesIdx.peek();
+                children.computeIfAbsent(parentIdx, k -> new ArrayList<>()).add(idx);
+                notFullNodesIdx.addLast(idx);
+                if (children.get(parentIdx).size() >= degree) {
+                    notFullNodesIdx.pop();
+                }
+                writerInterval[idx] = delay / (height - 1);
+            }
+        }
+
+        for (Integer parentId : children.keySet()) {
+            for (int childId : children.get(parentId)) {
+                result[childId] = parentId;
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        String result = "[" + wDelay + "," + w2rDelay + "," + rDelay + "]\n"
+                + "writer tree: degree " + treeDegreeW + ", count " + rootCountW + ",\n"
+                + "reader tree: degree " + treeDegreeR + ", count " + rootCountR;
+        return result;
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/AWORSetProxy.java

@@ -0,0 +1,38 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.set.AWORSet;
+import org.bdware.sc.crdt.SharableVarState;
+
+import java.util.Set;
+
+public class AWORSetProxy extends SharableVar<AWORSet<Object>> {
+    public AWORSetProxy(String varId, String cpId, SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void add(Object val) {
+        if (writerVar != null) {
+            AWORSet<Object> delta = writerVar.add(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void remove(Object val) {
+        if (writerVar != null) {
+            AWORSet<Object> delta = writerVar.remove(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Set<Object> read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected AWORSet<Object> createDeltaCrdt(String nodeId, String varId) {
+        return new AWORSet<>(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/DWFlagProxy.java

@@ -0,0 +1,36 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.flag.DWFlag;
+import org.bdware.sc.crdt.SharableVarState;
+
+public class DWFlagProxy extends SharableVar<DWFlag> {
+    public DWFlagProxy(String varId, String cpId, SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void enable() {
+        if (writerVar != null) {
+            DWFlag delta = writerVar.enable();
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void disable() {
+        if (writerVar != null) {
+            DWFlag delta = writerVar.disable();
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public boolean read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected DWFlag createDeltaCrdt(String nodeId, String varId) {
+        return new DWFlag(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/EWFlagProxy.java

@@ -0,0 +1,36 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.flag.EWFlag;
+import org.bdware.sc.crdt.SharableVarState;
+
+public class EWFlagProxy extends SharableVar<EWFlag> {
+    public EWFlagProxy(String varId, String cpId, SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void enable() {
+        if (writerVar != null) {
+            EWFlag delta = writerVar.enable();
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void disable() {
+        if (writerVar != null) {
+            EWFlag delta = writerVar.disable();
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public boolean read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected EWFlag createDeltaCrdt(String nodeId, String varId) {
+        return new EWFlag(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/GCounterProxy.java

@@ -0,0 +1,47 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.counter.GCounter;
+import org.bdware.sc.crdt.SharableVarState;
+
+import java.util.Map;
+
+public class GCounterProxy extends SharableVar<GCounter> {
+
+    public GCounterProxy(String varId, String cpId,
+            SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void inc() {
+        if (writerVar != null) {
+            GCounter delta = writerVar.inc();
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void inc(long var) {
+        if (writerVar != null) {
+            GCounter delta = writerVar.inc(var);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Long read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    public Map<String, Long> getM() {
+        if (readerVar != null) {
+            return readerVar.getM();
+        }
+        return writerVar.getM();
+    }
+
+    @Override
+    protected GCounter createDeltaCrdt(String nodeId, String varId) {
+        return new GCounter(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/GSetProxy.java

@@ -0,0 +1,31 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.set.GSet;
+import org.bdware.sc.crdt.SharableVarState;
+
+import java.util.Set;
+
+public class GSetProxy extends SharableVar<GSet<Object>> {
+    public GSetProxy(String varId, String cpId, SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void add(Object val) {
+        if (writerVar != null) {
+            GSet<Object> delta = writerVar.add(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Set<Object> read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected GSet<Object> createDeltaCrdt(String nodeId, String varId) {
+        return new GSet<>(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/LWWRegisterProxy.java

@@ -0,0 +1,30 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.register.LWWRegister;
+import org.bdware.sc.crdt.SharableVarState;
+
+public class LWWRegisterProxy extends SharableVar<LWWRegister<Long, Object>> {
+    public LWWRegisterProxy(String varId, String cpId,
+            SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void write(Object val) {
+        if (writerVar != null) {
+            LWWRegister<Long, Object> delta = writerVar.write(System.currentTimeMillis(), val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Object read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected LWWRegister<Long, Object> createDeltaCrdt(String nodeId, String varId) {
+        return new LWWRegister<>(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/MVRegisterProxy.java

@@ -0,0 +1,36 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.register.MVRegister;
+import org.bdware.sc.crdt.SharableVarState;
+
+public class MVRegisterProxy extends SharableVar<MVRegister<Object>> {
+
+    public MVRegisterProxy(String varId, String cpId,
+            SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void write(Object val) {
+        if (writerVar != null) {
+            MVRegister<Object> delta = writerVar.write(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void resolve(Object val) {
+        MVRegister<Object> delta = writerVar.resolve();
+        writerVarDeltaQueue.add(delta);
+    }
+
+    public Object read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected MVRegister<Object> createDeltaCrdt(String nodeId, String varId) {
+        return new MVRegister<>(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/PNCounterProxy.java

@@ -0,0 +1,51 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.counter.PNCounter;
+import org.bdware.sc.crdt.SharableVarState;
+
+public class PNCounterProxy extends SharableVar<PNCounter> {
+    public PNCounterProxy(String varId, String cpId,
+            SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void inc() {
+        if (writerVar != null) {
+            PNCounter delta = writerVar.inc();
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void inc(long val) {
+        if (writerVar != null) {
+            PNCounter delta = writerVar.inc(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void dec() {
+        if (writerVar != null) {
+            PNCounter delta = writerVar.dec();
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void dec(long val) {
+        if (writerVar != null) {
+            PNCounter delta = writerVar.dec(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Long read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected PNCounter createDeltaCrdt(String nodeId, String varId) {
+        return new PNCounter(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/RWLWWSetProxy.java

@@ -0,0 +1,39 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.set.RWLWWSet;
+import org.bdware.sc.crdt.SharableVarState;
+
+import java.util.Set;
+
+public class RWLWWSetProxy extends SharableVar<RWLWWSet<Long, Object>> {
+    public RWLWWSetProxy(String varId, String cpId,
+            SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void add(Object val) {
+        if (writerVar != null) {
+            RWLWWSet<Long, Object> delta = writerVar.add(System.currentTimeMillis(), val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void remove(Object val) {
+        if (writerVar != null) {
+            RWLWWSet<Long, Object> delta = writerVar.remove(System.currentTimeMillis(), val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Set<Object> read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected RWLWWSet<Long, Object> createDeltaCrdt(String nodeId, String varId) {
+        return new RWLWWSet<>(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/RWORSetProxy.java

@@ -0,0 +1,38 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.set.RWORSet;
+import org.bdware.sc.crdt.SharableVarState;
+
+import java.util.Set;
+
+public class RWORSetProxy extends SharableVar<RWORSet<Object>> {
+    public RWORSetProxy(String varId, String cpId, SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void add(Object val) {
+        if (writerVar != null) {
+            RWORSet<Object> delta = writerVar.add(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void remove(Object val) {
+        if (writerVar != null) {
+            RWORSet<Object> delta = writerVar.remove(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Set<Object> read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected RWORSet<Object> createDeltaCrdt(String nodeId, String varId) {
+        return new RWORSet<>(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/SharableVar.java

@@ -0,0 +1,146 @@
+package org.bdware.sc.crdt.proxy;
+
+import io.netty.util.HashedWheelTimer;
+import io.netty.util.Timeout;
+import io.netty.util.TimerTask;
+import org.bdware.crdt.basic.JoinableCRDT;
+import org.bdware.sc.crdt.SharableVarManager;
+import org.bdware.sc.crdt.SharableVarState;
+import org.bdware.sc.util.JsonUtil;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public abstract class SharableVar<T extends JoinableCRDT> {
+    // 用于writer节点的变量副本
+    public T writerVar;
+    // 用于reader节点的变量副本
+    public T readerVar;
+
+    public Queue<JoinableCRDT> writerVarDeltaQueue;
+    public Queue<JoinableCRDT> readerVarDeltaQueue;
+
+    public String varId;
+    public SharableVarState sharableVarState;
+
+    public HashedWheelTimer readerTimer;
+    public ReaderSyncTimerTask readerSyncTimerTask;
+    public HashedWheelTimer writerTimer;
+    public WriterSyncTimerTask writerSyncTimerTask;
+
+    public SharableVar(String varId, String cpId,
+            SharableVarState.SharableVarConfiguration resolveResult) {
+        this.varId = varId;
+        this.sharableVarState = new SharableVarState(cpId, resolveResult);
+
+        if (this.sharableVarState.isReaderFlag()) {
+            this.readerVar = createDeltaCrdt(cpId, varId);
+            this.readerVarDeltaQueue = new LinkedList<>();
+            if (this.sharableVarState.getReaderChildren() != null
+                    && this.sharableVarState.getReaderChildren().size() > 0
+                    && this.sharableVarState.getReaderInterval() != null
+                    && this.sharableVarState.getReaderInterval() > 0) {
+                this.readerTimer = new HashedWheelTimer(r -> {
+                    Thread t = Executors.defaultThreadFactory().newThread(r);
+                    t.setDaemon(true);
+                    return t;
+                }, 5, TimeUnit.MILLISECONDS, 2);
+                this.readerTimer.newTimeout(timeout -> {
+                    readerSyncTimerTask = new ReaderSyncTimerTask();
+                    readerTimer.newTimeout(readerSyncTimerTask,
+                            sharableVarState.getReaderInterval(), TimeUnit.SECONDS);
+                }, this.sharableVarState.getReaderInterval(), TimeUnit.SECONDS);
+            }
+        }
+        if (this.sharableVarState.isWriterFlag()) {
+            this.writerVar = createDeltaCrdt(cpId, varId);
+            this.writerVarDeltaQueue = new LinkedList<>();
+            if (this.sharableVarState.getWriteInterval() != null
+                    && this.sharableVarState.getWriteInterval() > 0) {
+                this.writerTimer = new HashedWheelTimer(r -> {
+                    Thread t = Executors.defaultThreadFactory().newThread(r);
+                    t.setDaemon(true);
+                    return t;
+                }, 5, TimeUnit.MILLISECONDS, 2);
+                this.writerTimer.newTimeout(timeout -> {
+                    writerSyncTimerTask = new WriterSyncTimerTask();
+                    writerTimer.newTimeout(writerSyncTimerTask, sharableVarState.getWriteInterval(),
+                            TimeUnit.SECONDS);
+                }, this.sharableVarState.getWriteInterval(), TimeUnit.SECONDS);
+            }
+        }
+    }
+
+    private void syncReaderVar() {
+        if (readerVarDeltaQueue.isEmpty()) {
+            return;
+        }
+        JoinableCRDT joinedDelta = createDeltaCrdt(null, varId);
+        synchronized (readerVarDeltaQueue) {
+            while (!readerVarDeltaQueue.isEmpty()) {
+                JoinableCRDT delta = readerVarDeltaQueue.poll();
+                joinedDelta.join(delta);
+            }
+        }
+        String content = JsonUtil.toJson(joinedDelta);
+        SharableVarManager.instance.broadcastSyncMessage(varId,
+                sharableVarState.getReaderChildren(), content, "r2r");
+    }
+
+    private void syncWriterVar() {
+        if (writerVarDeltaQueue.isEmpty()) {
+            return;
+        }
+        JoinableCRDT joinedDelta = createDeltaCrdt(null, varId);
+        synchronized (writerVarDeltaQueue) {
+            while (!writerVarDeltaQueue.isEmpty()) {
+                JoinableCRDT delta = writerVarDeltaQueue.poll();
+                joinedDelta.join(delta);
+            }
+        }
+        String content = JsonUtil.toJson(joinedDelta);
+        if (sharableVarState.getWriterParent() != null) {
+            // 父节点是Writer
+            SharableVarManager.instance.broadcastSyncMessage(varId,
+                    Collections.singletonList(sharableVarState.getWriterParent()), content, "w2w");
+        } else if (sharableVarState.getReaderRoots() != null) {
+            // 自己是writer根结点 向reader根结点们广播
+            SharableVarManager.instance.broadcastSyncMessage(varId,
+                    sharableVarState.getReaderRoots(), content, "w2r");
+        }
+
+    }
+
+    abstract protected T createDeltaCrdt(String nodeId, String varId);
+
+    class ReaderSyncTimerTask implements TimerTask {
+        @Override
+        public void run(Timeout timeout) throws Exception {
+            try {
+                syncReaderVar();
+            } catch (Exception e) {
+                e.printStackTrace();
+            } finally {
+                readerTimer.newTimeout(readerSyncTimerTask, sharableVarState.getReaderInterval(),
+                        TimeUnit.SECONDS);
+            }
+        }
+    }
+
+    class WriterSyncTimerTask implements TimerTask {
+        @Override
+        public void run(Timeout timeout) throws Exception {
+            try {
+                syncWriterVar();
+            } catch (Exception e) {
+                e.printStackTrace();
+            } finally {
+                writerTimer.newTimeout(writerSyncTimerTask, sharableVarState.getWriteInterval(),
+                        TimeUnit.SECONDS);
+            }
+        }
+    }
+}

src/main/java/org/bdware/sc/crdt/proxy/TPSetProxy.java

@@ -0,0 +1,38 @@
+package org.bdware.sc.crdt.proxy;
+
+import org.bdware.crdt.set.TPSet;
+import org.bdware.sc.crdt.SharableVarState;
+
+import java.util.Set;
+
+public class TPSetProxy extends SharableVar<TPSet<Object>> {
+    public TPSetProxy(String varId, String cpId, SharableVarState.SharableVarConfiguration conf) {
+        super(varId, cpId, conf);
+    }
+
+    public void add(Object val) {
+        if (writerVar != null) {
+            TPSet<Object> delta = writerVar.add(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public void remove(Object val) {
+        if (writerVar != null) {
+            TPSet<Object> delta = writerVar.remove(val);
+            writerVarDeltaQueue.add(delta);
+        }
+    }
+
+    public Set<Object> read() {
+        if (readerVar != null) {
+            return readerVar.read();
+        }
+        return writerVar.read();
+    }
+
+    @Override
+    protected TPSet<Object> createDeltaCrdt(String nodeId, String varId) {
+        return new TPSet<>(nodeId, varId);
+    }
+}

src/main/java/org/bdware/sc/engine/ConfidentialContractUtil.java

@@ -23,23 +23,26 @@ public class ConfidentialContractUtil {
 
     public static final String CONFIDENTIAL_TEMPLATE_PATH = System.getenv("GRAPHENE_DIR")
             + File.separator + "Examples" + File.separator + "nodejs-secret";
-    public static final String CONFIDENTIAL_SCRIPT_PATH = System.getenv("GRAPHENE_DIR")
-            + File.separator + "App";
+    public static final String CONFIDENTIAL_SCRIPT_PATH =
+            System.getenv("GRAPHENE_DIR") + File.separator + "App";
     public static final String[] COMMAND = {"bash", "executeContract.sh"};
-    private static final Type MapType = TypeToken.getParameterized(HashMap.class, String.class, String.class).getType();
+    private static final Type MapType =
+            TypeToken.getParameterized(HashMap.class, String.class, String.class).getType();
 
-    public static String executeConfidentialContract(ContractRequest input) throws IOException, InterruptedException {
+    public static String executeConfidentialContract(ContractRequest input)
+            throws IOException, InterruptedException {
         File runDir = new File(CONFIDENTIAL_SCRIPT_PATH + File.separator + input.getRequestID());
         ProcessBuilder pb = new ProcessBuilder(COMMAND);
         pb.directory(runDir);
         Process p = pb.start();
         p.waitFor();
-        File resultFile = new File(CONFIDENTIAL_SCRIPT_PATH + File.separator + input.getRequestID() +
-                File.separator + "result.json");
+        File resultFile = new File(CONFIDENTIAL_SCRIPT_PATH + File.separator + input.getRequestID()
+                + File.separator + "result.json");
         return FileUtils.readFileToString(resultFile, StandardCharsets.UTF_8);
     }
 
-    public static void generateConfidentialContract(ContractNode cn, ScriptObjectMirror globalVars, Global global) {
+    public static void generateConfidentialContract(ContractNode cn, ScriptObjectMirror globalVars,
+            Global global) {
         List<FunctionNode> functionNodes = cn.getFunctions();
         for (FunctionNode fn : functionNodes) {
             // assuming only one confidential function for now
@@ -54,18 +57,46 @@ public class ConfidentialContractUtil {
                     }
                 }
                 // load necessary Node.js libraries
-                jsStr.append("var fs = require('fs');\n" + "var crypto = require('crypto');\n" + "var sm2 = require('sm-crypto').sm2;\n");
+                jsStr.append("var fs = require('fs');\n" + "var crypto = require('crypto');\n"
+                        + "var sm2 = require('sm-crypto').sm2;\n");
                 // load Global variables and arguments from files
-                jsStr.append("let rawGlobal = fs.readFileSync('global.json').toString();\n" + "let Global = JSON.parse(rawGlobal);\n");
-                jsStr.append("let rawArg = fs.readFileSync('arg.json').toString();\n" + "let jsonArg = JSON.parse(rawArg);\n" + "let requester = jsonArg.requester;\n" + "let arg = jsonArg.arg;\n");
+                jsStr.append("let rawGlobal = fs.readFileSync('global.json').toString();\n"
+                        + "let Global = JSON.parse(rawGlobal);\n");
+                jsStr.append("let rawArg = fs.readFileSync('arg.json').toString();\n"
+                        + "let jsonArg = JSON.parse(rawArg);\n"
+                        + "let requester = jsonArg.requester;\n" + "let arg = jsonArg.arg;\n");
                 jsStr.append("let srcStr = fs.readFileSync('contract.js').toString();\n");
                 // verify signatures and decrypt all confidential variables Important!!!!!
-                jsStr.append("for (var k in Global) {\n" + "  if (Global.hasOwnProperty(k)) {\n" + "    if (k.startsWith('conf_')) {\n" + "      let sig = Global[k].signature;\n" + "      let pubKey = Global[k].owner;\n" + "      let verifyResult = sm2.doVerifySignature(srcStr, sig, pubKey);\n" + "      if (verifyResult) {\n" + "        let newKey = k.substring(5);\n" + "        let decKey = Buffer.from(process.env['KEY_'+pubKey.substring(0,10).toUpperCase()], 'hex');\n" + "        let decIv = Buffer.from(Global[k].iv, 'hex');\n" + "        let cipherText = Buffer.from(Global[k].cipherText, 'hex');\n" + "        let decipher = crypto.createDecipheriv('aes-256-cbc', decKey, decIv);\n" + "        let decrypted = decipher.update(cipherText);\n" + "        decrypted = Buffer.concat([decrypted, decipher.final()]);\n" + "        let plaintext = decrypted.toString();\n" + "        Global[newKey] = plaintext;\n" + "      }\n" + "    }\n" + "  }\n" + "}\n");
+                jsStr.append("for (var k in Global) {\n" + "  if (Global.hasOwnProperty(k)) {\n"
+                        + "    if (k.startsWith('conf_')) {\n"
+                        + "      let sig = Global[k].signature;\n"
+                        + "      let pubKey = Global[k].owner;\n"
+                        + "      let verifyResult = sm2.doVerifySignature(srcStr, sig, pubKey);\n"
+                        + "      if (verifyResult) {\n" + "        let newKey = k.substring(5);\n"
+                        + "        let decKey = Buffer.from(process.env['KEY_'+pubKey.substring(0,10).toUpperCase()], 'hex');\n"
+                        + "        let decIv = Buffer.from(Global[k].iv, 'hex');\n"
+                        + "        let cipherText = Buffer.from(Global[k].cipherText, 'hex');\n"
+                        + "        let decipher = crypto.createDecipheriv('aes-256-cbc', decKey, decIv);\n"
+                        + "        let decrypted = decipher.update(cipherText);\n"
+                        + "        decrypted = Buffer.concat([decrypted, decipher.final()]);\n"
+                        + "        let plaintext = decrypted.toString();\n"
+                        + "        Global[newKey] = plaintext;\n" + "      }\n" + "    }\n"
+                        + "  }\n" + "}\n");
                 // call function
-                jsStr.append("var ret = ").append(fn.functionName).append("(arg, requester, null);\n");
-                // TODO: encrypt all confidential variables so state can be updated in confidential function @shujunyi
+                jsStr.append("var ret = ").append(fn.functionName)
+                        .append("(arg, requester, null);\n");
+                // TODO: encrypt all confidential variables so state can be updated in confidential
+                // function @shujunyi
                 // encrypt return value and write to a file
-                jsStr.append("var retStr = JSON.stringify(ret);\n" + "var key = Buffer.from(process.env['KEY_'+requester.substring(0,10).toUpperCase()], 'hex');\n" + "var iv = crypto.randomBytes(16);\n" + "let cipher = crypto.createCipheriv('aes-256-cbc', key, iv); \n" + "let encRet =  cipher.update(retStr);\n" + "encRet = Buffer.concat([encRet, cipher.final()]);\n" + "let result = {iv: iv.toString('hex'), encryptedData: encRet.toString('hex')};\n" + "let resultStr = JSON.stringify(result);\n" + "fs.writeFileSync('result.json', resultStr);\n");
+                jsStr.append("var retStr = JSON.stringify(ret);\n"
+                        + "var key = Buffer.from(process.env['KEY_'+requester.substring(0,10).toUpperCase()], 'hex');\n"
+                        + "var iv = crypto.randomBytes(16);\n"
+                        + "let cipher = crypto.createCipheriv('aes-256-cbc', key, iv); \n"
+                        + "let encRet =  cipher.update(retStr);\n"
+                        + "encRet = Buffer.concat([encRet, cipher.final()]);\n"
+                        + "let result = {iv: iv.toString('hex'), encryptedData: encRet.toString('hex')};\n"
+                        + "let resultStr = JSON.stringify(result);\n"
+                        + "fs.writeFileSync('result.json', resultStr);\n");
                 // put script into Global so owner can send it and collect signatures
                 Object som = ScriptObjectMirror.wrap(jsStr.toString(), global);
                 globalVars.put("src_" + fn.functionName, som);
@@ -85,11 +116,8 @@ public class ConfidentialContractUtil {
         }
     }
 
-    public static void dumpScriptAndStates(
-            Invocable engine,
-            FunctionNode functionNode,
-            ContractRequest input,
-            ScriptObjectMirror globalVars)
+    public static void dumpScriptAndStates(Invocable engine, FunctionNode functionNode,
+            ContractRequest input, ScriptObjectMirror globalVars)
             throws IOException, ScriptException, NoSuchMethodException {
         Map<String, Object> globalMap = (Map<String, Object>) convertIntoJavaObject(globalVars);
         String dest = CONFIDENTIAL_SCRIPT_PATH + File.separator + input.getRequestID();
@@ -136,156 +164,116 @@ public class ConfidentialContractUtil {
         return dependentFunctions;
     }
 
-    private static String generateGrapheneManifestStr(Invocable engine, ContractRequest input) throws ScriptException, NoSuchMethodException {
-        String manifestStr = "# Nodejs manifest file example\n" +
-                "#\n" +
-                "# This manifest was prepared and tested on Ubuntu 18.04.\n" +
-                "\n" +
-                "loader.argv0_override = \"nodejs\"\n" +
-                "\n" +
-                "# LibOS layer library of Graphene. There is currently only one implementation,\n" +
-                "# so it is always set to libsysdb.so.\n" +
-                "loader.preload = \"file:$(GRAPHENEDIR)/Runtime/libsysdb.so\"\n" +
-                "\n" +
-                "# Show/hide debug log of Graphene ('inline' or 'none' respectively).\n" +
-                "loader.debug_type = \"$(GRAPHENEDEBUG)\"\n" +
-                "\n" +
-                "# Read application arguments directly from the command line. Don't use this on production!\n" +
-                "loader.insecure__use_cmdline_argv = 1\n" +
-                "\n" +
-                "# Specify paths to search for libraries. The usual LD_LIBRARY_PATH syntax\n" +
-                "# applies. Paths must be in-Graphene visible paths, not host-OS paths (i.e.,\n" +
-                "# paths must be taken from fs.mount.xxx.path, not fs.mount.xxx.uri).\n" +
-                "loader.env.LD_LIBRARY_PATH = \"/lib:/usr/lib:$(ARCH_LIBDIR):/usr/$(ARCH_LIBDIR):./\"\n" +
-                "\n" +
-                "# Mount host-OS directory to required libraries (in 'uri') into in-Graphene\n" +
-                "# visible directory /lib (in 'path').\n" +
-                "fs.mount.lib.type = \"chroot\"\n" +
-                "fs.mount.lib.path = \"/lib\"\n" +
-                "fs.mount.lib.uri = \"file:$(GRAPHENEDIR)/Runtime\"\n" +
-                "\n" +
-                "fs.mount.lib2.type = \"chroot\"\n" +
-                "fs.mount.lib2.path = \"$(ARCH_LIBDIR)\"\n" +
-                "fs.mount.lib2.uri = \"file:$(ARCH_LIBDIR)\"\n" +
-                "\n" +
-                "#fs.mount.lib3.type = \"chroot\"\n" +
-                "#fs.mount.lib3.path = \"/usr/$(ARCH_LIBDIR)\"\n" +
-                "#fs.mount.lib3.uri = \"file:/usr/$(ARCH_LIBDIR)\"\n" +
-                "\n" +
-                "fs.mount.usr.type = \"chroot\"\n" +
-                "fs.mount.usr.path = \"/usr\"\n" +
-                "fs.mount.usr.uri = \"file:/usr\"\n" +
-                "\n" +
-                "# Host-level directory to NSS files required by Glibc + NSS libs\n" +
-                "fs.mount.etc.type = \"chroot\"\n" +
-                "fs.mount.etc.path = \"/etc\"\n" +
-                "fs.mount.etc.uri = \"file:/etc\"\n" +
-                "\n" +
-                "# Workload needs to create temporary files\n" +
-                "fs.mount.tmp.type = \"chroot\"\n" +
-                "fs.mount.tmp.path = \"/tmp\"\n" +
-                "fs.mount.tmp.uri = \"file:/tmp\"\n" +
-                "\n" +
-                "# Set enclave size to 2GB; NodeJS expects around 1.7GB of heap on startup,\n" +
-                "# see e.g. https://github.com/nodejs/node/issues/13018.\n" +
-                "# Recall that SGX v1 requires to specify enclave size at enclave creation time.\n" +
-                "sgx.enclave_size = \"2G\"\n" +
-                "\n" +
-                "# Set maximum number of in-enclave threads (somewhat arbitrarily) to 8. Recall\n" +
-                "# that SGX v1 requires to specify the maximum number of simultaneous threads at\n" +
-                "# enclave creation time.\n" +
-                "sgx.thread_num = 16\n" +
-                "\n" +
-                "# Specify all libraries used by Node.js and its dependencies (including all libs\n" +
-                "# which can be loaded at runtime via dlopen).\n" +
-                "sgx.trusted_files.ld = \"file:$(GRAPHENEDIR)/Runtime/ld-linux-x86-64.so.2\"\n" +
-                "sgx.trusted_files.libc = \"file:$(GRAPHENEDIR)/Runtime/libc.so.6\"\n" +
-                "sgx.trusted_files.libm = \"file:$(GRAPHENEDIR)/Runtime/libm.so.6\"\n" +
-                "sgx.trusted_files.libdl = \"file:$(GRAPHENEDIR)/Runtime/libdl.so.2\"\n" +
-                "sgx.trusted_files.librt = \"file:$(GRAPHENEDIR)/Runtime/librt.so.1\"\n" +
-                "sgx.trusted_files.libutil = \"file:$(GRAPHENEDIR)/Runtime/libutil.so.1\"\n" +
-                "sgx.trusted_files.libpthread = \"file:$(GRAPHENEDIR)/Runtime/libpthread.so.0\"\n" +
-                "sgx.trusted_files.libnssdns = \"file:$(GRAPHENEDIR)/Runtime/libnss_dns.so.2\"\n" +
-                "sgx.trusted_files.libresolv = \"file:$(GRAPHENEDIR)/Runtime/libresolv.so.2\"\n" +
-                "\n" +
-                "sgx.trusted_files.libstdc = \"file:/usr/$(ARCH_LIBDIR)/libstdc++.so.6\"\n" +
-                "sgx.trusted_files.libgccs = \"file:$(ARCH_LIBDIR)/libgcc_s.so.1\"\n" +
-                "sgx.trusted_files.libaptpkg = \"file:/usr/$(ARCH_LIBDIR)/libapt-pkg.so.5.0\"\n" +
-                "sgx.trusted_files.liblz4 = \"file:/usr/$(ARCH_LIBDIR)/liblz4.so.1\"\n" +
-                "sgx.trusted_files.libsystemd = \"file:$(ARCH_LIBDIR)/libsystemd.so.0\"\n" +
-                "sgx.trusted_files.libselinux = \"file:$(ARCH_LIBDIR)/libselinux.so.1\"\n" +
-                "sgx.trusted_files.libgcrypt = \"file:$(ARCH_LIBDIR)/libgcrypt.so.20\"\n" +
-                "sgx.trusted_files.libpcre = \"file:$(ARCH_LIBDIR)/libpcre.so.3\"\n" +
-                "sgx.trusted_files.libgpgerror = \"file:$(ARCH_LIBDIR)/libgpg-error.so.0\"\n" +
-                "sgx.trusted_files.libexpat = \"file:$(ARCH_LIBDIR)/libexpat.so.1\"\n" +
-                "sgx.trusted_files.libz = \"file:$(ARCH_LIBDIR)/libz.so.1\"\n" +
-                "sgx.trusted_files.libz2 = \"file:$(ARCH_LIBDIR)/libbz2.so.1.0\"\n" +
-                "sgx.trusted_files.liblzma = \"file:$(ARCH_LIBDIR)/liblzma.so.5\"\n" +
-                "sgx.trusted_files.libmpdec = \"file:/usr/$(ARCH_LIBDIR)/libmpdec.so.2\"\n" +
-                "\n" +
-                "# Name Service Switch (NSS) libraries (Glibc dependencies)\n" +
-                "sgx.trusted_files.libnssfiles = \"file:$(ARCH_LIBDIR)/libnss_files.so.2\"\n" +
-                "sgx.trusted_files.libnsscompat = \"file:$(ARCH_LIBDIR)/libnss_compat.so.2\"\n" +
-                "sgx.trusted_files.libnssnis = \"file:$(ARCH_LIBDIR)/libnss_nis.so.2\"\n" +
-                "sgx.trusted_files.libnsl = \"file:$(ARCH_LIBDIR)/libnsl.so.1\"\n" +
-                "sgx.trusted_files.libnssmyhostname = \"file:$(ARCH_LIBDIR)/libnss_myhostname.so.2\"\n" +
-                "sgx.trusted_files.libnssmdns = \"file:$(ARCH_LIBDIR)/libnss_mdns4_minimal.so.2\"\n" +
-                "\n" +
-                "# Scratch space\n" +
-                "sgx.allowed_files.tmp = \"file:/tmp\"\n" +
-                "\n" +
-                "# APT config files\n" +
-                "sgx.allowed_files.aptconfd = \"file:/etc/apt/apt.conf.d\"\n" +
-                "sgx.allowed_files.aptconf = \"file:/etc/apt/apt.conf\"\n" +
-                "sgx.allowed_files.apport = \"file:/etc/default/apport\"\n" +
-                "\n" +
-                "# Name Service Switch (NSS) files (Glibc reads these files)\n" +
-                "sgx.allowed_files.nsswitch = \"file:/etc/nsswitch.conf\"\n" +
-                "sgx.allowed_files.group = \"file:/etc/group\"\n" +
-                "sgx.allowed_files.passwd = \"file:/etc/passwd\"\n" +
-                "\n" +
-                "# DNS hostname resolution files (Glibc reads these files)\n" +
-                "sgx.allowed_files.hostconf = \"file:/etc/host.conf\"\n" +
-                "sgx.allowed_files.hosts = \"file:/etc/hosts\"\n" +
-                "sgx.allowed_files.gaiconf = \"file:/etc/gai.conf\"\n" +
-                "sgx.allowed_files.resolv = \"file:/etc/resolv.conf\"\n" +
-                "\n" +
-                "sgx.allowed_files.openssl = \"file:/etc/ssl/openssl.cnf\"\n" +
-                "\n" +
-                "# System's file system table\n" +
-                "sgx.allowed_files.fstab = \"file:/etc/fstab\"\n" +
-                "\n" +
-                "$(NODEJS_TRUSTED_LIBS)\n" +
-                "\n" +
-                "# JavaScript (trusted)\n" +
-                "sgx.allowed_files.smlib = \"file:node_modules\"\n" +
-                "sgx.trusted_files.npminfo = \"file:package.json\"\n" +
-                "sgx.trusted_files.contract = \"file:contract.js\"\n" +
-                "sgx.trusted_files.globaljson = \"file:global.json\"\n" +
-                "sgx.trusted_files.argjson = \"file:arg.json\"\n" +
-                "\n" +
-                "sys.insecure__allow_eventfd = 1\n" +
-                "\n" +
-                "sgx.remote_attestation = 1\n" +
-                "\n" +
-                "loader.env.LD_PRELOAD = \"libsecret_prov_attest.so\"\n" +
-                "loader.env.SECRET_PROVISION_CONSTRUCTOR = \"1\"\n" +
-                "loader.env.SECRET_PROVISION_SET_PF_KEY = \"1\"\n" +
-                "loader.env.SECRET_PROVISION_CA_CHAIN_PATH = \"certs/test-ca-sha256.crt\"\n" +
-                "loader.env.SECRET_PROVISION_SERVERS = \"localhost:4433\"\n" +
-                "\n" +
-                "sgx.trusted_files.libsecretprovattest = \"file:libsecret_prov_attest.so\"\n" +
-                "sgx.trusted_files.cachain = \"file:certs/test-ca-sha256.crt\"\n" +
-                "\n" +
-                "# Specify your SPID and linkable/unlinkable attestation policy\n" +
-                "sgx.ra_client_spid = \"DF3A8BA098E93F66CC64E8A215E98333\"\n" +
-                "sgx.ra_client_linkable = 0\n";
+    private static String generateGrapheneManifestStr(Invocable engine, ContractRequest input)
+            throws ScriptException, NoSuchMethodException {
+        String manifestStr = "# Nodejs manifest file example\n" + "#\n"
+                + "# This manifest was prepared and tested on Ubuntu 18.04.\n" + "\n"
+                + "loader.argv0_override = \"nodejs\"\n" + "\n"
+                + "# LibOS layer library of Graphene. There is currently only one implementation,\n"
+                + "# so it is always set to libsysdb.so.\n"
+                + "loader.preload = \"file:$(GRAPHENEDIR)/Runtime/libsysdb.so\"\n" + "\n"
+                + "# Show/hide debug log of Graphene ('inline' or 'none' respectively).\n"
+                + "loader.debug_type = \"$(GRAPHENEDEBUG)\"\n" + "\n"
+                + "# Read application arguments directly from the command line. Don't use this on production!\n"
+                + "loader.insecure__use_cmdline_argv = 1\n" + "\n"
+                + "# Specify paths to search for libraries. The usual LD_LIBRARY_PATH syntax\n"
+                + "# applies. Paths must be in-Graphene visible paths, not host-OS paths (i.e.,\n"
+                + "# paths must be taken from fs.mount.xxx.path, not fs.mount.xxx.uri).\n"
+                + "loader.env.LD_LIBRARY_PATH = \"/lib:/usr/lib:$(ARCH_LIBDIR):/usr/$(ARCH_LIBDIR):./\"\n"
+                + "\n"
+                + "# Mount host-OS directory to required libraries (in 'uri') into in-Graphene\n"
+                + "# visible directory /lib (in 'path').\n" + "fs.mount.lib.type = \"chroot\"\n"
+                + "fs.mount.lib.path = \"/lib\"\n"
+                + "fs.mount.lib.uri = \"file:$(GRAPHENEDIR)/Runtime\"\n" + "\n"
+                + "fs.mount.lib2.type = \"chroot\"\n" + "fs.mount.lib2.path = \"$(ARCH_LIBDIR)\"\n"
+                + "fs.mount.lib2.uri = \"file:$(ARCH_LIBDIR)\"\n" + "\n"
+                + "#fs.mount.lib3.type = \"chroot\"\n"
+                + "#fs.mount.lib3.path = \"/usr/$(ARCH_LIBDIR)\"\n"
+                + "#fs.mount.lib3.uri = \"file:/usr/$(ARCH_LIBDIR)\"\n" + "\n"
+                + "fs.mount.usr.type = \"chroot\"\n" + "fs.mount.usr.path = \"/usr\"\n"
+                + "fs.mount.usr.uri = \"file:/usr\"\n" + "\n"
+                + "# Host-level directory to NSS files required by Glibc + NSS libs\n"
+                + "fs.mount.etc.type = \"chroot\"\n" + "fs.mount.etc.path = \"/etc\"\n"
+                + "fs.mount.etc.uri = \"file:/etc\"\n" + "\n"
+                + "# Workload needs to create temporary files\n"
+                + "fs.mount.tmp.type = \"chroot\"\n" + "fs.mount.tmp.path = \"/tmp\"\n"
+                + "fs.mount.tmp.uri = \"file:/tmp\"\n" + "\n"
+                + "# Set enclave size to 2GB; NodeJS expects around 1.7GB of heap on startup,\n"
+                + "# see e.g. https://github.com/nodejs/node/issues/13018.\n"
+                + "# Recall that SGX v1 requires to specify enclave size at enclave creation time.\n"
+                + "sgx.enclave_size = \"2G\"\n" + "\n"
+                + "# Set maximum number of in-enclave threads (somewhat arbitrarily) to 8. Recall\n"
+                + "# that SGX v1 requires to specify the maximum number of simultaneous threads at\n"
+                + "# enclave creation time.\n" + "sgx.thread_num = 16\n" + "\n"
+                + "# Specify all libraries used by Node.js and its dependencies (including all libs\n"
+                + "# which can be loaded at runtime via dlopen).\n"
+                + "sgx.trusted_files.ld = \"file:$(GRAPHENEDIR)/Runtime/ld-linux-x86-64.so.2\"\n"
+                + "sgx.trusted_files.libc = \"file:$(GRAPHENEDIR)/Runtime/libc.so.6\"\n"
+                + "sgx.trusted_files.libm = \"file:$(GRAPHENEDIR)/Runtime/libm.so.6\"\n"
+                + "sgx.trusted_files.libdl = \"file:$(GRAPHENEDIR)/Runtime/libdl.so.2\"\n"
+                + "sgx.trusted_files.librt = \"file:$(GRAPHENEDIR)/Runtime/librt.so.1\"\n"
+                + "sgx.trusted_files.libutil = \"file:$(GRAPHENEDIR)/Runtime/libutil.so.1\"\n"
+                + "sgx.trusted_files.libpthread = \"file:$(GRAPHENEDIR)/Runtime/libpthread.so.0\"\n"
+                + "sgx.trusted_files.libnssdns = \"file:$(GRAPHENEDIR)/Runtime/libnss_dns.so.2\"\n"
+                + "sgx.trusted_files.libresolv = \"file:$(GRAPHENEDIR)/Runtime/libresolv.so.2\"\n"
+                + "\n" + "sgx.trusted_files.libstdc = \"file:/usr/$(ARCH_LIBDIR)/libstdc++.so.6\"\n"
+                + "sgx.trusted_files.libgccs = \"file:$(ARCH_LIBDIR)/libgcc_s.so.1\"\n"
+                + "sgx.trusted_files.libaptpkg = \"file:/usr/$(ARCH_LIBDIR)/libapt-pkg.so.5.0\"\n"
+                + "sgx.trusted_files.liblz4 = \"file:/usr/$(ARCH_LIBDIR)/liblz4.so.1\"\n"
+                + "sgx.trusted_files.libsystemd = \"file:$(ARCH_LIBDIR)/libsystemd.so.0\"\n"
+                + "sgx.trusted_files.libselinux = \"file:$(ARCH_LIBDIR)/libselinux.so.1\"\n"
+                + "sgx.trusted_files.libgcrypt = \"file:$(ARCH_LIBDIR)/libgcrypt.so.20\"\n"
+                + "sgx.trusted_files.libpcre = \"file:$(ARCH_LIBDIR)/libpcre.so.3\"\n"
+                + "sgx.trusted_files.libgpgerror = \"file:$(ARCH_LIBDIR)/libgpg-error.so.0\"\n"
+                + "sgx.trusted_files.libexpat = \"file:$(ARCH_LIBDIR)/libexpat.so.1\"\n"
+                + "sgx.trusted_files.libz = \"file:$(ARCH_LIBDIR)/libz.so.1\"\n"
+                + "sgx.trusted_files.libz2 = \"file:$(ARCH_LIBDIR)/libbz2.so.1.0\"\n"
+                + "sgx.trusted_files.liblzma = \"file:$(ARCH_LIBDIR)/liblzma.so.5\"\n"
+                + "sgx.trusted_files.libmpdec = \"file:/usr/$(ARCH_LIBDIR)/libmpdec.so.2\"\n" + "\n"
+                + "# Name Service Switch (NSS) libraries (Glibc dependencies)\n"
+                + "sgx.trusted_files.libnssfiles = \"file:$(ARCH_LIBDIR)/libnss_files.so.2\"\n"
+                + "sgx.trusted_files.libnsscompat = \"file:$(ARCH_LIBDIR)/libnss_compat.so.2\"\n"
+                + "sgx.trusted_files.libnssnis = \"file:$(ARCH_LIBDIR)/libnss_nis.so.2\"\n"
+                + "sgx.trusted_files.libnsl = \"file:$(ARCH_LIBDIR)/libnsl.so.1\"\n"
+                + "sgx.trusted_files.libnssmyhostname = \"file:$(ARCH_LIBDIR)/libnss_myhostname.so.2\"\n"
+                + "sgx.trusted_files.libnssmdns = \"file:$(ARCH_LIBDIR)/libnss_mdns4_minimal.so.2\"\n"
+                + "\n" + "# Scratch space\n" + "sgx.allowed_files.tmp = \"file:/tmp\"\n" + "\n"
+                + "# APT config files\n"
+                + "sgx.allowed_files.aptconfd = \"file:/etc/apt/apt.conf.d\"\n"
+                + "sgx.allowed_files.aptconf = \"file:/etc/apt/apt.conf\"\n"
+                + "sgx.allowed_files.apport = \"file:/etc/default/apport\"\n" + "\n"
+                + "# Name Service Switch (NSS) files (Glibc reads these files)\n"
+                + "sgx.allowed_files.nsswitch = \"file:/etc/nsswitch.conf\"\n"
+                + "sgx.allowed_files.group = \"file:/etc/group\"\n"
+                + "sgx.allowed_files.passwd = \"file:/etc/passwd\"\n" + "\n"
+                + "# DNS hostname resolution files (Glibc reads these files)\n"
+                + "sgx.allowed_files.hostconf = \"file:/etc/host.conf\"\n"
+                + "sgx.allowed_files.hosts = \"file:/etc/hosts\"\n"
+                + "sgx.allowed_files.gaiconf = \"file:/etc/gai.conf\"\n"
+                + "sgx.allowed_files.resolv = \"file:/etc/resolv.conf\"\n" + "\n"
+                + "sgx.allowed_files.openssl = \"file:/etc/ssl/openssl.cnf\"\n" + "\n"
+                + "# System's file system table\n"
+                + "sgx.allowed_files.fstab = \"file:/etc/fstab\"\n" + "\n"
+                + "$(NODEJS_TRUSTED_LIBS)\n" + "\n" + "# JavaScript (trusted)\n"
+                + "sgx.allowed_files.smlib = \"file:node_modules\"\n"
+                + "sgx.trusted_files.npminfo = \"file:package.json\"\n"
+                + "sgx.trusted_files.contract = \"file:contract.js\"\n"
+                + "sgx.trusted_files.globaljson = \"file:global.json\"\n"
+                + "sgx.trusted_files.argjson = \"file:arg.json\"\n" + "\n"
+                + "sys.insecure__allow_eventfd = 1\n" + "\n" + "sgx.remote_attestation = 1\n" + "\n"
+                + "loader.env.LD_PRELOAD = \"libsecret_prov_attest.so\"\n"
+                + "loader.env.SECRET_PROVISION_CONSTRUCTOR = \"1\"\n"
+                + "loader.env.SECRET_PROVISION_SET_PF_KEY = \"1\"\n"
+                + "loader.env.SECRET_PROVISION_CA_CHAIN_PATH = \"certs/test-ca-sha256.crt\"\n"
+                + "loader.env.SECRET_PROVISION_SERVERS = \"localhost:4433\"\n" + "\n"
+                + "sgx.trusted_files.libsecretprovattest = \"file:libsecret_prov_attest.so\"\n"
+                + "sgx.trusted_files.cachain = \"file:certs/test-ca-sha256.crt\"\n" + "\n"
+                + "# Specify your SPID and linkable/unlinkable attestation policy\n"
+                + "sgx.ra_client_spid = \"DF3A8BA098E93F66CC64E8A215E98333\"\n"
+                + "sgx.ra_client_linkable = 0\n";
         // add secret servers
         manifestStr += "loader.env.SECRET_PROVISION_CC_SERVERS = ";
-        Object resultStr = engine.invokeFunction(
-                "getAllSecret",
-                "",
-                input.getRequester(),
+        Object resultStr = engine.invokeFunction("getAllSecret", "", input.getRequester(),
                 input.getRequesterDOI());
         Map<String, String> resultMap = JsonUtil.fromJson(resultStr.toString(), MapType);
         Map<String, String> serverMap = JsonUtil.fromJson(resultMap.get("result"), MapType);

src/main/java/org/bdware/sc/engine/DesktopEngine.java

@@ -1,6 +1,5 @@
 package org.bdware.sc.engine;
 
-import com.google.gson.JsonElement;
 import com.google.gson.JsonPrimitive;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.logging.log4j.LogManager;
@@ -52,18 +51,18 @@ public class DesktopEngine extends JSEngine {
     private static final String ScriptFileName = "contract_main.yjs";
     private static final Logger LOGGER = LogManager.getLogger(DesktopEngine.class);
     public static boolean _with_init_script = true;
-    //    static String script = "";
+    // static String script = "";
     public NashornScriptEngine engine;
     public SyncMechUtil syncUtil;
     public boolean recovering; // 如果正在通过trace、trans恢复，设置为true，此时即使是StableMode也不记录
     Resources resources;
-    //    Class<?> clz;
-    //    byte[] stub;
+    // Class<?> clz;
+    // byte[] stub;
     YJSClassLoader classLoader;
     private ContractNode cn;
     private Global global;
-    //    private Object obj;
-    //    private SimpleScriptContext simpleContext;
+    // private Object obj;
+    // private SimpleScriptContext simpleContext;
     // private String traceDir;
     private ContractProcess.Logger tracePS = null;
     private Contract contract;
@@ -137,37 +136,28 @@ public class DesktopEngine extends JSEngine {
             syncUtil = new SyncMechUtil(this);
             ClassLoader ccl = Thread.currentThread().getContextClassLoader();
             ccl = (ccl == null) ? NashornScriptEngineFactory.class.getClassLoader() : ccl;
-            String[] args = new String[]{"--loader-per-compile=false", "-strict=false"};
+            String[] args = new String[] {"--loader-per-compile=false", "-strict=false"};
             classLoader = new YJSClassLoader(ccl, new YJSFilter());
-            engine =
-                    (NashornScriptEngine)
-                            new NashornScriptEngineFactory()
-                                    .getScriptEngine(
-                                            args, // "--print-ast",
-                                            // "true",
-                                            // "-d=/Users/huaqiancai/Downloads/dumpedClz",
-                                            // "--trace-callsites=enterexit"
-                                            // "--log=methodhandles:all",
-                                            // fields:all,
-                                            // "--print-parse", "true" "--print-code",
-                                            // fields:finest
-                                            classLoader);
+            engine = (NashornScriptEngine) new NashornScriptEngineFactory().getScriptEngine(args, // "--print-ast",
+                    // "true",
+                    // "-d=/Users/huaqiancai/Downloads/dumpedClz",
+                    // "--trace-callsites=enterexit"
+                    // "--log=methodhandles:all",
+                    // fields:all,
+                    // "--print-parse", "true" "--print-code",
+                    // fields:finest
+                    classLoader);
 
             Context.TRACEIF = false;
             // engine = (NashornScriptEngine) new
             // NashornScriptEngineFactory().getScriptEngine(new YJSFilter());
             if (_with_init_script) {
-                InputStream in =
-                        DesktopEngine.class
-                                .getClassLoader()
-                                .getResourceAsStream("org/bdware/sc/engine/yancloud_desktop.js");
+                InputStream in = DesktopEngine.class.getClassLoader()
+                        .getResourceAsStream("org/bdware/sc/engine/yancloud_desktop.js");
                 assert in != null;
                 InputStreamReader streamReader = new InputStreamReader(in);
-                engine.getContext()
-                        .setAttribute(
-                                ScriptEngine.FILENAME,
-                                "org/bdware/sc/engine/yancloud_desktop.js",
-                                ScriptContext.ENGINE_SCOPE);
+                engine.getContext().setAttribute(ScriptEngine.FILENAME,
+                        "org/bdware/sc/engine/yancloud_desktop.js", ScriptContext.ENGINE_SCOPE);
                 engine.eval(streamReader);
             }
             global = engine.getNashornGlobal();
@@ -194,12 +184,9 @@ public class DesktopEngine extends JSEngine {
             for (String str : permissionStub) {
                 yancloud_desktop.append(UtilRegistry.getInitStr(str, false));
             }
-            //            LOGGER.debug("[initScript] " + yancloud_desktop);
-            engine.getContext()
-                    .setAttribute(
-                            ScriptEngine.FILENAME,
-                            yancloud_desktop.toString(),
-                            ScriptContext.ENGINE_SCOPE);
+            // LOGGER.debug("[initScript] " + yancloud_desktop);
+            engine.getContext().setAttribute(ScriptEngine.FILENAME, yancloud_desktop.toString(),
+                    ScriptContext.ENGINE_SCOPE);
             engine.eval(yancloud_desktop.toString());
         } catch (ScriptException e) {
             e.printStackTrace();
@@ -211,14 +198,14 @@ public class DesktopEngine extends JSEngine {
         ScriptLoader loader = engine.getNashornContext().getScriptLoader();
         Map<String, byte[]> clzCache = loader.getClzCache();
         Map<String, byte[]> ret = new HashMap<>(clzCache);
-        //        for (String str : clzCache.keySet()) {
-        //            System.out.println("===ScriptClzName:" + str);
-        //        }
+        // for (String str : clzCache.keySet()) {
+        // System.out.println("===ScriptClzName:" + str);
+        // }
         StructureLoader sLoader = (StructureLoader) (engine.getNashornContext().getStructLoader());
         clzCache = sLoader.getClzCache();
-        //        for (String str : clzCache.keySet()) {
-        //            System.out.println("===StructureClzName:" + str);
-        //        }
+        // for (String str : clzCache.keySet()) {
+        // System.out.println("===StructureClzName:" + str);
+        // }
         ret.putAll(clzCache);
         return ret;
     }
@@ -252,25 +239,26 @@ public class DesktopEngine extends JSEngine {
     }
 
     @Override
-    public ContractResult loadContract(
-            Contract contract, ContractNode contractNode, boolean isInsnLimit) {
+    public ContractResult loadContract(Contract contract, ContractNode contractNode,
+            boolean isInsnLimit) {
         cn = contractNode;
-        engine.getContext()
-                .setAttribute(ScriptEngine.FILENAME, ScriptFileName, ScriptContext.ENGINE_SCOPE);
+        engine.getContext().setAttribute(ScriptEngine.FILENAME, ScriptFileName,
+                ScriptContext.ENGINE_SCOPE);
         try {
             setPermission(cn.getPermission());
         } catch (Exception e) {
             e.printStackTrace();
         }
-
+        for (SharableNode sharable : contractNode.getSharables()) {
+            for (String variableStatement : sharable.getVariableStatements()) {
+                compileSharable(sharable, variableStatement);
+            }
+        }
         for (FunctionNode fun : contractNode.getFunctions())
             try {
                 String str = fun.plainText();
-                engine.getContext()
-                        .setAttribute(
-                                ScriptEngine.FILENAME,
-                                fun.getFileName(),
-                                ScriptContext.ENGINE_SCOPE);
+                engine.getContext().setAttribute(ScriptEngine.FILENAME, fun.getFileName(),
+                        ScriptContext.ENGINE_SCOPE);
                 compileFunction(fun, str, isInsnLimit);
             } catch (ScriptException e) {
                 return wrapperException(e, fun);
@@ -280,7 +268,8 @@ public class DesktopEngine extends JSEngine {
                 e.printStackTrace();
                 return new ContractResult(Status.Error, new JsonPrimitive(bo.toString()));
             }
-        LOGGER.debug(JsonUtil.toJson(contractNode.events) + "\n\t" + JsonUtil.toJson(contractNode.logs));
+        LOGGER.debug(
+                JsonUtil.toJson(contractNode.events) + "\n\t" + JsonUtil.toJson(contractNode.logs));
         for (String topic : contractNode.events.keySet()) {
             compileEventFunction(topic, topic, contractNode.events.get(topic));
         }
@@ -307,26 +296,33 @@ public class DesktopEngine extends JSEngine {
         return cResult;
     }
 
+    private void compileSharable(SharableNode sharable, String variableStatement) {
+        try {
+            engine.getContext().setAttribute(ScriptEngine.FILENAME, sharable.getFileName(),
+                    ScriptContext.ENGINE_SCOPE);
+            engine.eval("var " + variableStatement);
+            LOGGER.info("load sharable: " + variableStatement);
+        } catch (ScriptException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     private void compileEventFunction(String name, String topic, REventSemantics semantics) {
         try {
             String str;
             if (REventSemantics.AT_LEAST_ONCE.equals(semantics)) {
-                str =
-                        String.format(
-                                "function %s(arg) { YancloudUtil.pubEvent(\"%s\", arg); }",
-                                name, topic);
+                str = String.format("function %s(arg) { YancloudUtil.pubEvent(\"%s\", arg); }",
+                        name, topic);
             } else {
-                str =
-                        String.format(
-                                "function %s(arg) { YancloudUtil.pubEventConstraint(\"%s\", arg, \"%s\"); }",
-                                name, topic, semantics.name());
+                str = String.format(
+                        "function %s(arg) { YancloudUtil.pubEventConstraint(\"%s\", arg, \"%s\"); }",
+                        name, topic, semantics.name());
             }
             compileFunction(null, str, false);
             LOGGER.debug("compile function " + name + " success!");
-            str =
-                    String.format(
-                            "function %ss(arg0, arg1) { YancloudUtil.pubEventConstraint(\"%s\", arg0, arg1); }",
-                            name, topic);
+            str = String.format(
+                    "function %ss(arg0, arg1) { YancloudUtil.pubEventConstraint(\"%s\", arg0, arg1); }",
+                    name, topic);
             compileFunction(null, str, false);
             LOGGER.debug("compile function " + name + "s success!");
         } catch (ScriptException e) {
@@ -334,79 +330,80 @@ public class DesktopEngine extends JSEngine {
         }
     }
 
-    //    /**
-    //     * Load a contract into contract engine
-    //     *
-    //     * @param contractNode a contract node generated by YJS compiler
-    //     * @return whether contract is loaded successfully
-    //     */
-    //    @Override
-    //    public ContractResult loadContract(Contract contract, ContractNode contractNode) {
-    //        cn = contractNode;
-    //        engine.getContext()
-    //                .setAttribute(ScriptEngine.FILENAME, ScriptFileName,
+    // /**
+    // * Load a contract into contract engine
+    // *
+    // * @param contractNode a contract node generated by YJS compiler
+    // * @return whether contract is loaded successfully
+    // */
+    // @Override
+    // public ContractResult loadContract(Contract contract, ContractNode contractNode) {
+    // cn = contractNode;
+    // engine.getContext()
+    // .setAttribute(ScriptEngine.FILENAME, ScriptFileName,
     // ScriptContext.ENGINE_SCOPE);
-    //        try {
-    //            setPermission(cn.getPermission());
-    //        } catch (Exception e) {
-    //            e.printStackTrace();
-    //        }
+    // try {
+    // setPermission(cn.getPermission());
+    // } catch (Exception e) {
+    // e.printStackTrace();
+    // }
     //
-    //        for (FunctionNode fun : cn.getFunctions()) {
-    //            try {
-    //                String str = fun.plainText();
-    //                engine.getContext()
-    //                        .setAttribute(
-    //                                ScriptEngine.FILENAME,
-    //                                fun.getFileName(),
-    //                                ScriptContext.ENGINE_SCOPE);
-    //                Object scriptFunction = engine.eval(str);
-    //                ScriptObjectMirror sf = (ScriptObjectMirror) scriptFunction;
-    //                compileFunction(sf, fun.getLogTypes().contains(LogType.Branch));
-    //            } catch (ScriptException e) {
-    //                return wrapperException(e, fun);
-    //            } catch (Exception e) {
-    //                ByteArrayOutputStream bo = new ByteArrayOutputStream();
-    //                e.printStackTrace(new PrintStream(bo));
-    //                e.printStackTrace();
-    //                return new ContractResult(Status.Error, new JsonPrimitive(bo.toString()));
-    //            }
-    //        }
-    //        for (String event : cn.events) {
-    //            String str =
-    //                    "function "
-    //                            + event
-    //                            + "(arg){ return YancloudUtil.pubEvent(\""
-    //                            + event
-    //                            + "\",arg);}";
+    // for (FunctionNode fun : cn.getFunctions()) {
+    // try {
+    // String str = fun.plainText();
+    // engine.getContext()
+    // .setAttribute(
+    // ScriptEngine.FILENAME,
+    // fun.getFileName(),
+    // ScriptContext.ENGINE_SCOPE);
+    // Object scriptFunction = engine.eval(str);
+    // ScriptObjectMirror sf = (ScriptObjectMirror) scriptFunction;
+    // compileFunction(sf, fun.getLogTypes().contains(LogType.Branch));
+    // } catch (ScriptException e) {
+    // return wrapperException(e, fun);
+    // } catch (Exception e) {
+    // ByteArrayOutputStream bo = new ByteArrayOutputStream();
+    // e.printStackTrace(new PrintStream(bo));
+    // e.printStackTrace();
+    // return new ContractResult(Status.Error, new JsonPrimitive(bo.toString()));
+    // }
+    // }
+    // for (String event : cn.events) {
+    // String str =
+    // "function "
+    // + event
+    // + "(arg){ return YancloudUtil.pubEvent(\""
+    // + event
+    // + "\",arg);}";
     //
-    //            try {
-    //                Object scriptFunction = engine.eval(str);
-    //                ScriptObjectMirror sf = (ScriptObjectMirror) scriptFunction;
-    //                compileFunction(sf, false);
-    //            } catch (ScriptException e) {
-    //                e.printStackTrace();
-    //            }
-    //        }
+    // try {
+    // Object scriptFunction = engine.eval(str);
+    // ScriptObjectMirror sf = (ScriptObjectMirror) scriptFunction;
+    // compileFunction(sf, false);
+    // } catch (ScriptException e) {
+    // e.printStackTrace();
+    // }
+    // }
     //
-    //        for (ClassNode classNode : cn.getClzs()) {
-    //            try {
-    //                System.out.println(classNode.plainText());
-    //                // engine.eval(cn.plainText());
-    //            } catch (Exception e) {
-    //                // return wrapperException(e, cn.getFileName(), cn.getLine(),
-    //                // cn.getPos());
-    //            }
-    //        }
+    // for (ClassNode classNode : cn.getClzs()) {
+    // try {
+    // System.out.println(classNode.plainText());
+    // // engine.eval(cn.plainText());
+    // } catch (Exception e) {
+    // // return wrapperException(e, cn.getFileName(), cn.getLine(),
+    // // cn.getPos());
+    // }
+    // }
     //
-    //        // dump confidential functions and corresponding dependent functions to a String in
+    // // dump confidential functions and corresponding dependent functions to a String in
     // Global
-    //        // variable.
-    //        // The String will be passed to collect signature.
+    // // variable.
+    // // The String will be passed to collect signature.
     //
-    //        return new ContractResult(Status.Success, new JsonPrimitive(""));
-    //    }
-    private void compileFunction(FunctionNode functionNode, ScriptObjectMirror sf, boolean instrumentBranch) {
+    // return new ContractResult(Status.Success, new JsonPrimitive(""));
+    // }
+    private void compileFunction(FunctionNode functionNode, ScriptObjectMirror sf,
+            boolean instrumentBranch) {
         Global oldGlobal = Context.getGlobal();
         boolean globalChanged = (oldGlobal != global);
         try {
@@ -423,7 +420,8 @@ public class DesktopEngine extends JSEngine {
             f.setAccessible(true);
             ScriptFunctionData scriptFunctioNData = (ScriptFunctionData) f.get(scriptFunction);
             Object scope = scriptFunction.getScope();
-            Method getGeneric = ScriptFunctionData.class.getDeclaredMethod("getGenericInvoker", ScriptObject.class);
+            Method getGeneric = ScriptFunctionData.class.getDeclaredMethod("getGenericInvoker",
+                    ScriptObject.class);
             getGeneric.setAccessible(true);
             MethodHandle methodHandle = (MethodHandle) getGeneric.invoke(scriptFunctioNData, scope);
             if (methodHandle.getClass() != Class.forName("java.lang.invoke.DirectMethodHandle")) {
@@ -441,17 +439,19 @@ public class DesktopEngine extends JSEngine {
             Class clazz2 = (Class) clazz.get(memberName);
             if (functionNode != null)
                 functionNode.compiledClazz = clazz2;
-            //functionNode==null --> event functions
+            // functionNode==null --> event functions
         } catch (Exception e) {
 
             e.printStackTrace();
         } finally {
-            if (globalChanged) Context.setGlobal(oldGlobal);
+            if (globalChanged)
+                Context.setGlobal(oldGlobal);
             Context.TRACEIF = false;
         }
     }
 
-    public void compileFunction(FunctionNode functionNode, String snippet, boolean instrumentBranch) throws ScriptException {
+    public void compileFunction(FunctionNode functionNode, String snippet, boolean instrumentBranch)
+            throws ScriptException {
         compileFunction(functionNode, (ScriptObjectMirror) engine.eval(snippet), instrumentBranch);
     }
 
@@ -481,8 +481,7 @@ public class DesktopEngine extends JSEngine {
         JavaScriptEntry.msgList = new ArrayList<>();
         FunctionNode fun = cn.getFunction(input.getAction());
         if (fun == null) {
-            return new ContractResult(
-                    Status.Exception,
+            return new ContractResult(Status.Exception,
                     new JsonPrimitive("Action " + input.getAction() + " is not exists"));
         }
         ProgramPointCounter ppc = null;
@@ -499,23 +498,14 @@ public class DesktopEngine extends JSEngine {
                 HashMap<String, Long> ppCountMap = evaluatesAnalysis(input.getAction(), functions);
                 Long extraGas = getExtraGas(fun.getCost().getExtraGas(), input);
                 bo = new ByteArrayOutputStream();
-                ppc =
-                        new ProgramPointCounter(
-                                bo,
-                                previous.getCp(),
-                                Long.MAX_VALUE,
-                                functionIndex,
-                                input.getGasLimit(),
-                                extraGas,
-                                input.getAction(),
-                                ppCountMap);
+                ppc = new ProgramPointCounter(bo, previous.getCp(), Long.MAX_VALUE, functionIndex,
+                        input.getGasLimit(), extraGas, input.getAction(), ppCountMap);
                 this.redirectTracePS(ppc);
             }
             if (fun.isExport() ||
-                    // if the function has been registered as event handler
-                    (fun.isHandler() &&
-                            null != input.getRequester() &&
-                            input.getRequester().startsWith("event"))) {
+            // if the function has been registered as event handler
+                    (fun.isHandler() && null != input.getRequester()
+                            && input.getRequester().startsWith("event"))) {
                 Object ret;
                 if (fun.isView()) {
                     ret = executeWithoutLock(fun, input, null);
@@ -525,8 +515,10 @@ public class DesktopEngine extends JSEngine {
 
                     }
                 }
-                //System.out.println("[DesktopEngine MaskConfig]"+ContractProcess.instance.getProjectConfig().getMaskConfig().config.toString());
-                ContractResult contractRes = new ContractResult(Status.Success, (JsonElement) ret);
+                // System.out.println("[DesktopEngine
+                // MaskConfig]"+ContractProcess.instance.getProjectConfig().getMaskConfig().config.toString());
+                ContractResult contractRes =
+                        new ContractResult(Status.Success, JSONTool.convertMirrorToJson(ret));
                 if (ppc != null) {
                     contractRes.extraGas = ppc.extraGas;
                     contractRes.executionGas = ppc.cost;
@@ -553,10 +545,10 @@ public class DesktopEngine extends JSEngine {
                 if (syncUtil.startFlag && !recovering) {
                     switch (syncUtil.currType) {
                         case Trace:
-                            //  syncUtil.traceRecordUtil.eachFinish();
+                            // syncUtil.traceRecordUtil.eachFinish();
                             break;
                         case Trans:
-                            //    syncUtil.transRecordUtil.eachFinish();
+                            // syncUtil.transRecordUtil.eachFinish();
                             break;
                         case Memory:
                         default:
@@ -568,48 +560,42 @@ public class DesktopEngine extends JSEngine {
             } else {
                 // return new ContractResult(Status.Exception, "Action " + input.getAction() + "
                 // is not exported!");
-                return new ContractResult(
-                        Status.Exception,
+                return new ContractResult(Status.Exception,
                         new JsonPrimitive("Action " + input.getAction() + " is not exported!"));
             }
 
         } catch (ScriptReturnException e) {
             e.printStackTrace();
-            return new ContractResult(
-                    Status.Exception,
-                    e.message);
+            return new ContractResult(Status.Exception, e.message);
         } catch (ScriptException e) {
             Throwable cause = e.getCause();
             e.printStackTrace();
-            return new ContractResult(
-                    Status.Exception,
-                    new JsonPrimitive(extractException(e.getMessage(), extract(cn, cause))));
+            return wrapperException(e, fun);
         } catch (Throwable e) {
             ByteArrayOutputStream bo1 = new ByteArrayOutputStream();
             PrintStream ps = new PrintStream(bo1);
             e.printStackTrace(ps);
             e.printStackTrace();
             if (e.getCause() != null && e.getCause() instanceof ScriptException) {
-                return new ContractResult(
-                        Status.Exception,
-                        new JsonPrimitive(
-                                extractException(bo1.toString(), extract(cn, e.getCause()))));
+                return new ContractResult(Status.Exception, new JsonPrimitive(
+                        extractException(bo1.toString(), extract(cn, e.getCause()))));
             } else {
-                return new ContractResult(
-                        Status.Exception,
+                return new ContractResult(Status.Exception,
                         new JsonPrimitive(extractException(bo1.toString(), extract(cn, e))));
             }
         } finally {
             this.redirectTracePS(previous);
-            if (globalChanged) Context.setGlobal(oldGlobal);
+            if (globalChanged)
+                Context.setGlobal(oldGlobal);
         }
 
     }
 
-    public Object executeWithoutLock(FunctionNode fun, ContractRequest input, Object injectedArg) throws ScriptException, NoSuchMethodException {
-        //              long start = System.currentTimeMillis();
+    public Object executeWithoutLock(FunctionNode fun, ContractRequest input, Object injectedArg)
+            throws ScriptException, NoSuchMethodException {
+        // long start = System.currentTimeMillis();
         ArgPacks argPacks = new ArgPacks(input, input.getArg(), null);
-        if(injectedArg != null) {
+        if (injectedArg != null) {
             argPacks.arg = injectedArg;
         }
         for (AnnotationHook handler : fun.beforeExecutionAnnotations()) {
@@ -618,19 +604,15 @@ public class DesktopEngine extends JSEngine {
 
         // actually invoke!
         if (argPacks.ret == null) {
-            argPacks.ret =
-                    engine.invokeFunction(
-                            input.getAction(),
-                            (fun.isHandler()
-                                    ? JsonUtil.fromJson(input.getArg(), Event.class)
-                                    : JSONTool.convertJsonElementToMirror(argPacks.arg)),
-                            input.getRequester(),
-                            input.getRequesterDOI());
+            argPacks.ret = engine.invokeFunction(input.getAction(),
+                    (fun.isHandler() ? JsonUtil.fromJson(input.getArg(), Event.class)
+                            : JSONTool.convertJsonElementToMirror(argPacks.arg)),
+                    input.getRequester(), input.getRequesterDOI());
         }
 
         for (AnnotationHook handler : fun.afterExecutionAnnotations()) {
-            //Mask在after裏面
-            //System.out.println("afterHook"+contract.Mask);
+            // Mask在after裏面
+            // System.out.println("afterHook"+contract.Mask);
             argPacks = handler.handle(this, argPacks);
         }
         return argPacks.ret;
@@ -663,13 +645,12 @@ public class DesktopEngine extends JSEngine {
         for (String function : functions) {
             MethodNode mn = methods.get(function);
             if (mn != null) {
-                CFGraph cfg =
-                        new CFGraph(mn) {
-                            @Override
-                            public BasicBlock getBasicBlock(int id) {
-                                return new BasicBlock(id);
-                            }
-                        };
+                CFGraph cfg = new CFGraph(mn) {
+                    @Override
+                    public BasicBlock getBasicBlock(int id) {
+                        return new BasicBlock(id);
+                    }
+                };
                 // cfg.printSelf();
                 CFGmap.put(function, cfg);
                 PPCount countFee = new PPCount(cfg, flag);
@@ -688,15 +669,15 @@ public class DesktopEngine extends JSEngine {
                 flag++;
             }
         }
-        /*        for (Map.Entry<String, Long> map : PPCount.functionSumGas.entrySet()) {
-            if (map.getKey().contains(getFunction) && map.getKey().contains("true")) {
-                System.out.println("[合约方法pub中条件循环为true时：]" + map.getValue());
-            } else if (map.getKey().contains(getFunction) && map.getKey().contains("false")) {
-                System.out.println("[合约方法pub中条件循环为false时：]" + map.getValue());
-            } else if (map.getKey().contains(getFunction)) {
-                System.out.println("[合约方法pub中其他语句消耗：]" + map.getValue());
-            }
-        }*/
+        /*
+         * for (Map.Entry<String, Long> map : PPCount.functionSumGas.entrySet()) { if
+         * (map.getKey().contains(getFunction) && map.getKey().contains("true")) {
+         * System.out.println("[合约方法pub中条件循环为true时：]" + map.getValue()); } else if
+         * (map.getKey().contains(getFunction) && map.getKey().contains("false")) {
+         * System.out.println("[合约方法pub中条件循环为false时：]" + map.getValue()); } else if
+         * (map.getKey().contains(getFunction)) { System.out.println("[合约方法pub中其他语句消耗：]" +
+         * map.getValue()); } }
+         */
         return ppCountMap;
     }
 
@@ -706,12 +687,8 @@ public class DesktopEngine extends JSEngine {
             return 0L;
         }
         Invocable cal = engine;
-        Object ret =
-                cal.invokeFunction(
-                        costFunction,
-                        input.getArg(),
-                        input.getRequester(),
-                        input.getRequesterDOI());
+        Object ret = cal.invokeFunction(costFunction, input.getArg(), input.getRequester(),
+                input.getRequesterDOI());
         if (ret != null && StringUtils.isNumeric(ret.toString())) {
             return Long.parseLong(ret.toString());
         } else {
@@ -767,15 +744,16 @@ public class DesktopEngine extends JSEngine {
         if (actLine != -1) {
             actLine += line - 1;
         }
-        message =
-                message.replaceAll(
-                        "at line number " + e.getLineNumber(), "at line number " + (actLine));
+        message = message.replaceAll("at line number " + e.getLineNumber(),
+                "at line number " + (actLine));
         if (fun.getFileName() != null)
             message = message.replace("in contract_main.yjs", "in " + fun.getFileName());
         content.append(message);
         content.append("(");
-        if (fun.functionName != null) content.append(fun.functionName);
-        else content.append("contract_main.yjs");
+        if (fun.functionName != null)
+            content.append(fun.functionName);
+        else
+            content.append("contract_main.yjs");
         content.append(":");
 
         content.append(actLine);
@@ -794,17 +772,15 @@ public class DesktopEngine extends JSEngine {
             String methodName = element.getMethodName();
             String fileName = element.getFileName();
 
-            if (fileName.endsWith(".java")) continue;
+            if (fileName.endsWith(".java"))
+                continue;
             if (c.isBundle()) {
                 fileName = fixFile(c, methodName);
             }
-            if (fileName.equals("--")) continue;
-            ret.add(
-                    String.format(
-                            "at %s(%s:%d)",
-                            methodName,
-                            fileName,
-                            (fixLine(c, methodName) + element.getLineNumber())));
+            if (fileName.equals("--"))
+                continue;
+            ret.add(String.format("at %s(%s:%d)", methodName, fileName,
+                    (fixLine(c, methodName) + element.getLineNumber())));
         }
         return ret;
     }
@@ -920,13 +896,13 @@ public class DesktopEngine extends JSEngine {
                 }
                 if (entry.getName().endsWith(".so") || entry.getName().endsWith(".so.1")) {
                     System.out.println("unzip library:" + entry.getName().replaceAll(".*/", ""));
-                    loader.unzipLibrary(
-                            zf.getInputStream(entry), entry.getName().replaceAll(".*/", ""));
+                    loader.unzipLibrary(zf.getInputStream(entry),
+                            entry.getName().replaceAll(".*/", ""));
                 }
                 if (HardwareInfo.type == OSType.mac && entry.getName().endsWith(".dylib")) {
                     System.out.println("unzip library:" + entry.getName().replaceAll(".*/", ""));
-                    loader.unzipLibrary(
-                            zf.getInputStream(entry), entry.getName().replaceAll(".*/", ""));
+                    loader.unzipLibrary(zf.getInputStream(entry),
+                            entry.getName().replaceAll(".*/", ""));
                 }
             } catch (IOException e) {
                 e.printStackTrace();

src/main/java/org/bdware/sc/engine/JSONTool.java

@@ -1,14 +1,15 @@
 package org.bdware.sc.engine;
 
 import com.google.gson.*;
-import jdk.nashorn.internal.runtime.Context;
 import wrp.jdk.nashorn.api.scripting.ScriptObjectMirror;
 import wrp.jdk.nashorn.internal.objects.NativeArray;
 import wrp.jdk.nashorn.internal.runtime.PropertyMap;
-import wrp.jdk.nashorn.internal.runtime.ScriptObject;
 import wrp.jdk.nashorn.internal.scripts.JO;
 
-import java.util.*;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 public class JSONTool {
     public static JsonElement convertMirrorToJson(Object ret2) {
@@ -41,7 +42,7 @@ public class JSONTool {
     }
 
     public static Object convertJsonElementToMirror(Object input) {
-        if(input instanceof JsonElement) {
+        if (input instanceof JsonElement) {
             return convertJsonElementToMirror((JsonElement) input);
         } else {
             return input;
@@ -49,11 +50,14 @@ public class JSONTool {
     }
 
     private static JsonElement convertMirrorToJsonInternal(Object obj, Set<Object> recorded) {
-        if (recorded.contains(obj)) return JsonNull.INSTANCE;
-        if (obj == null) return JsonNull.INSTANCE;
+        if (recorded.contains(obj))
+            return JsonNull.INSTANCE;
+        if (obj == null)
+            return JsonNull.INSTANCE;
         if (obj.getClass() == wrp.jdk.nashorn.internal.runtime.Undefined.class)
             return JsonNull.INSTANCE;
-        if (obj instanceof JsonElement) return (JsonElement) obj;
+        if (obj instanceof JsonElement)
+            return (JsonElement) obj;
         if (obj.getClass().isArray()) {
             Object[] arr = (Object[]) obj;
             recorded.add(obj);
@@ -148,15 +152,15 @@ public class JSONTool {
             return JsonNull.INSTANCE;
         } else if (obj instanceof Number) {
             return new JsonPrimitive((Number) obj);
-
         } else if (obj instanceof String) {
             return new JsonPrimitive((String) obj);
-
         } else if (obj instanceof Character) {
             return new JsonPrimitive((Character) obj);
-        }
-        if (obj instanceof Boolean) {
+        } else if (obj instanceof Boolean) {
             return new JsonPrimitive((Boolean) obj);
+        } else if (obj.getClass() == Boolean.TYPE) {
+            return new JsonPrimitive((boolean) obj);
+
         }
         return JsonNull.INSTANCE;
     }

src/main/java/org/bdware/sc/engine/SyncMechUtil.java

@@ -128,17 +128,18 @@ public class SyncMechUtil {
     }
 
     /*
-     * memory的操作
-     * 无需startFlag就可以使用memory的操作
+     * memory的操作 无需startFlag就可以使用memory的操作
      */
     public synchronized String dumpMemory(String path) {
-        if (memoryDumpUtil == null) memoryDumpUtil = new MemoryDumpUtil(engine.engine);
+        if (memoryDumpUtil == null)
+            memoryDumpUtil = new MemoryDumpUtil(engine.engine);
         return memoryDumpUtil.dumpMemory(path, true);
     }
 
     public synchronized String dumpMemory(String path, boolean stateful) {
         LOGGER.info("dumpMemroy : stateful=" + stateful);
-        if (memoryDumpUtil == null) memoryDumpUtil = new MemoryDumpUtil(engine.engine);
+        if (memoryDumpUtil == null)
+            memoryDumpUtil = new MemoryDumpUtil(engine.engine);
         return memoryDumpUtil.dumpMemory(path, stateful);
     }
 
@@ -158,7 +159,7 @@ public class SyncMechUtil {
     }
 
     /*
-     *   同步机制操作
+     * 同步机制操作
      */
     // 设置ContractRecord持久化的文件
     public void setCRFile(String fileName) {
@@ -210,7 +211,8 @@ public class SyncMechUtil {
     }
 
     public void changeCurrType(SyncType t) {
-        if (t == currType) return;
+        if (t == currType)
+            return;
 
         // finASyncRecord();
         currType = t;
@@ -226,7 +228,8 @@ public class SyncMechUtil {
                 }
                 break;
             case Memory:
-                if (memoryDumpUtil == null) memoryDumpUtil = new MemoryDumpUtil(engine.engine);
+                if (memoryDumpUtil == null)
+                    memoryDumpUtil = new MemoryDumpUtil(engine.engine);
                 break;
             default:
                 break;
@@ -256,7 +259,8 @@ public class SyncMechUtil {
      * Trans操作
      */
     public synchronized String redo(String path) {
-        if (transRecoverUtil == null) transRecoverUtil = new TransRecoverUtil(engine);
+        if (transRecoverUtil == null)
+            transRecoverUtil = new TransRecoverUtil(engine);
 
         // 先清空，否则会重复执行一些trans
         if (transRecoverUtil.transRecords != null && !transRecoverUtil.transRecords.isEmpty())
@@ -264,10 +268,11 @@ public class SyncMechUtil {
 
         // 某一次检查点之后没有transRecords
         File file = new File(path);
-        if (!file.exists()) return "success";
+        if (!file.exists())
+            return "success";
 
         transRecoverUtil.setTraceRecords(path);
         transRecoverUtil.recoverFromTransRecord();
         return "success";
     }
-}
+}

src/main/java/org/bdware/sc/engine/TestClassFilter.java

@@ -6,9 +6,8 @@ import javax.script.ScriptEngine;
 
 public class TestClassFilter {
     public TestClassFilter() {
-        final String script = "print(java.lang.System.getProperty(\"java.home\"));" +
-                "print(\"Create file variable\");" +
-                "var File = Java.type(\"java.io.File\");";
+        final String script = "print(java.lang.System.getProperty(\"java.home\"));"
+                + "print(\"Create file variable\");" + "var File = Java.type(\"java.io.File\");";
         NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
         ScriptEngine engine = factory.getScriptEngine(new YJSFilter());
         try {

src/main/java/org/bdware/sc/engine/YJSClassLoader.java

@@ -19,7 +19,7 @@ public class YJSClassLoader extends URLClassLoader {
     List<String> toLoad = new ArrayList<>();
 
     public YJSClassLoader(ClassLoader parent, ClassFilter cf) {
-        super(new URL[]{}, parent);
+        super(new URL[] {}, parent);
         classFilter = cf;
     }
 
@@ -50,7 +50,7 @@ public class YJSClassLoader extends URLClassLoader {
             ByteArrayOutputStream bo = new ByteArrayOutputStream();
             byte[] buff = new byte[1024];
 
-            for (int len = 0; (len = in.read(buff)) > 0; ) {
+            for (int len = 0; (len = in.read(buff)) > 0;) {
                 bo.write(buff, 0, len);
             }
             return bo.toByteArray();
@@ -63,7 +63,8 @@ public class YJSClassLoader extends URLClassLoader {
     public String unzipLibrary(InputStream inputStream, String name) {
         try {
             if (libDir == null) {
-                libDir = new File(System.getProperty("java.io.tmpdir"), "yjscontract_" + System.currentTimeMillis());
+                libDir = new File(System.getProperty("java.io.tmpdir"),
+                        "yjscontract_" + System.currentTimeMillis());
                 libDir.mkdirs();
             }
             File f = new File(libDir, name);
@@ -71,7 +72,7 @@ public class YJSClassLoader extends URLClassLoader {
             toLoad.add(f.getAbsolutePath());
             FileOutputStream fout = new FileOutputStream(f);
             byte[] buff = new byte[1024 * 100];
-            for (int k = 0; (k = inputStream.read(buff)) > 0; ) {
+            for (int k = 0; (k = inputStream.read(buff)) > 0;) {
                 fout.write(buff, 0, k);
             }
             fout.close();
@@ -84,7 +85,7 @@ public class YJSClassLoader extends URLClassLoader {
 
     private void addDirToPath(String s) {
         try {
-         //   System.out.println("[YJSClassloader] addtopath:" + s);
+            // System.out.println("[YJSClassloader] addtopath:" + s);
             Field field = ClassLoader.class.getDeclaredField("sys_paths");
             field.setAccessible(true);
             String[] path = (String[]) field.get(null);

src/main/java/org/bdware/sc/engine/YJSFilter.java

@@ -3,9 +3,9 @@ package org.bdware.sc.engine;
 import wrp.jdk.nashorn.api.scripting.ClassFilter;
 
 public class YJSFilter implements ClassFilter {
-	@Override
-	public boolean exposeToScripts(String arg0) {
-		return true;
-		//return arg0.compareTo("java.io.File") != 0;
-	}
+    @Override
+    public boolean exposeToScripts(String arg0) {
+        return true;
+        // return arg0.compareTo("java.io.File") != 0;
+    }
 }

src/main/java/org/bdware/sc/engine/hook/AccessHandler.java

@@ -3,22 +3,24 @@ package org.bdware.sc.engine.hook;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.bdware.sc.JSEngine;
 import org.bdware.sc.bean.ContractRequest;
 import org.bdware.sc.boundry.ScriptReturnException;
 import org.bdware.sc.engine.DesktopEngine;
 import org.bdware.sc.engine.JSONTool;
+import org.bdware.sc.entity.DoipMessagePacker;
 import org.bdware.sc.node.AnnotationHook;
 import org.bdware.sc.node.AnnotationNode;
 import org.bdware.sc.node.ArgPacks;
 import org.bdware.sc.node.FunctionNode;
-import wrp.jdk.nashorn.internal.objects.Global;
-import wrp.jdk.nashorn.internal.runtime.Context;
 import wrp.jdk.nashorn.internal.runtime.PropertyMap;
 import wrp.jdk.nashorn.internal.scripts.JO;
 
 @YJSAnnotation(name = "Access")
 public class AccessHandler implements AnnotationHook {
+    static Logger LOGGER = LogManager.getLogger(AccessHandler.class);
     public String acFunction;
     public boolean requireSign;
 
@@ -41,20 +43,23 @@ public class AccessHandler implements AnnotationHook {
     @Override
     public ArgPacks handle(JSEngine desktopEngine, ArgPacks argPacks) {
         if (requireSign) {
-            if (!argPacks.request.verifySignature()) {
-                throw new ScriptReturnException(JsonParser.parseString("{\"code\":400,\"msg\":\"permission denied\"}"));
+            if (!verifyRequest(argPacks)) {
+                throw new ScriptReturnException(
+                        JsonParser.parseString("{\"code\":400,\"msg\":\"permission denied\"}"));
             }
             return argPacks;
         }
-        if (acFunction == null) return argPacks;
+        if (!verifyRequest(argPacks)) {
+            LOGGER.info("verify failed! clear requester," + argPacks.request.getContentStr()
+                    + " -> " + argPacks.request.getPublicKey() + "sign:"
+                    + argPacks.request.getSignature());
+            argPacks.request.setRequester(null);
+        } else
+            LOGGER.info("verify success!" + argPacks.request.getRequester());
+        if (acFunction == null)
+            return argPacks;
         DesktopEngine de = (DesktopEngine) desktopEngine;
-        Global oldGlobal = Context.getGlobal();
-        Global newGlobal = de.getDesktopGlobal();
-        boolean globalChanged = (oldGlobal != newGlobal);
         try {
-            if (globalChanged) {
-                Context.setGlobal(newGlobal);
-            }
             ContractRequest input = argPacks.request;
             JO jo = new JO(PropertyMap.newMap());
             jo.put("requester", input.getRequester(), false);
@@ -69,10 +74,14 @@ public class AccessHandler implements AnnotationHook {
             jo.addProperty("code", "401");
             jo.addProperty("msg", "access check meets exception! " + e);
             throw new ScriptReturnException(jo);
-        } finally {
-            if (globalChanged) Context.setGlobal(oldGlobal);
-
         }
 
     }
+
+    private boolean verifyRequest(ArgPacks argPacks) {
+        if (argPacks.arg != null && argPacks.arg instanceof DoipMessagePacker) {
+            return true;
+        }
+        return argPacks.request.verifySignature();
+    }
 }

src/main/java/org/bdware/sc/engine/hook/ArgSchemaHandler.java

@@ -21,14 +21,15 @@ public class ArgSchemaHandler implements AnnotationHook {
     public ArgSchemaHandler(AnnotationNode annoNode) {
         a = annoNode;
         String arg = a.getArgs().get(0);
-//        if (arg.startsWith("/")){
-//            ;//ContractProcess.instance.engine.getResources().loadAsString(arg);
-//        }else {
-//            ;
-//        }
+        // if (arg.startsWith("/")){
+        // ;//ContractProcess.instance.engine.getResources().loadAsString(arg);
+        // }else {
+        // ;
+        // }
     }
 
-    public static ArgSchemaHandler fromAnnotationNode(FunctionNode funNode, AnnotationNode annoNode) {
+    public static ArgSchemaHandler fromAnnotationNode(FunctionNode funNode,
+            AnnotationNode annoNode) {
         return new ArgSchemaHandler(annoNode);
     }
 
@@ -43,7 +44,7 @@ public class ArgSchemaHandler implements AnnotationHook {
             try {
                 JsonElement obj = JsonParser.parseString(input.getArg().getAsString());
                 visitor = new ArgSchemaVisitor(obj);
-                //IMPORTANT automatically convert arg type here
+                // IMPORTANT automatically convert arg type here
                 input.setArg(obj);
                 argPacks.arg = obj;
             } catch (Exception e) {
@@ -65,6 +66,7 @@ public class ArgSchemaHandler implements AnnotationHook {
             JsonObject jo = new JsonObject();
             jo.addProperty("msg", visitor.getException());
             jo.addProperty("code", visitor.errorCode);
+            jo.add("argSchema", JsonParser.parseString(a.getArgs().get(0)));
             throw new ScriptReturnException(jo);
         }
         return argPacks;

src/main/java/org/bdware/sc/engine/hook/ArgSchemaVisitor.java

@@ -1,18 +1,15 @@
 package org.bdware.sc.engine.hook;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonPrimitive;
+import com.google.gson.*;
 import org.bdware.mockjava.JsonVisitor;
 
 public class ArgSchemaVisitor extends JsonVisitor {
     JsonElement root;
     public boolean status = true;
     public int errorCode = 0;
-    //{"msg":"xxx","code":1000}
+    // {"msg":"xxx","code":1000}
     //
-//    JsonElement message = new JsonPrimitive("");
+    // JsonElement message = new JsonPrimitive("");
     public String message = "";
 
     public ArgSchemaVisitor(JsonElement ret) {
@@ -21,13 +18,13 @@ public class ArgSchemaVisitor extends JsonVisitor {
 
     @Override
     public JsonVisitor visitObject(JsonObject schema) {
-        //message = new JsonObject();
+        // message = new JsonObject();
         if (root.isJsonObject()) {
             JsonObject jo = root.getAsJsonObject();
             for (String key : schema.keySet()) {
                 if (key.startsWith("!")) {
-                    //TODO
-                    //if(必選）
+                    // TODO
+                    // if(必選）
                     if (jo.has(key.substring(1))) {
                         ArgSchemaVisitor visitor = new ArgSchemaVisitor(jo.get(key.substring(1)));
                         visitor.visit(schema.get(key));
@@ -37,12 +34,12 @@ public class ArgSchemaVisitor extends JsonVisitor {
                         }
                         status &= visitor.status;
                     } else {
-                        message += "[Missing argument] " + key.substring(1) + " should be supplied ";
+                        message += "[Missing key] " + key.substring(1) + " should be supplied ";
                         status = false;
                         errorCode = 1002;
                     }
                 } else {
-                    if (jo.has(key)) {
+                    if (jo.has(key) && jo.get(key) != null && jo.get(key) != JsonNull.INSTANCE) {
                         ArgSchemaVisitor visitor = new ArgSchemaVisitor(jo.get(key));
                         visitor.visit(schema.get(key));
                         if (!visitor.status) {
@@ -87,12 +84,13 @@ public class ArgSchemaVisitor extends JsonVisitor {
             String type = primitive.getAsString();
             try {
                 String result = "";
-                //md5不需要参数
+                // md5不需要参数
                 if (type.equals("string")) {
                     if (root.isJsonPrimitive() && root.getAsJsonPrimitive().isString()) {
                         return this;
                     } else {
-                        message = "[Type error] The value (" + root.getAsJsonPrimitive().getAsString() + ") should be string";
+                        message = "[Type error] The value ("
+                                + root.getAsJsonPrimitive().getAsString() + ") should be string";
                         status = false;
                         errorCode = 1001;
                         return this;
@@ -101,7 +99,8 @@ public class ArgSchemaVisitor extends JsonVisitor {
                     if (root.isJsonPrimitive() && root.getAsJsonPrimitive().isNumber()) {
                         return this;
                     } else {
-                        message = "[Type error] The value (" + root.getAsJsonPrimitive().getAsString() + ") should be number";
+                        message = "[Type error] The value ("
+                                + root.getAsJsonPrimitive().getAsString() + ") should be number";
                         status = false;
                         errorCode = 1001;
                         return this;
@@ -110,7 +109,8 @@ public class ArgSchemaVisitor extends JsonVisitor {
                     if (root.isJsonPrimitive() && root.getAsJsonPrimitive().isBoolean()) {
                         return this;
                     } else {
-                        message = "[Type error] The value (" + root.getAsJsonPrimitive().getAsString() + ") should be boolean";
+                        message = "[Type error] The value ("
+                                + root.getAsJsonPrimitive().getAsString() + ") should be boolean";
                         status = false;
                         errorCode = 1001;
                         return this;
@@ -119,7 +119,8 @@ public class ArgSchemaVisitor extends JsonVisitor {
                     if (root.isJsonArray()) {
                         return this;
                     } else {
-                        message = "[Type error] The value (" + root.getAsJsonPrimitive().getAsString() + ") should be array";
+                        message = "[Type error] The value ("
+                                + root.getAsJsonPrimitive().getAsString() + ") should be array";
                         status = false;
                         errorCode = 1001;
                         return this;
@@ -128,7 +129,8 @@ public class ArgSchemaVisitor extends JsonVisitor {
                     if (root.isJsonObject()) {
                         return this;
                     } else {
-                        message = "[Type error] The value (" + root.getAsJsonPrimitive().getAsString() + ") should be object";
+                        message = "[Type error] The value ("
+                                + root.getAsJsonPrimitive().getAsString() + ") should be object";
                         status = false;
                         errorCode = 1001;
                         return this;

src/main/java/org/bdware/sc/engine/hook/ConfidentialHandler.java

@@ -23,8 +23,8 @@ public class ConfidentialHandler implements AnnotationHook {
             DesktopEngine desktopEngine = (DesktopEngine) engine;
             ConfidentialContractUtil.copyTemplateToDestination(input);
             ScriptObjectMirror globalVars = (ScriptObjectMirror) desktopEngine.get("Global");
-            ConfidentialContractUtil.dumpScriptAndStates(
-                    desktopEngine.engine, fun, input, globalVars);
+            ConfidentialContractUtil.dumpScriptAndStates(desktopEngine.engine, fun, input,
+                    globalVars);
             // run in SGX instead of Nashorn if function has @Confidential annotation
             argPacks.ret = ConfidentialContractUtil.executeConfidentialContract(input);
             return argPacks;

src/main/java/org/bdware/sc/engine/hook/DOOPAfterExecHandler.java

@@ -0,0 +1,129 @@
+package org.bdware.sc.engine.hook;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.bdware.doip.codec.JsonDoipMessage;
+import org.bdware.doip.codec.doipMessage.DoipMessage;
+import org.bdware.doip.codec.doipMessage.DoipResponseCode;
+import org.bdware.doip.codec.operations.BasicOperations;
+import org.bdware.sc.JSEngine;
+import org.bdware.sc.boundry.ScriptReturnException;
+import org.bdware.sc.conn.ByteUtil;
+import org.bdware.sc.entity.DoipMessagePacker;
+import org.bdware.sc.node.AnnotationHook;
+import org.bdware.sc.node.ArgPacks;
+import org.bdware.sc.node.FunctionNode;
+import org.bdware.sc.util.JsonUtil;
+
+import java.nio.charset.StandardCharsets;
+
+public class DOOPAfterExecHandler implements AnnotationHook {
+    private JsonElement jsonResponseRules;
+
+    public DOOPAfterExecHandler(BasicOperations operations) {
+        jsonResponseRules = getRulesForJsonResponse(operations);
+    }
+
+    @Override
+    public ArgPacks handle(JSEngine desktopEngine, ArgPacks argPacks) {
+        Object originDoipMsgPacker = argPacks.arg;
+        DoipMessage originDoipMsg = null;
+        if (originDoipMsgPacker instanceof DoipMessagePacker) {
+            DoipMessagePacker doipMessagePacker = (DoipMessagePacker) originDoipMsgPacker;
+            originDoipMsg = doipMessagePacker.rawDoipMsg;
+            // if http, directly return
+            if (doipMessagePacker.source.equals("http")) {
+                if (argPacks.ret != null && argPacks.ret instanceof DoipMessage) {
+                    argPacks.ret = JsonUtil.parseObject(
+                            JsonDoipMessage.fromDoipMessage((DoipMessage) argPacks.ret));
+                }
+                return argPacks;
+            } else {
+                // pack
+                if (!(argPacks.ret instanceof DoipMessage)) {
+                    JsonObject jsonObjectRes = ((JsonElement) argPacks.ret).getAsJsonObject();
+                    if (!jsonObjectRes.has("bodyBase64Encoded")
+                            || jsonObjectRes.get("bodyBase64Encoded").getAsBoolean() == true) {
+                        if (jsonObjectRes.has("body")) {
+                            String body = jsonObjectRes.get("body").getAsString();
+                            jsonObjectRes.addProperty("body",
+                                    ByteUtil.encodeBASE64(body.getBytes(StandardCharsets.UTF_8)));
+                        }
+                    }
+                    // validate json response
+                    ArgSchemaVisitor visitor = new ArgSchemaVisitor(jsonObjectRes);
+                    validateJsonElementRulesByArgSchemaVisitor(jsonResponseRules, visitor);
+                    JsonDoipMessage returnedMessage =
+                            JsonUtil.fromJson(jsonObjectRes, JsonDoipMessage.class);
+                    argPacks.ret = returnedMessage.toResponseDoipMessage(originDoipMsg);
+                }
+                return argPacks;
+            }
+        } else {
+            return argPacks;
+        }
+    }
+
+
+    public static JsonElement getRulesForJsonResponse(BasicOperations basicOperations) {
+        switch (basicOperations) {
+            case Hello:
+            case Retrieve:
+            case Create:
+            case Update:
+            case Search:
+            case ListOps:
+            case Delete:
+                return JsonParser.parseString(
+                        "{\"header\":{\"response\":\"string\",\"attributes\":{}},\"body\":\"string\"}");
+            case Extension:
+            case Unknown:
+            default:
+                return null;
+        }
+    }
+
+    // old convert jsonResponse from argPack's ret to Doip response in doip chain logic
+    public DoipMessage convertJsonResponseToDoipMessage(FunctionNode fn, JsonElement jsonResponse,
+            DoipMessage msg) {
+        JsonObject jsonParams = jsonResponse.getAsJsonObject();
+        // validate json response
+        ArgSchemaVisitor visitor = new ArgSchemaVisitor(jsonResponse);
+        validateJsonElementRulesByArgSchemaVisitor(jsonResponseRules, visitor);
+
+        JsonObject header =
+                jsonParams.get("header") != null ? jsonParams.get("header").getAsJsonObject()
+                        : null;
+        String body = jsonParams.get("body") != null ? jsonParams.get("body").getAsString() : null;
+
+        if (header != null) {
+            String headerRespCode =
+                    header.get("response") != null ? header.get("response").getAsString() : null;
+            if (headerRespCode != null) {
+                for (DoipResponseCode responseCode : DoipResponseCode.values()) {
+                    if (responseCode.toString().equals(headerRespCode)) {
+                        msg.header.parameters.response = responseCode;
+                        break;
+                    }
+                }
+            }
+        }
+        if (body != null) {
+            msg.body.encodedData = body.getBytes(StandardCharsets.UTF_8);
+        }
+
+        return msg;
+    }
+
+    public static void validateJsonElementRulesByArgSchemaVisitor(JsonElement jsonElement,
+            ArgSchemaVisitor visitor) {
+        visitor.visit(jsonElement);
+        if (!visitor.getStatus()) {
+            JsonObject jo = new JsonObject();
+            jo.addProperty("msg", visitor.getException());
+            jo.addProperty("code", visitor.errorCode);
+            throw new ScriptReturnException(jo);
+        }
+    }
+}

src/main/java/org/bdware/sc/engine/hook/DOOPBeforeExecHandler.java

@@ -0,0 +1,109 @@
+package org.bdware.sc.engine.hook;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.bdware.doip.codec.JsonDoipMessage;
+import org.bdware.doip.codec.doipMessage.DoipMessage;
+import org.bdware.doip.codec.doipMessage.MessageCredential;
+import org.bdware.doip.codec.operations.BasicOperations;
+import org.bdware.sc.JSEngine;
+import org.bdware.sc.bean.ContractRequest;
+import org.bdware.sc.boundry.ScriptReturnException;
+import org.bdware.sc.entity.DoipMessagePacker;
+import org.bdware.sc.node.AnnotationHook;
+import org.bdware.sc.node.ArgPacks;
+import org.bdware.sc.util.JsonUtil;
+
+public class DOOPBeforeExecHandler implements AnnotationHook {
+
+    private final BasicOperations httpOperation;
+    private JsonElement httpArgsRules;
+
+    public DOOPBeforeExecHandler(BasicOperations operations) {
+        httpOperation = operations;
+        httpArgsRules = getRulesForHTTPRequest(operations);
+    }
+
+    @Override
+    public ArgPacks handle(JSEngine desktopEngine, ArgPacks argPacks) {
+        Object arg = argPacks.arg;
+        DoipMessagePacker doipMsgPackerArg = new DoipMessagePacker();
+        if (arg instanceof DoipMessagePacker) {
+            doipMsgPackerArg = (DoipMessagePacker) arg;
+        } else {
+            // validate http request's params
+            ContractRequest httpReq = argPacks.request;
+            validateHTTPRequestArgs(httpReq);
+            // set doipMsgPackerArg struct's params
+            doipMsgPackerArg.setSource("http");
+            doipMsgPackerArg.rawDoipMsg = convertHttpRequestToDoipMessage(httpReq);
+
+            if (httpReq.verifySignature()) {
+                doipMsgPackerArg.rawDoipMsg.credential =
+                        new MessageCredential(httpReq.getRequester(), new byte[0]);
+            } else {
+                doipMsgPackerArg.rawDoipMsg.credential = null;
+            }
+        }
+
+        argPacks.arg = doipMsgPackerArg;
+        return argPacks;
+    }
+
+    public void validateHTTPRequestArgs(ContractRequest httpReq) {
+        JsonElement originArgs = httpReq.getArg();
+        JsonElement httpArgs = null;
+        if (originArgs.isJsonObject())
+            httpArgs = originArgs;
+        else
+            httpArgs = JsonParser.parseString(originArgs.getAsString());
+        // get args rules and validate http args
+        ArgSchemaVisitor visitor = new ArgSchemaVisitor(httpArgs);
+        validateJsonElementRulesByArgSchemaVisitor(httpArgsRules, visitor);
+    }
+
+    public static JsonElement getRulesForHTTPRequest(BasicOperations basicOperation) {
+        switch (basicOperation) {
+            case Hello:
+            case Delete:
+            case ListOps:
+                return JsonParser.parseString("{\"!header\":{\"!identifier\":\"string\"}}");
+            case Create:
+            case Update:
+                return JsonParser.parseString(
+                        "{\"!header\":{\"!identifier\":\"string\"}, \"!body\":\"string\"}");
+            case Search:
+                return JsonParser.parseString(
+                        "{\"!header\":{\"!identifier\":\"string\", \"!attributes\":{\"!query\":\"string\", \"!pageNum\":\"int\", \"!pageSize\":\"int\", \"!type\":\"string\"}}}");
+            case Retrieve:
+                return JsonParser.parseString(
+                        "{\"!header\":{\"!identifier\":\"string\", \"attributes\":{\"element\":\"string\", \"includeElementData\":\"boolean\"}}}");
+            case Extension:
+            case Unknown:
+            default:
+                return null;
+        }
+    }
+
+    public DoipMessage convertHttpRequestToDoipMessage(ContractRequest httpReq) {
+        JsonElement arg = httpReq.getArg();
+        if (!arg.isJsonObject()) {
+            arg = JsonParser.parseString(arg.getAsString());
+        }
+        JsonDoipMessage doipMessage = JsonUtil.fromJson(arg, JsonDoipMessage.class);
+        return doipMessage.toRequestDoipMessage();
+    }
+
+
+    public static void validateJsonElementRulesByArgSchemaVisitor(JsonElement jsonElement,
+            ArgSchemaVisitor visitor) {
+        visitor.visit(jsonElement);
+        if (!visitor.getStatus()) {
+            JsonObject jo = new JsonObject();
+            jo.addProperty("msg", visitor.getException());
+            jo.addProperty("code", visitor.errorCode);
+            throw new ScriptReturnException(jo);
+        }
+    }
+}

src/main/java/org/bdware/sc/engine/hook/DOOPHandler.java

@@ -1,129 +0,0 @@
-package org.bdware.sc.engine.hook;
-
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
-import org.bdware.doip.codec.doipMessage.DoipMessage;
-import org.bdware.doip.codec.doipMessage.DoipMessageFactory;
-import org.bdware.doip.codec.doipMessage.DoipResponseCode;
-import org.bdware.doip.codec.operations.BasicOperations;
-import org.bdware.sc.JSEngine;
-import org.bdware.sc.bean.ContractRequest;
-import org.bdware.sc.boundry.ScriptReturnException;
-import org.bdware.sc.entity.DoipMessagePacker;
-import org.bdware.sc.node.AnnotationHook;
-import org.bdware.sc.node.ArgPacks;
-import org.bdware.sc.node.FunctionNode;
-
-import java.nio.charset.StandardCharsets;
-import java.util.HashMap;
-import java.util.Map;
-
-public class DOOPHandler implements AnnotationHook {
-    public static Map<String, BasicOperations> funcNameToDoipOperations;
-    public static DOOPHandler instance;
-    public DOOPHandler() {
-        funcNameToDoipOperations = new HashMap<>();
-    }
-
-    public static DOOPHandler createDOOPHandler() {
-        if(instance == null) {
-            instance = new DOOPHandler();
-        }
-
-        return instance;
-    }
-
-    public void putFuncNameAndDoipOperationsMapping(FunctionNode fn) {
-        String basicOperationsString = fn.getDoipOperationInfo().operationType;
-        BasicOperations operation = BasicOperations.Unknown;
-        for(BasicOperations basicOperation : BasicOperations.values()) {
-            if(basicOperation.toString().equals(basicOperationsString)) {
-                operation = basicOperation;
-            }
-        }
-        funcNameToDoipOperations.put(fn.getFunctionName(), operation);
-    }
-
-    @Override
-    public ArgPacks handle(JSEngine desktopEngine, ArgPacks argPacks) {
-        Object arg = argPacks.arg;
-        DoipMessagePacker doipMsgPackerArg = new DoipMessagePacker();
-
-        if (arg instanceof DoipMessagePacker){
-            doipMsgPackerArg = (DoipMessagePacker)arg;
-        } else {
-            // validate http request's params
-            ContractRequest httpReq = argPacks.request;
-            validateHTTPRequestArgs(httpReq);
-
-            // set doipMsgPackerArg struct's params
-            doipMsgPackerArg.setSource("http");
-            doipMsgPackerArg.rawDoipMsg = convertContractRequestToDoipMessage(httpReq);
-        }
-
-        argPacks.arg = doipMsgPackerArg;
-        return argPacks;
-    }
-
-    public static void validateHTTPRequestArgs(ContractRequest httpReq) {
-        JsonElement originArgs = httpReq.getArg();
-        JsonElement httpArgs = JsonParser.parseString(originArgs.getAsString());
-        BasicOperations curOp = funcNameToDoipOperations.get(httpReq.getAction());
-
-        // get args rules and validate http args
-        JsonElement httpArgsRules = getRulesForBasicOperation(curOp);
-        ArgSchemaVisitor visitor = new ArgSchemaVisitor(httpArgs);
-        visitor.visit(httpArgsRules);
-        if (!visitor.getStatus()) {
-            JsonObject jo = new JsonObject();
-            jo.addProperty("msg", visitor.getException());
-            jo.addProperty("code", visitor.errorCode);
-            throw new ScriptReturnException(jo);
-        }
-    }
-
-    public static JsonElement getRulesForBasicOperation(BasicOperations basicOperation) {
-
-        switch(basicOperation) {
-            case Hello:
-                return JsonParser.parseString("{\"!doid\":\"string\"}");
-            case Retrieve:
-                return JsonParser.parseString("{\"!doid\":\"string\", \"!element\":\"boolean\"}");
-            default:
-                return null;
-        }
-    }
-
-    public static DoipMessage convertContractRequestToDoipMessage(ContractRequest httpReq) {
-        BasicOperations httpOperation = funcNameToDoipOperations.get(httpReq.getAction());
-        JsonObject jsonParams = JsonParser.parseString(httpReq.getArg().getAsString()).getAsJsonObject();
-        DoipMessage doipMessage = new DoipMessageFactory.DoipMessageBuilder().createRequest("", httpReq.getAction()).create();
-        switch(httpOperation) {
-            case Hello:
-                doipMessage = new DoipMessageFactory.DoipMessageBuilder().createRequest(jsonParams.get("doid").getAsString(), httpReq.getAction()).create();
-                break;
-            case Retrieve:
-                DoipMessageFactory.DoipMessageBuilder msgBuilder = new DoipMessageFactory.DoipMessageBuilder().createRequest(jsonParams.get("doid").getAsString(), httpReq.getAction());
-                msgBuilder = msgBuilder.addAttributes("element", jsonParams.get("element").getAsString());
-                doipMessage = msgBuilder.create();
-                break;
-        }
-
-        return doipMessage;
-    }
-
-    public static DoipMessage convertJsonElementToDoipMessage(JsonElement jsonElementRet, DoipMessage msg) {
-        DoipMessageFactory.DoipMessageBuilder builder = new DoipMessageFactory.DoipMessageBuilder();
-
-        String responseCodeStr = jsonElementRet.getAsJsonObject().get("doipResponseCode").getAsString();
-        DoipResponseCode responseCode = DoipResponseCode.UnKnownError;
-        for (DoipResponseCode resp : DoipResponseCode.values()) {
-            if (resp.toString().equals(responseCodeStr)) responseCode = resp;
-        }
-
-        DoipMessage doipRet = builder.createResponse(responseCode, msg).create();;
-        doipRet.body.encodedData = jsonElementRet.getAsJsonObject().get("body").getAsJsonObject().get("encodedData").getAsString().getBytes(StandardCharsets.UTF_8);
-        return doipRet;
-    }
-}

src/main/java/org/bdware/sc/engine/hook/HomoVisitor.java

@@ -74,7 +74,7 @@ public class HomoVisitor extends JsonVisitor {
                 System.out.println(e);
             }
         }
-        
+
         return this;
     }
 

src/main/java/org/bdware/sc/engine/hook/HomomorphicDecryptHandler.java

@@ -27,25 +27,25 @@ public class HomomorphicDecryptHandler implements AnnotationHook {
     @Override
     public ArgPacks handle(JSEngine engine, ArgPacks argPacks) {
         try {
-//            GetHomArgs args =
-//                    new GetHomArgs(
-//                            input.getRequester(), this.fun.getSecretID().replaceAll("\"", ""));
-//            String arg = JsonUtil.toJson(args);
+            // GetHomArgs args =
+            // new GetHomArgs(
+            // input.getRequester(), this.fun.getSecretID().replaceAll("\"", ""));
+            // String arg = JsonUtil.toJson(args);
             JsonElement homoDecryptConf = this.fun.getHomoDecryptConf();
             if (null != homoDecryptConf && !homoDecryptConf.isJsonNull()) {
-                String res = (String)
-                        JavaScriptEntry.executeContract(
-                                "keyManager_1",
-                                "getPrivKey",
-                                this.fun.getSecretID().replaceAll("\"", ""));
+                String res = (String) JavaScriptEntry.executeContract("keyManager_1", "getPrivKey",
+                        this.fun.getSecretID().replaceAll("\"", ""));
                 LOGGER.info("HomomorphicDecryptHandler--------------------------------1: " + res);
                 ContractResult results = JsonUtil.fromJson(res, ContractResult.class);
                 String privKeyStr = results.result.getAsString();
-                LOGGER.info("HomomorphicEncryptHandler--------------------------------2: " + privKeyStr);
+                LOGGER.info("HomomorphicEncryptHandler--------------------------------2: "
+                        + privKeyStr);
                 RSAPrivateKey privkey = (RSAPrivateKey) PaillierKeyPair.pemToPrivateKey(privKeyStr);
-                LOGGER.info("HomomorphicEncryptHandler--------------------------------3: " + privkey);
+                LOGGER.info(
+                        "HomomorphicEncryptHandler--------------------------------3: " + privkey);
                 HomoVisitor.privateKey = privkey;
-                argPacks.ret = getDecryptResult(homoDecryptConf, JsonUtil.parseObject(argPacks.ret));
+                argPacks.ret =
+                        getDecryptResult(homoDecryptConf, JsonUtil.parseObject(argPacks.ret));
                 if (null != argPacks.ret) {
                     return argPacks;
                 }

src/main/java/org/bdware/sc/engine/hook/HomomorphicEncryptHandler.java

@@ -29,36 +29,36 @@ public class HomomorphicEncryptHandler implements AnnotationHook {
     public ArgPacks handle(JSEngine engine, ArgPacks argPacks) {
         try {
             ContractRequest input = argPacks.request;
-            LOGGER.info(
-                    "HomomorphicEncryptHandler--------------------------------1: "
-                            + input.getRequester());
-            LOGGER.info(
-                    "HomomorphicEncryptHandler--------------------------------2: "
-                            + this.fun.getSecretID());
+            LOGGER.info("HomomorphicEncryptHandler--------------------------------1: "
+                    + input.getRequester());
+            LOGGER.info("HomomorphicEncryptHandler--------------------------------2: "
+                    + this.fun.getSecretID());
             JsonElement response = (JsonElement) argPacks.ret;
             JsonElement homoEncryptConf = this.fun.getHomoEncryptConf();
             if (homoEncryptConf != null && !homoEncryptConf.isJsonNull()) {
-                String res =
-                        (String) JavaScriptEntry.executeContract(
-                                "keyManager_1",
-                                "getPubKey",
-                                this.fun.getSecretID().replaceAll("\"", ""));
-//                String res =
-//                        JavaScriptEntry.executeContract(
-//                                this.fun.getKeyManagerID(),
-//                                "getPubKey",
-//                                this.fun.getSecretID().replaceAll("\"", ""));
+                String res = (String) JavaScriptEntry.executeContract("keyManager_1", "getPubKey",
+                        this.fun.getSecretID().replaceAll("\"", ""));
+                // String res =
+                // JavaScriptEntry.executeContract(
+                // this.fun.getKeyManagerID(),
+                // "getPubKey",
+                // this.fun.getSecretID().replaceAll("\"", ""));
                 LOGGER.info("HomomorphicEncryptHandler--------------------------------4: " + res);
                 ContractResult results = JsonUtil.fromJson(res, ContractResult.class);
                 String pubKeyStr = results.result.getAsString();
-                LOGGER.info("HomomorphicEncryptHandler--------------------------------5: " + pubKeyStr);
+                LOGGER.info(
+                        "HomomorphicEncryptHandler--------------------------------5: " + pubKeyStr);
                 HomoVisitor.publicKey = (RSAPublicKey) PaillierKeyPair.pemToPublicKey(pubKeyStr);
-//                if (homoEncryptConf.getAsJsonPrimitive().isString())
-//                    homoEncryptConf = JsonParser.parseString(homoEncryptConf.getAsString());
-                LOGGER.info("HomomorphicEncryptHandler--------------------------------6: " + homoEncryptConf);
-                LOGGER.info("HomomorphicEncryptHandler--------------------------------7: " + argPacks.ret);
-                LOGGER.info("HomomorphicEncryptHandler--------------------------------8: " + argPacks.ret.toString());
-                // LOGGER.info("HomomorphicEncryptHandler--------------------------------9: " + JsonUtil.toJson(ret));
+                // if (homoEncryptConf.getAsJsonPrimitive().isString())
+                // homoEncryptConf = JsonParser.parseString(homoEncryptConf.getAsString());
+                LOGGER.info("HomomorphicEncryptHandler--------------------------------6: "
+                        + homoEncryptConf);
+                LOGGER.info("HomomorphicEncryptHandler--------------------------------7: "
+                        + argPacks.ret);
+                LOGGER.info("HomomorphicEncryptHandler--------------------------------8: "
+                        + argPacks.ret.toString());
+                // LOGGER.info("HomomorphicEncryptHandler--------------------------------9: " +
+                // JsonUtil.toJson(ret));
                 argPacks.ret = getEncryptResult(homoEncryptConf, response);
                 if (argPacks.ret != null) {
                     return argPacks;
@@ -73,9 +73,9 @@ public class HomomorphicEncryptHandler implements AnnotationHook {
     }
 
     private Object getEncryptResult(JsonElement homoEncryptConf, JsonElement data) {
-//        if (null == homoEncryptConf || homoEncryptConf.getAsString().isEmpty()) {
-//            return data;
-//        }
+        // if (null == homoEncryptConf || homoEncryptConf.getAsString().isEmpty()) {
+        // return data;
+        // }
         if (null == homoEncryptConf) {
             return data;
         }

src/main/java/org/bdware/sc/engine/hook/MaskHandler.java

@@ -25,14 +25,14 @@ public class MaskHandler implements AnnotationHook {
             if (null != maskConf) {
                 LOGGER.debug("execute maskConf: " + maskConf);
                 String s1 = ret.toString();
-                //budeijin
-                //"{\"count\":1}"
-                //{"count":1}
-                //System.out.println(s1);
+                // budeijin
+                // "{\"count\":1}"
+                // {"count":1}
+                // System.out.println(s1);
                 s1 = s1.replace("\\", "");
                 s1 = s1.substring(1, s1.length() - 1);
-                //System.out.println(s1);
-                //System.out.println(JsonParser.parseString(s1));
+                // System.out.println(s1);
+                // System.out.println(JsonParser.parseString(s1));
                 MaskVisitor visitor = new MaskVisitor(JsonParser.parseString(s1));
                 visitor.visit(maskConf);
                 ret = visitor.get();

src/main/java/org/bdware/sc/engine/hook/MaskVisitor.java

@@ -23,7 +23,7 @@ public class MaskVisitor extends JsonVisitor {
             JsonObject jo = root.getAsJsonObject();
             for (String key : mask.keySet()) {
                 if (jo.has(key)) {
-                    //TODO
+                    // TODO
                     MaskVisitor visitor = new MaskVisitor(jo.get(key));
                     visitor.visit(mask.get(key));
                     jo.add(key, visitor.get());
@@ -58,7 +58,7 @@ public class MaskVisitor extends JsonVisitor {
             String method = primitive.getAsString();
             try {
                 String result = "";
-                //md5不需要参数
+                // md5不需要参数
                 if (method.equals("md5")) {
                     MD5EncryptionImpl masker = new MD5EncryptionImpl();
                     result = masker.execute(root.getAsString());
@@ -69,7 +69,7 @@ public class MaskVisitor extends JsonVisitor {
                     FormatPreservingEncryptionImpl masker = new FormatPreservingEncryptionImpl();
                     result = masker.execute(root.getAsString());
                 }
-                //edp需要精度的参数
+                // edp需要精度的参数
                 else if (method.equals("edp")) {
                     EpsilonDifferentialPrivacyImpl masker = new EpsilonDifferentialPrivacyImpl();
                     double epsilon = 1;
@@ -87,11 +87,11 @@ public class MaskVisitor extends JsonVisitor {
         }
 
 
-        //String result = masker.execute(primitive.toString());
-        //System.out.println(result);
+        // String result = masker.execute(primitive.toString());
+        // System.out.println(result);
 
-        //root = new JsonPrimitive(root.getAsString().substring(0, 2));
-        //https://github.com/guohf/DataX-Masking
+        // root = new JsonPrimitive(root.getAsString().substring(0, 2));
+        // https://github.com/guohf/DataX-Masking
         return this;
     }
 }

src/main/java/org/bdware/sc/engine/hook/MockTemplateHandler.java

@@ -23,7 +23,8 @@ public class MockTemplateHandler implements AnnotationHook {
                     MockUtil Mock = new MockUtil();
                     argPacks.ret = Mock.mock(template).toString();
                     return argPacks;
-                } else return argPacks; //When mock config is null defined just ignore.
+                } else
+                    return argPacks; // When mock config is null defined just ignore.
             }
         } catch (Exception e) {
             e.printStackTrace();

src/main/java/org/bdware/sc/engine/hook/ObjToJsonHandler.java

@@ -1,5 +1,6 @@
 package org.bdware.sc.engine.hook;
 
+import org.bdware.doip.codec.doipMessage.DoipMessage;
 import org.bdware.sc.JSEngine;
 import org.bdware.sc.engine.JSONTool;
 import org.bdware.sc.node.AnnotationHook;
@@ -8,6 +9,8 @@ import org.bdware.sc.node.ArgPacks;
 public class ObjToJsonHandler implements AnnotationHook {
     @Override
     public ArgPacks handle(JSEngine desktopEngine, ArgPacks argPacks) {
+        if (argPacks.ret instanceof DoipMessage)
+            return argPacks;
         argPacks.ret = JSONTool.convertMirrorToJson(argPacks.ret);
         return argPacks;
     }

src/main/java/org/bdware/sc/engine/hook/ReadMeHandler.java

@@ -13,10 +13,9 @@ import org.commonmark.parser.Parser;
 
 public class ReadMeHandler implements AnnotationHook {
     String getReadMeData(DesktopEngine desktopEngine, ContractRequest c) {
-        String fileReadme =
-                desktopEngine
-                        .getResources()
-                        .loadAsString("/assets/README.md"); // is "/README.md"  not"./README.md"!!!!
+        String fileReadme = desktopEngine.getResources().loadAsString("/assets/README.md"); // is
+                                                                                            // "/README.md"
+                                                                                            // not"./README.md"!!!!
         // System.out.println("fileReadme:" + fileReadme);
         if (null == fileReadme) {
             return "项目目录下无预览文档";
@@ -30,18 +29,11 @@ public class ReadMeHandler implements AnnotationHook {
                 while (visitor != null) {
                     if (visitor instanceof Heading) {
                         if (((Heading) visitor).getLevel() == 2) {
-                            if (((Text) (visitor.getFirstChild()))
-                                    .getLiteral()
+                            if (((Text) (visitor.getFirstChild())).getLiteral()
                                     .equals(targetFunction)) {
                                 FencedCodeBlock blockResult =
-                                        (FencedCodeBlock)
-                                                (visitor.getNext()
-                                                        .getNext()
-                                                        .getNext()
-                                                        .getNext()
-                                                        .getNext()
-                                                        .getNext()
-                                                        .getNext());
+                                        (FencedCodeBlock) (visitor.getNext().getNext().getNext()
+                                                .getNext().getNext().getNext().getNext());
                                 result = blockResult.getLiteral();
                                 break;
                             }

src/main/java/org/bdware/sc/engine/hook/ResultSchemaHandler.java

@@ -0,0 +1,85 @@
+package org.bdware.sc.engine.hook;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bdware.doip.codec.JsonDoipMessage;
+import org.bdware.doip.codec.doipMessage.DoipMessage;
+import org.bdware.sc.JSEngine;
+import org.bdware.sc.boundry.ScriptReturnException;
+import org.bdware.sc.node.AnnotationHook;
+import org.bdware.sc.node.AnnotationNode;
+import org.bdware.sc.node.ArgPacks;
+import org.bdware.sc.node.FunctionNode;
+import org.bdware.sc.util.JsonUtil;
+
+@YJSAnnotation(name = "ResultSchema")
+public class ResultSchemaHandler implements AnnotationHook {
+    private AnnotationNode a;
+    private static final Logger LOGGER = LogManager.getLogger(ResultSchemaHandler.class);
+
+    public ResultSchemaHandler(AnnotationNode annotationNode) {
+        a = annotationNode;
+    }
+
+    @Override
+    public ArgPacks handle(JSEngine desktopEngine, ArgPacks argPacks) throws ScriptReturnException {
+        Object ret = argPacks.ret;
+        if (ret != null) {
+            JsonElement je = null;
+            if (ret instanceof DoipMessage) {
+                JsonDoipMessage jo = JsonDoipMessage.fromDoipMessage((DoipMessage) ret);
+                je = JsonUtil.parseObjectAsJsonObject(jo);
+            } else if (ret instanceof JsonElement) {
+                je = (JsonElement) ret;
+            }
+            if (je == null) {
+                JsonObject jo = new JsonObject();
+                jo.addProperty("msg", "[Illegal Type] result should not be empty or null");
+                jo.addProperty("code", 1004);
+                throw new ScriptReturnException(jo);
+            }
+            ArgSchemaVisitor visitor;
+            if (je.isJsonObject())
+                visitor = new ArgSchemaVisitor(je.getAsJsonObject());
+            else {
+                try {
+                    JsonElement obj = JsonParser.parseString(je.getAsString());
+                    visitor = new ArgSchemaVisitor(obj);
+                    // IMPORTANT automatically convert arg type here
+                    argPacks.ret = obj;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    JsonObject jo = new JsonObject();
+                    jo.addProperty("msg", "[Illegal Type] result should be JSON");
+                    jo.add("errorResult", je);
+                    jo.addProperty("code", 1004);
+                    throw new ScriptReturnException(jo);
+                }
+            }
+            if (je.toString().isEmpty() && !a.getArgs().get(0).equals("")) {
+                JsonObject jo = new JsonObject();
+                jo.addProperty("msg", "[Empty result] result should not be empty");
+                jo.addProperty("code", 1003);
+                throw new ScriptReturnException(jo);
+            }
+            visitor.visit(JsonParser.parseString(a.getArgs().get(0)));
+            if (!visitor.getStatus()) {
+                JsonObject jo = new JsonObject();
+                jo.addProperty("msg", visitor.getException());
+                jo.addProperty("code", visitor.errorCode);
+                jo.add("errorResult", je);
+                jo.add("resultSchema", JsonParser.parseString(a.getArgs().get(0)));
+                throw new ScriptReturnException(jo);
+            }
+        }
+        return argPacks;
+    }
+
+    public static ResultSchemaHandler fromAnnotationNode(FunctionNode funNode,
+            AnnotationNode annoNode) {
+        return new ResultSchemaHandler(annoNode);
+    }
+}

src/main/java/org/bdware/sc/engine/setArgs/GetHomArgs.java

@@ -3,8 +3,7 @@ package org.bdware.sc.engine.setArgs;
 public class GetHomArgs {
     public String secretID;
 
-    public GetHomArgs() {
-    }
+    public GetHomArgs() {}
 
     public GetHomArgs(String secretID) {
         this.secretID = secretID;

src/main/java/org/bdware/sc/entity/DoipMessagePacker.java

@@ -1,6 +1,9 @@
 package org.bdware.sc.entity;
 
+import org.bdware.doip.codec.JsonDoipMessage;
 import org.bdware.doip.codec.doipMessage.DoipMessage;
+import org.bdware.sc.engine.JSONTool;
+import org.bdware.sc.util.JsonUtil;
 
 public class DoipMessagePacker {
     // the DoipMessagePacker is raised by http/doip
@@ -22,4 +25,9 @@ public class DoipMessagePacker {
     public void setSource(String source) {
         this.source = source;
     }
+
+    public Object toJSObject() {
+        return JSONTool.convertJsonElementToMirror(
+                JsonUtil.parseObject(JsonDoipMessage.fromDoipMessage(rawDoipMsg)));
+    }
 }

src/main/java/org/bdware/sc/handler/ContractHandler.java

@@ -104,8 +104,8 @@ public class ContractHandler extends MsgHandler implements Runnable {
 
     @Description("set members")
     public void setMembers(GetMessage msg, ResultCallback cb) {
-        cb.onResult(cs.setMembers(JsonUtil.fromJson(msg.arg, new TypeToken<List<String>>() {
-        }.getType())));
+        cb.onResult(cs.setMembers(
+                JsonUtil.fromJson(msg.arg, new TypeToken<List<String>>() {}.getType())));
     }
 
     @Description("get current contract name")

src/main/java/org/bdware/sc/handler/DOOPRequestHandler.java

@@ -1,56 +1,61 @@
 package org.bdware.sc.handler;
 
-import com.google.gson.Gson;
-import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
 import io.netty.channel.ChannelHandlerContext;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.bdware.doip.codec.JsonDoipMessage;
 import org.bdware.doip.codec.doipMessage.DoipMessage;
+import org.bdware.doip.codec.doipMessage.DoipMessageFactory;
+import org.bdware.doip.codec.doipMessage.DoipResponseCode;
+import org.bdware.doip.codec.doipMessage.HeaderParameter;
 import org.bdware.doip.codec.operations.BasicOperations;
 import org.bdware.doip.endpoint.server.DoipRequestHandler;
 import org.bdware.doip.endpoint.server.NettyServerHandler;
-import org.bdware.doip.endpoint.server.RepositoryHandler;
 import org.bdware.sc.ContractProcess;
 import org.bdware.sc.bean.ContractRequest;
-import org.bdware.sc.engine.hook.DOOPHandler;
+import org.bdware.sc.boundry.JavaScriptEntry;
+import org.bdware.sc.boundry.ScriptReturnException;
+import org.bdware.sc.crdt.SharableVarManager;
 import org.bdware.sc.entity.DoipMessagePacker;
 import org.bdware.sc.node.FunctionNode;
+import org.bdware.sc.util.JsonUtil;
 
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
 
-public class DOOPRequestHandler implements DoipRequestHandler, RepositoryHandler {
-    public Map<String, FunctionNode> doipOperationsMap;
+public class DOOPRequestHandler implements DoipRequestHandler {
     static Logger logger = LogManager.getLogger(NettyServerHandler.class);
-    static Gson gson;
-
-    public static DOOPRequestHandler instance;
+    public Map<String, FunctionNode> doipFunctionNodeMap;
 
     public DOOPRequestHandler() {
-        doipOperationsMap = new HashMap<>();
-        gson = new Gson();
+        doipFunctionNodeMap = new HashMap<>();
     }
 
-    public static DOOPRequestHandler createHandler() {
-        if(instance == null) {
-            instance = new DOOPRequestHandler();
+    public void addDoipOperation(FunctionNode function) throws Exception {
+        String operationName = function.getDoipOperationInfo().operationName;
+        if (doipFunctionNodeMap.containsKey(operationName)) {
+            throw new Exception("Contract is wrong: One DO operation maps multiple functions");
         }
-
-        return instance;
-    }
-
-    public void addDoipOperation(FunctionNode function) {
-        doipOperationsMap.put(function.getDoipOperationInfo().operationName, function);
+        doipFunctionNodeMap.put(operationName, function);
     }
 
     @Override
     public DoipMessage onRequest(ChannelHandlerContext ctx, DoipMessage msg) {
         String str = msg.header.parameters.operation;
+        if (msg.header != null
+                && msg.header.parameters.operation.equals(SharableVarManager.SHARABLEOP)) {
+            return SharableVarManager.instance.handleSyncMessage(msg);
+        }
         logger.debug("[Call operation] name: " + str);
         if (str != null) {
             FunctionNode fn;
-            fn = doipOperationsMap.get(str);
-            if (fn == null) fn = doipOperationsMap.get(BasicOperations.Unknown.getName());
+            fn = doipFunctionNodeMap.get(str);
+            if (fn == null)
+                fn = doipFunctionNodeMap.get(BasicOperations.Unknown.getName());
             if (fn != null) {
                 return buildRequestAndInvokeEngine(fn, msg);
             }
@@ -58,89 +63,55 @@ public class DOOPRequestHandler implements DoipRequestHandler, RepositoryHandler
         return null;
     }
 
-    @Override
-    public DoipMessage handleHello(DoipMessage request) {
-        FunctionNode fn = doipOperationsMap.get(BasicOperations.Hello.getName());
-        if (fn == null) fn = doipOperationsMap.get(BasicOperations.Unknown.getName());
-        if (fn != null) {
-            return buildRequestAndInvokeEngine(fn, request);
-        }
-        return null;
-    }
-
-    @Override
-    public DoipMessage handleListOps(DoipMessage request) {
-        FunctionNode fn = doipOperationsMap.get(BasicOperations.ListOps.getName());
-        if (fn == null) fn = doipOperationsMap.get(BasicOperations.Unknown.getName());
-        if (fn != null) {
-            return buildRequestAndInvokeEngine(fn, request);
-        }
-        return null;
-    }
-
-    @Override
-    public DoipMessage handleCreate(DoipMessage request) {
-        FunctionNode fn = doipOperationsMap.get(BasicOperations.Create.getName());
-        if (fn == null) fn = doipOperationsMap.get(BasicOperations.Unknown.getName());
-        if (fn != null) {
-            return buildRequestAndInvokeEngine(fn, request);
-        }
-        return null;
-    }
-
-    @Override
-    public DoipMessage handleUpdate(DoipMessage request) {
-        FunctionNode fn = doipOperationsMap.get(BasicOperations.Update.getName());
-        if (fn == null) fn = doipOperationsMap.get(BasicOperations.Unknown.getName());
-        if (fn != null) {
-            return buildRequestAndInvokeEngine(fn, request);
-        }
-        return null;
-    }
-
-    @Override
-    public DoipMessage handleDelete(DoipMessage request) {
-        FunctionNode fn = doipOperationsMap.get(BasicOperations.Delete.getName());
-        if (fn == null) fn = doipOperationsMap.get(BasicOperations.Unknown.getName());
-        if (fn != null) {
-            return buildRequestAndInvokeEngine(fn, request);
-        }
-        return null;
-    }
-
-    @Override
-    public DoipMessage handleRetrieve(DoipMessage request) {
-        FunctionNode fn = doipOperationsMap.get(BasicOperations.Retrieve.getName());
-        if (fn == null) fn = doipOperationsMap.get(BasicOperations.Unknown.getName());
-        if (fn != null) {
-            return buildRequestAndInvokeEngine(fn, request);
-        }
-        return null;
-    }
-
     public DoipMessage buildRequestAndInvokeEngine(FunctionNode fn, DoipMessage msg) {
         ContractRequest contractRequest = constructContractRequest(fn, msg);
         DoipMessagePacker arg = new DoipMessagePacker("doip", msg);
         try {
             // 改变调用的函数 + 构造DoipMessagePacker
-            Object ret = ContractProcess.instance.engine.executeWithoutLock(fn, contractRequest, arg);
-            return DOOPHandler.convertJsonElementToDoipMessage((JsonElement) ret, msg);
+            Object ret =
+                    ContractProcess.instance.engine.executeWithoutLock(fn, contractRequest, arg);
+            DoipMessage finalDoipMsg = (DoipMessage) ret;
+            finalDoipMsg.requestID = msg.requestID;
+            if (finalDoipMsg.header.parameters == null) {
+                finalDoipMsg.header.parameters = new HeaderParameter("", "");
+            }
+            if (finalDoipMsg.header.parameters.attributes == null) {
+                finalDoipMsg.header.parameters.attributes = new JsonObject();
+            }
+            finalDoipMsg.header.parameters.attributes.addProperty("nodeID",
+                    String.valueOf(JavaScriptEntry.shardingID));
+            return finalDoipMsg;
+        } catch (ScriptReturnException e) {
+            DoipMessageFactory.DoipMessageBuilder builder =
+                    new DoipMessageFactory.DoipMessageBuilder();
+            builder.createResponse(DoipResponseCode.Declined, msg);
+            builder.setBody(e.message.toString().getBytes(StandardCharsets.UTF_8));
+            logger.error("buildRequestAndInvokeEngine catch ScriptReturnException");
+            return builder.create();
         } catch (Exception e) {
-            e.printStackTrace();
+            ByteArrayOutputStream bo = new ByteArrayOutputStream();
+            e.printStackTrace(new PrintStream(bo));
+            DoipMessageFactory.DoipMessageBuilder builder =
+                    new DoipMessageFactory.DoipMessageBuilder();
+            builder.createResponse(DoipResponseCode.Declined, msg);
+            builder.setBody(bo.toByteArray());
+            builder.addAttributes("nodeID", String.valueOf(JavaScriptEntry.shardingID));
+            logger.error(
+                    "buildRequestAndInvokeEngine has something wrong, executeWithoutLock err or validateJsonElementRulesByArgSchemaVisitor err");
+            return builder.create();
         }
-
-        return null;
     }
 
     public ContractRequest constructContractRequest(FunctionNode fn, DoipMessage request) {
-        ContractRequest cr  = new ContractRequest();
+        ContractRequest cr = new ContractRequest();
         cr.setContractID("");
-        if(request.credential == null) {
+        if (request.credential == null) {
             cr.setRequester(null);
         } else {
             cr.setRequester(request.credential.getSigner());
         }
         cr.setAction(fn.functionName);
+        cr.setArg(JsonUtil.parseObjectAsJsonObject(JsonDoipMessage.fromDoipMessage(request)));
         return cr;
     }
 }

src/main/java/org/bdware/sc/memory/JSEDump.java

@@ -7,13 +7,13 @@ public class JSEDump implements Serializable {
     long ranSeed;
     int numsOfCopies;
 
-    public JSEDump(long id,long ra,int nums){
+    public JSEDump(long id, long ra, int nums) {
         invokeID = id;
         ranSeed = ra;
         numsOfCopies = nums;
     }
 
-    public void printContent(){
+    public void printContent() {
         System.out.println("invokeID=" + invokeID);
         System.out.println("ranSeed=" + ranSeed);
         System.out.println("numsOfCopies=" + numsOfCopies);

src/main/java/org/bdware/sc/memory/MOType.java

@@ -4,37 +4,38 @@ import jdk.internal.dynalink.beans.StaticClass;
 import wrp.jdk.nashorn.api.scripting.ScriptObjectMirror;
 
 public enum MOType {
-	String(true), Int(true), Double(true), Boolean(true),JSObject(false), JSArray(false), JavaObject(false), Method(false),
-	Undefined(true), JSFunction(false),JSStatic(false);
+    String(true), Int(true), Double(true), Boolean(true), JSObject(false), JSArray(
+            false), JavaObject(
+                    false), Method(false), Undefined(true), JSFunction(false), JSStatic(false);
 
-	private boolean isPrimitive;
+    private boolean isPrimitive;
 
-	MOType(boolean isPrimitive) {
-		this.isPrimitive = (isPrimitive);
-	}
+    MOType(boolean isPrimitive) {
+        this.isPrimitive = (isPrimitive);
+    }
 
-	public static MOType getType(Object obj) {
-		if (obj == null)
-			return Undefined;
-		if (obj instanceof Integer) {
-			return Int;
-		} else if (obj instanceof Double) {
-			return Double;
-		} else if (obj instanceof String) {
-			return String;
-		} else if (obj instanceof ScriptObjectMirror) {
-			// ------
-			return JSObject;
-		}else if(obj instanceof StaticClass) {
-			return JSStatic;
-		}else if(obj instanceof Boolean){
-			return Boolean;
-		}
-		return JSObject;
-	}
+    public static MOType getType(Object obj) {
+        if (obj == null)
+            return Undefined;
+        if (obj instanceof Integer) {
+            return Int;
+        } else if (obj instanceof Double) {
+            return Double;
+        } else if (obj instanceof String) {
+            return String;
+        } else if (obj instanceof ScriptObjectMirror) {
+            // ------
+            return JSObject;
+        } else if (obj instanceof StaticClass) {
+            return JSStatic;
+        } else if (obj instanceof Boolean) {
+            return Boolean;
+        }
+        return JSObject;
+    }
 
-	public boolean isPrimitive() {
-		return isPrimitive;
-	}
+    public boolean isPrimitive() {
+        return isPrimitive;
+    }
 
-}
+}

src/main/java/org/bdware/sc/memory/MemoryArrayObject.java

@@ -1,12 +1,12 @@
 package org.bdware.sc.memory;
 
-public class MemoryArrayObject extends MemoryJSObject{
+public class MemoryArrayObject extends MemoryJSObject {
 
-	private static final long serialVersionUID = -5805776423219733634L;
+    private static final long serialVersionUID = -5805776423219733634L;
 
-	public MemoryArrayObject(long id) {
-		super(id);
-		type = MOType.JSArray;
-	}
+    public MemoryArrayObject(long id) {
+        super(id);
+        type = MOType.JSArray;
+    }
 
 }

src/main/java/org/bdware/sc/memory/MemoryDump.java

@@ -19,9 +19,9 @@ import java.util.Map.Entry;
 
 public class MemoryDump implements Serializable {
     transient long id;
-    transient Map<Object, Long> allocated;  //js对象，id
+    transient Map<Object, Long> allocated; // js对象，id
 
-    Map<Long, MemoryObject> objects;  //id,memory对象
+    Map<Long, MemoryObject> objects; // id,memory对象
     JSEDump jseDump;
 
     transient Map<Long, Object> recreate;
@@ -99,12 +99,11 @@ public class MemoryDump implements Serializable {
         id++;
         currID = id;
         if (obj.getClass() == jdk.internal.dynalink.beans.StaticClass.class) {
-			/*
-			String obj2 = "jdk.internal.dynalink.beans.StaticClass.class";
-			if (allocated.containsKey(obj2))
-				return allocated.get(obj2);
-			allocated.put(obj2, currID);
-			 */
+            /*
+             * String obj2 = "jdk.internal.dynalink.beans.StaticClass.class"; if
+             * (allocated.containsKey(obj2)) return allocated.get(obj2); allocated.put(obj2,
+             * currID);
+             */
         } else {
             if (allocated.containsKey(obj))
                 return allocated.get(obj);
@@ -137,12 +136,12 @@ public class MemoryDump implements Serializable {
         } else if (obj.getClass() == wrp.jdk.nashorn.internal.runtime.Undefined.class) {
 
         } else if (obj.getClass() == jdk.internal.dynalink.beans.StaticClass.class) {
-            //regard as String
+            // regard as String
 
-//			MemoryObject mo = new MemoryObject(currID);
-//			mo.type = MOType.String;
-//			mo.data = "jdk.internal.dynalink.beans.StaticClass";
-//			objects.put(currID, mo);
+            // MemoryObject mo = new MemoryObject(currID);
+            // mo.type = MOType.String;
+            // mo.data = "jdk.internal.dynalink.beans.StaticClass";
+            // objects.put(currID, mo);
         } else {
             MOType type = MOType.getType(obj);
             if (type.isPrimitive()) {
@@ -151,7 +150,8 @@ public class MemoryDump implements Serializable {
                 mo.data = obj;
                 objects.put(currID, mo);
             } else
-                System.out.println("[MemoryDump] Allocat MetType:" + obj.getClass() + " now id=" + currID);
+                System.out.println(
+                        "[MemoryDump] Allocat MetType:" + obj.getClass() + " now id=" + currID);
 
         }
         return currID;
@@ -203,15 +203,18 @@ public class MemoryDump implements Serializable {
             }
             switch (mo.type) {
                 case JSArray:
-                    obj = ScriptObjectMirror.wrap(Global.allocate(new int[0]), JavaScriptEntry.getEngineGlobal());
+                    obj = ScriptObjectMirror.wrap(Global.allocate(new int[0]),
+                            JavaScriptEntry.getEngineGlobal());
                     break;
                 case JSObject:
-                    obj = ScriptObjectMirror.wrap(new JO(PropertyMap.newMap()), JavaScriptEntry.getEngineGlobal());
+                    obj = ScriptObjectMirror.wrap(new JO(PropertyMap.newMap()),
+                            JavaScriptEntry.getEngineGlobal());
                     break;
                 case JSFunction:
                     break;
                 case String:
                 case Int:
+                case Boolean:
                     obj = mo.data;
                     break;
                 case Double:
@@ -225,4 +228,4 @@ public class MemoryDump implements Serializable {
             recreate.put(key, obj);
         }
     }
-}
+}

src/main/java/org/bdware/sc/memory/MemoryDumpUtil.java

@@ -13,7 +13,7 @@ import java.util.zip.GZIPOutputStream;
 
 public class MemoryDumpUtil {
     public static final String STATELESS_MEMORY = "statelessContractMemory";
-    public static AtomicInteger checkPointCounter;   //用于common模式下的检查点计数
+    public static AtomicInteger checkPointCounter; // 用于common模式下的检查点计数
     NashornScriptEngine engine;
     String dumpContent;
     MemoryDump memoryDump = null;
@@ -30,11 +30,12 @@ public class MemoryDumpUtil {
             GZIPInputStream gzin = new GZIPInputStream(fileout);
             reader = new ObjectInputStream(gzin);
             MemoryDump memoryDump = new MemoryDump();
-            //memoryDump.objects = (Map<Long, MemoryObject>) reader.readObject();
+            // memoryDump.objects = (Map<Long, MemoryObject>) reader.readObject();
             memoryDump = (MemoryDump) reader.readObject();
             reader.close();
             String ret = JsonUtil.toPrettyJson(memoryDump.objects);
-            ret += ("<seperate>" + memoryDump.jseDump.invokeID + ";" + memoryDump.jseDump.ranSeed + ";" + memoryDump.jseDump.numsOfCopies + "");
+            ret += ("<seperate>" + memoryDump.jseDump.invokeID + ";" + memoryDump.jseDump.ranSeed
+                    + ";" + memoryDump.jseDump.numsOfCopies + "");
             return ret;
         } catch (IOException | ClassNotFoundException e) {
             e.printStackTrace();
@@ -43,23 +44,14 @@ public class MemoryDumpUtil {
     }
 
     /*
-    public static String getContentFromFile2(String path) {
-    	File file = new File(path);
-    	ObjectInputStream reader;
-    	try {
-    		FileInputStream fileout = new FileInputStream(file);
-    		reader = new ObjectInputStream(fileout);
-    		String ret = (String)reader.readObject();
-    		reader.close();
-    		return ret;
-    	} catch (IOException | ClassNotFoundException e) {
-    		e.printStackTrace();
-    	}
-    	return null;
-    }
-    */
+     * public static String getContentFromFile2(String path) { File file = new File(path);
+     * ObjectInputStream reader; try { FileInputStream fileout = new FileInputStream(file); reader =
+     * new ObjectInputStream(fileout); String ret = (String)reader.readObject(); reader.close();
+     * return ret; } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } return
+     * null; }
+     */
 
-    //stateful 表示合约是有/无状态合约
+    // stateful 表示合约是有/无状态合约
     public String dumpMemory(String path, boolean stateful) {
         synchronized (engine) {
             String ret;
@@ -73,16 +65,21 @@ public class MemoryDumpUtil {
                     long id = memoryDump.allocate(obj);
                     root.addField(key, id);
                 }
-                memoryDump.jseDump = new JSEDump(JavaScriptEntry.invokeID, Long.parseLong(JavaScriptEntry.currentSyncUtil.contractID), JavaScriptEntry.numOfCopies);
+                memoryDump.jseDump = new JSEDump(JavaScriptEntry.invokeID,
+                        Long.parseLong(JavaScriptEntry.currentSyncUtil.contractID),
+                        JavaScriptEntry.numOfCopies);
                 ret = JsonUtil.toPrettyJson(memoryDump.objects);
-            } else { //无状态合约
-                memoryDump.jseDump = new JSEDump(JavaScriptEntry.invokeID, Long.parseLong(JavaScriptEntry.currentSyncUtil.contractID), JavaScriptEntry.numOfCopies);
+            } else { // 无状态合约
+                memoryDump.jseDump = new JSEDump(JavaScriptEntry.invokeID,
+                        Long.parseLong(JavaScriptEntry.currentSyncUtil.contractID),
+                        JavaScriptEntry.numOfCopies);
                 memoryDump.objects.clear();
                 ret = JsonUtil.toPrettyJson(memoryDump.objects);
             }
 
             ret += "--seperate--";
-            ret += (memoryDump.jseDump.invokeID + ";" + memoryDump.jseDump.ranSeed + ";" + memoryDump.jseDump.numsOfCopies);
+            ret += (memoryDump.jseDump.invokeID + ";" + memoryDump.jseDump.ranSeed + ";"
+                    + memoryDump.jseDump.numsOfCopies);
 
             if (path == null || path.equals("")) {
                 return ret;
@@ -90,13 +87,14 @@ public class MemoryDumpUtil {
 
             File mem = new File(path);
             File parent = mem.getParentFile();
-            if (!parent.exists()) parent.mkdirs();
+            if (!parent.exists())
+                parent.mkdirs();
             ObjectOutputStream writer;
             try {
                 FileOutputStream fileout = new FileOutputStream(mem);
                 GZIPOutputStream out = new GZIPOutputStream(fileout);
                 writer = new ObjectOutputStream(out);
-                //writer.writeObject(memoryDump.objects);
+                // writer.writeObject(memoryDump.objects);
                 writer.writeObject(memoryDump);
                 writer.flush();
                 writer.close();
@@ -112,44 +110,25 @@ public class MemoryDumpUtil {
 
 
     /*
-    public String dumpMemory(String path) {
-    	memoryDump = new MemoryDump();
-    	Bindings bindings = engine.getBindings(ScriptContext.ENGINE_SCOPE);
-    	System.out.println("[MemoryDumpUtil] bindings size=" + bindings.size());
-    	MemoryJSObject root = memoryDump.getRoot();
-    	for (String key : bindings.keySet()) {
-    		System.out.println("[MemoryDumpUtil] dumpMemory " + key);
-    		Object obj = bindings.get(key);
-    		long id = memoryDump.allocate(obj);
-    		root.addField(key, id);
-
-    		System.out.println("[root addFiled] key=" + key + "   id=" + id);
-    	}
-    	String ret = JsonUtil.toPrettyJson(memoryDump);
-    	dumpContent = ret;
-
-    	if(path == null || path.equals("")) {
-    		return ret;
-    	}
-
-    	File mem = new File(path);
-    	File parent = mem.getParentFile();
-    	if (!parent.exists())
-    		parent.mkdirs();
-    	ObjectOutputStream writer;
-    	try {
-    		FileOutputStream fileout = new FileOutputStream(mem);
-    		writer = new ObjectOutputStream(fileout);
-    		writer.writeObject(dumpContent);
-
-    		writer.flush();
-    		writer.close();
-    	} catch (IOException e) {
-    		e.printStackTrace();
-    	}
-
-    	memoryDump = null;
-    	return ret;
-    }
-    */
+     * public String dumpMemory(String path) { memoryDump = new MemoryDump(); Bindings bindings =
+     * engine.getBindings(ScriptContext.ENGINE_SCOPE);
+     * System.out.println("[MemoryDumpUtil] bindings size=" + bindings.size()); MemoryJSObject root
+     * = memoryDump.getRoot(); for (String key : bindings.keySet()) {
+     * System.out.println("[MemoryDumpUtil] dumpMemory " + key); Object obj = bindings.get(key);
+     * long id = memoryDump.allocate(obj); root.addField(key, id);
+     * 
+     * System.out.println("[root addFiled] key=" + key + "   id=" + id); } String ret =
+     * JsonUtil.toPrettyJson(memoryDump); dumpContent = ret;
+     * 
+     * if(path == null || path.equals("")) { return ret; }
+     * 
+     * File mem = new File(path); File parent = mem.getParentFile(); if (!parent.exists())
+     * parent.mkdirs(); ObjectOutputStream writer; try { FileOutputStream fileout = new
+     * FileOutputStream(mem); writer = new ObjectOutputStream(fileout);
+     * writer.writeObject(dumpContent);
+     * 
+     * writer.flush(); writer.close(); } catch (IOException e) { e.printStackTrace(); }
+     * 
+     * memoryDump = null; return ret; }
+     */
 }

src/main/java/org/bdware/sc/memory/MemoryFunctionObject.java

@@ -4,16 +4,16 @@ import java.util.HashMap;
 import java.util.Map;
 
 public class MemoryFunctionObject extends MemoryObject {
-	private static final long serialVersionUID = 5169037078273981613L;
-	Map<String, Long> fields;
-	
-	public MemoryFunctionObject(long id) {
-		super(id);
-		fields = new HashMap<>();
-		type = MOType.JSFunction;
-	}
-	
-	public void addField(String key, long id) {
-		fields.put(key, id);
-	}
-}
+    private static final long serialVersionUID = 5169037078273981613L;
+    Map<String, Long> fields;
+
+    public MemoryFunctionObject(long id) {
+        super(id);
+        fields = new HashMap<>();
+        type = MOType.JSFunction;
+    }
+
+    public void addField(String key, long id) {
+        fields.put(key, id);
+    }
+}

src/main/java/org/bdware/sc/memory/MemoryJSObject.java

@@ -1,19 +1,18 @@
 package org.bdware.sc.memory;
 
 import java.util.LinkedHashMap;
-import java.util.Map;
 
 public class MemoryJSObject extends MemoryObject {
-	private static final long serialVersionUID = -2290414347562477503L;
-	LinkedHashMap<String, Long> fields;
+    private static final long serialVersionUID = -2290414347562477503L;
+    LinkedHashMap<String, Long> fields;
 
-	public MemoryJSObject(long id) {
-		super(id);
-		fields = new LinkedHashMap<>();
-		type = MOType.JSObject;
-	}
+    public MemoryJSObject(long id) {
+        super(id);
+        fields = new LinkedHashMap<>();
+        type = MOType.JSObject;
+    }
 
-	public void addField(String key, long id) {
-		fields.put(key, id);
-	}
-}
+    public void addField(String key, long id) {
+        fields.put(key, id);
+    }
+}