wowok 1.1.2 → 1.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (22) hide show
  1. package/README.md +3 -2
  2. package/dist/exception.d.ts +2 -1
  3. package/dist/exception.d.ts.map +1 -1
  4. package/dist/exception.js +1 -0
  5. package/dist/guard.d.ts +29 -25
  6. package/dist/guard.d.ts.map +1 -1
  7. package/dist/guard.js +341 -352
  8. package/dist/passport.d.ts +32 -14
  9. package/dist/passport.d.ts.map +1 -1
  10. package/dist/passport.js +467 -78
  11. package/dist/protocol.d.ts +46 -38
  12. package/dist/protocol.d.ts.map +1 -1
  13. package/dist/protocol.js +59 -48
  14. package/dist/utils.d.ts +17 -1
  15. package/dist/utils.d.ts.map +1 -1
  16. package/dist/utils.js +54 -0
  17. package/package.json +3 -2
  18. package/src/exception.ts +1 -0
  19. package/src/guard.ts +349 -365
  20. package/src/passport.ts +484 -85
  21. package/src/protocol.ts +69 -51
  22. package/src/utils.ts +59 -1
package/dist/guard.js CHANGED
@@ -1,40 +1,43 @@
1
1
  import { BCS } from '@mysten/bcs';
2
- import { MODULES, ContextType, ValueType, OperatorType } from './protocol';
2
+ import { MODULES, ContextType, ValueType, OperatorType, SER_VALUE } from './protocol';
3
3
  import { concatenate, array_equal } from './utils';
4
4
  import { IsValidDesription, Bcs, IsValidInt, IsValidAddress } from './utils';
5
5
  import { ERROR, Errors } from './exception';
6
6
  export class Guard {
7
7
  static MAX_INPUT_LENGTH = 2048;
8
- static launch(protocol, creation) {
9
- if (!IsValidDesription(creation.description)) {
8
+ static launch(protocol, description, maker) {
9
+ if (!maker.IsReady()) {
10
+ ERROR(Errors.InvalidParam, 'launch maker');
11
+ }
12
+ if (!IsValidDesription(description)) {
10
13
  ERROR(Errors.IsValidDesription);
11
14
  }
12
- if (creation.input.length == 0 || creation.input.length > Guard.MAX_INPUT_LENGTH) {
13
- ERROR(Errors.InvalidParam, 'creation.input');
15
+ let bcs_input = maker.get_input()[0];
16
+ let variables = maker.get_variable();
17
+ if (bcs_input.length == 0 || bcs_input.length > Guard.MAX_INPUT_LENGTH) {
18
+ ERROR(Errors.InvalidParam, 'launch input');
14
19
  }
15
20
  let bValid = true;
16
- creation?.variables?.forEach((v, k) => {
17
- if (!GuardVariableMaker.IsValidIndentifier(k))
18
- bValid = false;
19
- if (!GuardVariableMaker.IsValidGuardVirableType(v.type))
21
+ variables?.forEach((v, k) => {
22
+ if (!GuardVariableHelper.IsValidIndentifier(k))
20
23
  bValid = false;
21
24
  if (!v.value && !v.witness)
22
25
  bValid = false;
23
26
  });
24
27
  if (!bValid) {
25
- ERROR(Errors.InvalidParam, 'creation.variables');
28
+ ERROR(Errors.InvalidParam, 'launch variables');
26
29
  }
27
30
  let txb = protocol.CurrentSession();
28
- let input = new Uint8Array(creation.input); // copy new uint8array to reserve!
31
+ let input = new Uint8Array(bcs_input); // copy new uint8array to reserve!
29
32
  // reserve the bytes for guard
30
33
  let guard = txb.moveCall({
31
34
  target: protocol.GuardFn('new'),
32
- arguments: [txb.pure(creation.description, BCS.STRING), txb.pure([].slice.call(input.reverse()))],
35
+ arguments: [txb.pure(description, BCS.STRING), txb.pure([].slice.call(input.reverse()))],
33
36
  });
34
- creation?.variables?.forEach((v, k) => {
35
- if (v.type == OperatorType.TYPE_FUTURE_QUERY || v.type == ContextType.TYPE_CONTEXT_FUTURE_ID) {
37
+ variables?.forEach((v, k) => {
38
+ if (v.type == ContextType.TYPE_WITNESS_ID) {
36
39
  if (!v.witness) {
37
- ERROR(Errors.InvalidParam, 'creation.variables.type');
40
+ ERROR(Errors.InvalidParam, 'variables type');
38
41
  }
39
42
  txb.moveCall({
40
43
  target: protocol.GuardFn("variable_add"),
@@ -43,7 +46,7 @@ export class Guard {
43
46
  }
44
47
  else {
45
48
  if (!v.value) {
46
- ERROR(Errors.InvalidParam, 'creation.variables.type');
49
+ ERROR(Errors.InvalidParam, 'variables type');
47
50
  }
48
51
  txb.moveCall({
49
52
  target: protocol.GuardFn("variable_add"),
@@ -70,156 +73,138 @@ export class Guard {
70
73
  }
71
74
  static QUERIES = [
72
75
  // module, 'name', 'id', [input], output
73
- [MODULES.permission, 'builder', 1, [], ValueType.TYPE_STATIC_address],
74
- [MODULES.permission, 'is_admin', 2, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
75
- [MODULES.permission, 'has_rights', 3, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_bool],
76
- [MODULES.permission, 'contains_address', 4, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
77
- [MODULES.permission, 'contains_index', 5, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_bool],
78
- [MODULES.permission, 'contains_guard', 6, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_bool],
79
- [MODULES.permission, 'contains_guard', 7, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_address],
80
- [MODULES.permission, 'entity_count', 8, [], ValueType.TYPE_STATIC_u64],
81
- [MODULES.permission, 'admin_count', 9, [], ValueType.TYPE_STATIC_u64],
82
- [MODULES.repository, 'permission', 1, [], ValueType.TYPE_STATIC_address],
83
- [MODULES.repository, 'policy_contains', 2, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
84
- [MODULES.repository, 'policy_has_permission_index', 3, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
85
- [MODULES.repository, 'policy_permission_index', 4, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64],
86
- [MODULES.repository, 'policy_value_type', 5, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u8],
87
- [MODULES.repository, 'contains_id', 6, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
88
- [MODULES.repository, 'contains_value', 7, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
89
- [MODULES.repository, 'value_without_type', 8, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_vec_u8],
90
- [MODULES.repository, 'value', 9, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_vec_u8],
91
- [MODULES.repository, 'type', 10, [], ValueType.TYPE_STATIC_u8],
92
- [MODULES.repository, 'policy_mode', 11, [], ValueType.TYPE_STATIC_u8],
93
- [MODULES.repository, 'reference_count', 12, [], ValueType.TYPE_STATIC_u64],
94
- [MODULES.repository, 'has_reference', 13, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
95
- [MODULES.machine, 'permission', 1, [], ValueType.TYPE_STATIC_address],
96
- [MODULES.machine, 'has_paused', 2, [], ValueType.TYPE_STATIC_bool],
97
- [MODULES.machine, 'has_published', 3, [], ValueType.TYPE_STATIC_bool],
98
- [MODULES.machine, 'consensus_repositories_contains', 5, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
99
- [MODULES.machine, 'has_endpoint', 6, [], ValueType.TYPE_STATIC_bool],
100
- [MODULES.machine, 'endpoint', 7, [], ValueType.TYPE_STATIC_vec_u8],
101
- [MODULES.progress, 'machine', 1, [], ValueType.TYPE_STATIC_address],
102
- [MODULES.progress, 'current', 2, [], ValueType.TYPE_STATIC_vec_u8],
103
- [MODULES.progress, 'has_parent', 3, [], ValueType.TYPE_STATIC_bool],
104
- [MODULES.progress, 'parent', 4, [], ValueType.TYPE_STATIC_address],
105
- [MODULES.progress, 'has_task', 5, [], ValueType.TYPE_STATIC_bool],
106
- [MODULES.progress, 'task', 6, [], ValueType.TYPE_STATIC_address],
107
- [MODULES.progress, 'has_namedOperator', 7, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
108
- [MODULES.progress, 'namedOperator_contains', 8, [ValueType.TYPE_STATIC_vec_u8, ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
109
- [MODULES.progress, 'has_context_repository', 9, [], ValueType.TYPE_STATIC_bool],
110
- [MODULES.progress, 'context_repository', 10, [], ValueType.TYPE_STATIC_address],
111
- [MODULES.demand, 'permission', 1, [], ValueType.TYPE_STATIC_address],
112
- [MODULES.demand, 'has_time_expire', 2, [], ValueType.TYPE_STATIC_bool],
113
- [MODULES.demand, 'time_expire', 3, [], ValueType.TYPE_STATIC_u64],
114
- [MODULES.demand, 'earnest_count', 4, [], ValueType.TYPE_STATIC_u64],
115
- [MODULES.demand, 'has_guard', 5, [], ValueType.TYPE_STATIC_bool],
116
- [MODULES.demand, 'guard', 6, [], ValueType.TYPE_STATIC_address],
117
- [MODULES.demand, 'has_yes', 7, [], ValueType.TYPE_STATIC_bool],
118
- [MODULES.demand, 'yes', 8, [], ValueType.TYPE_STATIC_address],
119
- [MODULES.demand, 'presenters_count', 9, [], ValueType.TYPE_STATIC_u64],
120
- [MODULES.demand, 'has_presenter', 10, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
121
- [MODULES.demand, 'persenter', 11, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_address],
122
- [MODULES.order, 'amount', 1, [], ValueType.TYPE_STATIC_u64],
123
- [MODULES.order, 'payer', 2, [], ValueType.TYPE_STATIC_address],
124
- [MODULES.order, 'service', 3, [], ValueType.TYPE_STATIC_address],
125
- [MODULES.order, 'has_progress', 4, [], ValueType.TYPE_STATIC_bool],
126
- [MODULES.order, 'progress', 5, [], ValueType.TYPE_STATIC_address],
127
- [MODULES.order, 'has_requred_info', 6, [], ValueType.TYPE_STATIC_bool],
128
- [MODULES.order, 'requred_info_service_pubkey', 7, [], ValueType.TYPE_STATIC_vec_u8],
129
- [MODULES.order, 'requred_info_customer_pubkey', 8, [], ValueType.TYPE_STATIC_vec_u8],
130
- [MODULES.order, 'requred_info_info', 9, [], ValueType.TYPE_STATIC_vec_vec_u8],
131
- [MODULES.order, 'has_discount', 10, [], ValueType.TYPE_STATIC_bool],
132
- [MODULES.order, 'discount', 11, [], ValueType.TYPE_STATIC_address],
133
- [MODULES.order, 'balance', 12, [], ValueType.TYPE_STATIC_u64],
134
- [MODULES.order, 'bRefunded', 13, [], ValueType.TYPE_STATIC_u8],
135
- [MODULES.order, 'bWithdrawed', 14, [], ValueType.TYPE_STATIC_u8],
136
- [MODULES.service, 'permission', 1, [], ValueType.TYPE_STATIC_address],
137
- [MODULES.service, 'payee', 2, [], ValueType.TYPE_STATIC_address],
138
- [MODULES.service, 'has_buy_guard', 3, [], ValueType.TYPE_STATIC_bool],
139
- [MODULES.service, 'buy_guard', 4, [], ValueType.TYPE_STATIC_address],
140
- [MODULES.service, 'repository_contains', 5, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
141
- [MODULES.service, 'has_withdraw_guard', 6, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
142
- [MODULES.service, 'withdraw_guard_percent', 7, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
143
- [MODULES.service, 'has_refund_guard', 8, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
144
- [MODULES.service, 'refund_guard_percent', 9, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
145
- [MODULES.service, 'has_sale', 10, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
146
- [MODULES.service, 'sale_price', 11, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64],
147
- [MODULES.service, 'sale_stock', 12, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64],
148
- [MODULES.service, 'has_machine', 13, [], ValueType.TYPE_STATIC_bool],
149
- [MODULES.service, 'machine', 14, [], ValueType.TYPE_STATIC_address],
150
- [MODULES.service, 'bPaused', 15, [], ValueType.TYPE_STATIC_bool],
151
- [MODULES.service, 'bPublished', 16, [], ValueType.TYPE_STATIC_bool],
152
- [MODULES.service, 'has_required', 17, [], ValueType.TYPE_STATIC_bool],
153
- [MODULES.service, 'requrired_pubkey', 18, [], ValueType.TYPE_STATIC_vec_u8],
154
- [MODULES.service, 'requrired_info', 19, [], ValueType.TYPE_STATIC_vec_vec_u8],
155
- [MODULES.reward, 'permission', 1, [], ValueType.TYPE_STATIC_address],
156
- [MODULES.reward, 'rewards_count_remain', 2, [], ValueType.TYPE_STATIC_u64],
157
- [MODULES.reward, 'rewards_count_supplied', 3, [], ValueType.TYPE_STATIC_u64],
158
- [MODULES.reward, 'guard_count', 4, [], ValueType.TYPE_STATIC_u64],
159
- [MODULES.reward, 'has_guard', 5, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
160
- [MODULES.reward, 'guard_portions', 6, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
161
- [MODULES.reward, 'time_expire', 7, [], ValueType.TYPE_STATIC_u64],
162
- [MODULES.reward, 'has_claimed', 8, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
163
- [MODULES.reward, 'claimed', 9, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
164
- [MODULES.reward, 'has_claimed_count', 10, [], ValueType.TYPE_STATIC_u64],
165
- [MODULES.reward, 'is_sponsor', 11, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
166
- [MODULES.reward, 'sponsor', 12, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
167
- [MODULES.reward, 'sponsor_count', 13, [], ValueType.TYPE_STATIC_u64],
168
- [MODULES.reward, 'bAllowRepeatClaim', 14, [], ValueType.TYPE_STATIC_bool],
169
- [MODULES.vote, 'permission', 1, [], ValueType.TYPE_STATIC_address],
170
- [MODULES.vote, 'bOptions_locked_for_voting', 2, [], ValueType.TYPE_STATIC_bool],
171
- [MODULES.vote, 'bdeadline_locked', 3, [], ValueType.TYPE_STATIC_bool],
172
- [MODULES.vote, 'bLockedGuard', 4, [], ValueType.TYPE_STATIC_bool],
173
- [MODULES.vote, 'max_choice_count', 5, [], ValueType.TYPE_STATIC_u8],
174
- [MODULES.vote, 'deadline', 6, [], ValueType.TYPE_STATIC_u64],
175
- [MODULES.vote, 'has_reference', 7, [], ValueType.TYPE_STATIC_bool],
176
- [MODULES.vote, 'reference', 8, [], ValueType.TYPE_STATIC_address],
177
- [MODULES.vote, 'has_guard', 9, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
178
- [MODULES.vote, 'guard', 10, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
179
- [MODULES.vote, 'voted', 11, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
180
- [MODULES.vote, 'voted_weight', 12, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
181
- [MODULES.vote, 'has_agree', 13, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
182
- [MODULES.vote, 'agree_has_object', 14, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
183
- [MODULES.vote, 'agree_object', 15, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_address],
184
- [MODULES.vote, 'agree_count', 16, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64],
185
- [MODULES.vote, 'agree_votes', 17, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64],
186
- [MODULES.vote, 'voted_count', 18, [], ValueType.TYPE_STATIC_u64],
187
- [MODULES.vote, 'top1_name_by_count', 19, [], ValueType.TYPE_STATIC_vec_u8],
188
- [MODULES.vote, 'top1_count', 20, [], ValueType.TYPE_STATIC_u64],
189
- [MODULES.vote, 'top1_name_by_votes', 21, [], ValueType.TYPE_STATIC_vec_u8],
190
- [MODULES.vote, 'top1_votes', 22, [], ValueType.TYPE_STATIC_u64],
76
+ [MODULES.permission, 'builder', 1, [], ValueType.TYPE_ADDRESS],
77
+ [MODULES.permission, 'is_admin', 2, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
78
+ [MODULES.permission, 'has_rights', 3, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
79
+ [MODULES.permission, 'contains_address', 4, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
80
+ [MODULES.permission, 'contains_index', 5, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
81
+ [MODULES.permission, 'contains_guard', 6, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
82
+ [MODULES.permission, 'contains_guard', 7, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_ADDRESS],
83
+ [MODULES.permission, 'entity_count', 8, [], ValueType.TYPE_U64],
84
+ [MODULES.permission, 'admin_count', 9, [], ValueType.TYPE_U64],
85
+ [MODULES.repository, 'permission', 11, [], ValueType.TYPE_ADDRESS],
86
+ [MODULES.repository, 'policy_contains', 12, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
87
+ [MODULES.repository, 'policy_has_permission_index', 13, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
88
+ [MODULES.repository, 'policy_permission_index', 14, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64],
89
+ [MODULES.repository, 'policy_value_type', 15, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U8],
90
+ [MODULES.repository, 'contains_id', 16, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
91
+ [MODULES.repository, 'contains_value', 17, [ValueType.TYPE_ADDRESS, ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
92
+ [MODULES.repository, 'value_without_type', 18, [ValueType.TYPE_ADDRESS, ValueType.TYPE_VEC_U8], ValueType.TYPE_VEC_U8],
93
+ [MODULES.repository, 'value', 19, [ValueType.TYPE_ADDRESS, ValueType.TYPE_VEC_U8], ValueType.TYPE_VEC_U8],
94
+ [MODULES.repository, 'type', 20, [], ValueType.TYPE_U8],
95
+ [MODULES.repository, 'policy_mode', 21, [], ValueType.TYPE_U8],
96
+ [MODULES.repository, 'reference_count', 22, [], ValueType.TYPE_U64],
97
+ [MODULES.repository, 'has_reference', 23, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
98
+ [MODULES.machine, 'permission', 31, [], ValueType.TYPE_ADDRESS],
99
+ [MODULES.machine, 'has_paused', 32, [], ValueType.TYPE_BOOL],
100
+ [MODULES.machine, 'has_published', 33, [], ValueType.TYPE_BOOL],
101
+ [MODULES.machine, 'consensus_repositories_contains', 34, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
102
+ [MODULES.machine, 'has_endpoint', 35, [], ValueType.TYPE_BOOL],
103
+ [MODULES.machine, 'endpoint', 36, [], ValueType.TYPE_VEC_U8],
104
+ [MODULES.progress, 'machine', 51, [], ValueType.TYPE_ADDRESS],
105
+ [MODULES.progress, 'current', 52, [], ValueType.TYPE_VEC_U8],
106
+ [MODULES.progress, 'has_parent', 53, [], ValueType.TYPE_BOOL],
107
+ [MODULES.progress, 'parent', 54, [], ValueType.TYPE_ADDRESS],
108
+ [MODULES.progress, 'has_task', 55, [], ValueType.TYPE_BOOL],
109
+ [MODULES.progress, 'task', 56, [], ValueType.TYPE_ADDRESS],
110
+ [MODULES.progress, 'has_namedOperator', 57, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
111
+ [MODULES.progress, 'namedOperator_contains', 58, [ValueType.TYPE_VEC_U8, ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
112
+ [MODULES.progress, 'has_context_repository', 59, [], ValueType.TYPE_BOOL],
113
+ [MODULES.progress, 'context_repository', 60, [], ValueType.TYPE_ADDRESS],
114
+ [MODULES.demand, 'permission', 71, [], ValueType.TYPE_ADDRESS],
115
+ [MODULES.demand, 'has_time_expire', 72, [], ValueType.TYPE_BOOL],
116
+ [MODULES.demand, 'time_expire', 73, [], ValueType.TYPE_U64],
117
+ [MODULES.demand, 'earnest_count', 74, [], ValueType.TYPE_U64],
118
+ [MODULES.demand, 'has_guard', 75, [], ValueType.TYPE_BOOL],
119
+ [MODULES.demand, 'guard', 76, [], ValueType.TYPE_ADDRESS],
120
+ [MODULES.demand, 'has_yes', 77, [], ValueType.TYPE_BOOL],
121
+ [MODULES.demand, 'yes', 78, [], ValueType.TYPE_ADDRESS],
122
+ [MODULES.demand, 'presenters_count', 79, [], ValueType.TYPE_U64],
123
+ [MODULES.demand, 'has_presenter', 80, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
124
+ [MODULES.demand, 'persenter', 81, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS],
125
+ [MODULES.order, 'amount', 91, [], ValueType.TYPE_U64],
126
+ [MODULES.order, 'payer', 92, [], ValueType.TYPE_ADDRESS],
127
+ [MODULES.order, 'service', 93, [], ValueType.TYPE_ADDRESS],
128
+ [MODULES.order, 'has_progress', 94, [], ValueType.TYPE_BOOL],
129
+ [MODULES.order, 'progress', 95, [], ValueType.TYPE_ADDRESS],
130
+ [MODULES.order, 'has_requred_info', 96, [], ValueType.TYPE_BOOL],
131
+ [MODULES.order, 'requred_info_service_pubkey', 97, [], ValueType.TYPE_VEC_U8],
132
+ [MODULES.order, 'requred_info_customer_pubkey', 98, [], ValueType.TYPE_VEC_U8],
133
+ [MODULES.order, 'requred_info_info', 99, [], ValueType.TYPE_VEC_VEC_U8],
134
+ [MODULES.order, 'has_discount', 100, [], ValueType.TYPE_BOOL],
135
+ [MODULES.order, 'discount', 101, [], ValueType.TYPE_ADDRESS],
136
+ [MODULES.order, 'balance', 102, [], ValueType.TYPE_U64],
137
+ [MODULES.order, 'bRefunded', 103, [], ValueType.TYPE_U8],
138
+ [MODULES.order, 'bWithdrawed', 104, [], ValueType.TYPE_U8],
139
+ [MODULES.service, 'permission', 111, [], ValueType.TYPE_ADDRESS],
140
+ [MODULES.service, 'payee', 112, [], ValueType.TYPE_ADDRESS],
141
+ [MODULES.service, 'has_buy_guard', 113, [], ValueType.TYPE_BOOL],
142
+ [MODULES.service, 'buy_guard', 114, [], ValueType.TYPE_ADDRESS],
143
+ [MODULES.service, 'repository_contains', 115, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
144
+ [MODULES.service, 'has_withdraw_guard', 116, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
145
+ [MODULES.service, 'withdraw_guard_percent', 117, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
146
+ [MODULES.service, 'has_refund_guard', 118, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
147
+ [MODULES.service, 'refund_guard_percent', 119, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
148
+ [MODULES.service, 'has_sale', 120, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
149
+ [MODULES.service, 'sale_price', 121, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64],
150
+ [MODULES.service, 'sale_stock', 122, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64],
151
+ [MODULES.service, 'has_machine', 123, [], ValueType.TYPE_BOOL],
152
+ [MODULES.service, 'machine', 124, [], ValueType.TYPE_ADDRESS],
153
+ [MODULES.service, 'bPaused', 125, [], ValueType.TYPE_BOOL],
154
+ [MODULES.service, 'bPublished', 126, [], ValueType.TYPE_BOOL],
155
+ [MODULES.service, 'has_required', 127, [], ValueType.TYPE_BOOL],
156
+ [MODULES.service, 'requrired_pubkey', 128, [], ValueType.TYPE_VEC_U8],
157
+ [MODULES.service, 'requrired_info', 129, [], ValueType.TYPE_VEC_VEC_U8],
158
+ [MODULES.reward, 'permission', 151, [], ValueType.TYPE_ADDRESS],
159
+ [MODULES.reward, 'rewards_count_remain', 152, [], ValueType.TYPE_U64],
160
+ [MODULES.reward, 'rewards_count_supplied', 153, [], ValueType.TYPE_U64],
161
+ [MODULES.reward, 'guard_count', 154, [], ValueType.TYPE_U64],
162
+ [MODULES.reward, 'has_guard', 155, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
163
+ [MODULES.reward, 'guard_portions', 156, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
164
+ [MODULES.reward, 'time_expire', 157, [], ValueType.TYPE_U64],
165
+ [MODULES.reward, 'has_claimed', 158, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
166
+ [MODULES.reward, 'claimed', 159, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
167
+ [MODULES.reward, 'has_claimed_count', 160, [], ValueType.TYPE_U64],
168
+ [MODULES.reward, 'is_sponsor', 161, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
169
+ [MODULES.reward, 'sponsor', 162, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
170
+ [MODULES.reward, 'sponsor_count', 163, [], ValueType.TYPE_U64],
171
+ [MODULES.reward, 'bAllowRepeatClaim', 164, [], ValueType.TYPE_BOOL],
172
+ [MODULES.reward, 'claimed_potions_count', 165, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
173
+ [MODULES.vote, 'permission', 171, [], ValueType.TYPE_ADDRESS],
174
+ [MODULES.vote, 'bOptions_locked_for_voting', 172, [], ValueType.TYPE_BOOL],
175
+ [MODULES.vote, 'bdeadline_locked', 173, [], ValueType.TYPE_BOOL],
176
+ [MODULES.vote, 'bLockedGuard', 174, [], ValueType.TYPE_BOOL],
177
+ [MODULES.vote, 'max_choice_count', 175, [], ValueType.TYPE_U8],
178
+ [MODULES.vote, 'deadline', 176, [], ValueType.TYPE_U64],
179
+ [MODULES.vote, 'has_reference', 177, [], ValueType.TYPE_BOOL],
180
+ [MODULES.vote, 'reference', 178, [], ValueType.TYPE_ADDRESS],
181
+ [MODULES.vote, 'has_guard', 179, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
182
+ [MODULES.vote, 'guard', 180, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
183
+ [MODULES.vote, 'voted', 181, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
184
+ [MODULES.vote, 'voted_weight', 182, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
185
+ [MODULES.vote, 'has_agree', 183, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
186
+ [MODULES.vote, 'agree_has_object', 184, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
187
+ [MODULES.vote, 'agree_object', 185, [ValueType.TYPE_VEC_U8], ValueType.TYPE_ADDRESS],
188
+ [MODULES.vote, 'agree_count', 186, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64],
189
+ [MODULES.vote, 'agree_votes', 187, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64],
190
+ [MODULES.vote, 'voted_count', 188, [], ValueType.TYPE_U64],
191
+ [MODULES.vote, 'top1_name_by_count', 189, [], ValueType.TYPE_VEC_U8],
192
+ [MODULES.vote, 'top1_count', 190, [], ValueType.TYPE_U64],
193
+ [MODULES.vote, 'top1_name_by_votes', 191, [], ValueType.TYPE_VEC_U8],
194
+ [MODULES.vote, 'top1_votes', 192, [], ValueType.TYPE_U64],
191
195
  ];
192
- }
193
- /*
194
- export const graphql_query_objects = (protocol: Protocol, nodes:any) : Guard_Query_Object[] => {
195
- let ret:Guard_Query_Object[] = [];
196
- nodes.forEach((node:any) => {
197
- for (let k = 0; k < protocol.WOWOK_OBJECTS_TYPE().length; k++) {
198
- if (node?.asMoveObject?.contents?.type?.repr?.includes(protocol.WOWOK_OBJECTS_TYPE()[k]) ) { // type: pack::m::Object<...>
199
- ret.push({ target:protocol.WOWOK_OBJECTS_PREFIX_TYPE()[k] + 'guard_query' as FnCallType,
200
- object:Inputs.SharedObjectRef({
201
- objectId: node.address,
202
- mutable: false,
203
- initialSharedVersion: node.version,
204
- }) as TransactionObjectInput,
205
- types:parse_object_type(node.asMoveObject.contents.type.repr as string),
206
- id: node.address,
207
- } as Guard_Query_Object);
208
- }
209
- }
210
- })
211
- return ret
212
- } */
213
- export class GuardVariableMaker {
214
- static IsValidGuardVirableType = (type) => {
215
- if (type == OperatorType.TYPE_FUTURE_QUERY || type == ContextType.TYPE_CONTEXT_FUTURE_ID || type == OperatorType.TYPE_QUERY_FROM_CONTEXT ||
216
- type == ContextType.TYPE_CONTEXT_bool || type == ContextType.TYPE_CONTEXT_address || type == ContextType.TYPE_CONTEXT_u64 ||
217
- type == ContextType.TYPE_CONTEXT_u8 || type == ContextType.TYPE_CONTEXT_vec_u8) {
218
- return true;
196
+ static BoolCmd = Guard.QUERIES.filter(q => q[4] == ValueType.TYPE_BOOL);
197
+ static IsBoolCmd = (cmd) => { return Guard.BoolCmd.includes((q) => { return q[2] == cmd; }); };
198
+ static GetCmd = (cmd) => {
199
+ let r = Guard.QUERIES.find((q) => { return q[2] == cmd; });
200
+ if (!r) {
201
+ ERROR(Errors.Fail, 'CmdParamCount: not found');
219
202
  }
220
203
  ;
221
- return false;
204
+ return r;
222
205
  };
206
+ }
207
+ export class GuardVariableHelper {
223
208
  static IsValidIndentifier = (identifier) => {
224
209
  if (!IsValidInt(identifier) || identifier > 255)
225
210
  return false;
@@ -232,219 +217,184 @@ export class GuardVariableMaker {
232
217
  return v.value;
233
218
  }
234
219
  }
235
- return false;
236
220
  }
237
- static get_variable_witness(variables, identifier, type) {
221
+ static get_variable_witness(variables, identifier) {
238
222
  if (variables.has(identifier)) {
239
223
  let v = variables.get(identifier);
240
- if (v?.witness && v.type == type) {
224
+ if (v?.witness && v.type == ContextType.TYPE_WITNESS_ID) {
241
225
  return v.witness;
242
226
  }
243
227
  }
244
- return false;
245
228
  }
246
- static add_future_variable(variables, identifier, type, witness, value, bNeedSerialize = true) {
247
- if (!GuardVariableMaker.IsValidIndentifier(identifier))
248
- return false;
249
- if (!GuardVariableMaker.IsValidGuardVirableType(type))
250
- return false;
229
+ static add_future_variable(variables, identifier, witness, value, bNeedSerialize = true) {
230
+ if (!GuardVariableHelper.IsValidIndentifier(identifier))
231
+ ERROR(Errors.IsValidIndentifier, 'add_future_variable');
251
232
  if (!witness && !value)
252
- return false;
253
- switch (type) {
254
- case OperatorType.TYPE_FUTURE_QUERY:
255
- case ContextType.TYPE_CONTEXT_FUTURE_ID:
256
- if (variables.has(identifier)) {
257
- let v = variables.get(identifier);
258
- if (bNeedSerialize) {
259
- v.value = value ? Bcs.getInstance().ser_address(value) : undefined;
260
- v.witness = witness ? Bcs.getInstance().ser_address(witness) : undefined;
261
- }
262
- else {
263
- v.value = value ? value : undefined;
264
- v.witness = witness ? witness : undefined;
265
- }
266
- }
267
- else {
268
- if (bNeedSerialize) {
269
- variables.set(identifier, { type: type, value: value ? Bcs.getInstance().ser_address(value) : undefined, witness: witness ? Bcs.getInstance().ser_address(witness) : undefined });
270
- }
271
- else {
272
- variables.set(identifier, { type: type, value: value ? value : undefined, witness: witness ? witness : undefined });
273
- }
274
- }
275
- return true;
233
+ ERROR(Errors.InvalidParam, 'both witness and value invalid');
234
+ let v = variables.get(identifier);
235
+ if (!v || v.type == ContextType.TYPE_WITNESS_ID) {
236
+ if (bNeedSerialize) {
237
+ variables.set(identifier, { type: ContextType.TYPE_WITNESS_ID, value: value ? Bcs.getInstance().ser_address(value) : undefined, witness: witness ? Bcs.getInstance().ser_address(witness) : undefined });
238
+ }
239
+ else {
240
+ variables.set(identifier, { type: ContextType.TYPE_WITNESS_ID, value: value ? value : undefined, witness: witness ? witness : undefined });
241
+ }
276
242
  }
277
- return false;
278
243
  }
279
244
  static add_variable(variables, identifier, type, value, bNeedSerialize = true) {
280
- if (!GuardVariableMaker.IsValidIndentifier(identifier))
281
- return false;
282
- if (!GuardVariableMaker.IsValidGuardVirableType(type))
245
+ if (!GuardVariableHelper.IsValidIndentifier(identifier))
283
246
  return false;
284
247
  if (!value)
285
248
  return false;
286
249
  switch (type) {
287
- case ContextType.TYPE_CONTEXT_bool:
288
- bNeedSerialize ? variables.set(identifier, { type: type, value: Bcs.getInstance().ser_bool(value) }) :
289
- variables.set(identifier, { type: type, value: value });
290
- return true;
291
- case ContextType.TYPE_CONTEXT_address:
292
- case OperatorType.TYPE_QUERY_FROM_CONTEXT:
293
- bNeedSerialize ? variables.set(identifier, { type: type, value: Bcs.getInstance().ser_address(value) }) :
294
- variables.set(identifier, { type: type, value: value });
295
- return true;
296
- case ContextType.TYPE_CONTEXT_u64:
297
- bNeedSerialize ? variables.set(identifier, { type: type, value: Bcs.getInstance().ser_u64(value) }) :
250
+ case ValueType.TYPE_BOOL:
251
+ case ValueType.TYPE_ADDRESS:
252
+ case ValueType.TYPE_U64:
253
+ case ValueType.TYPE_U8:
254
+ case ValueType.TYPE_U128:
255
+ case ValueType.TYPE_U256:
256
+ case ValueType.TYPE_VEC_U64:
257
+ case ValueType.TYPE_VEC_VEC_U8:
258
+ case ValueType.TYPE_OPTION_ADDRESS:
259
+ case ValueType.TYPE_OPTION_BOOL:
260
+ case ValueType.TYPE_OPTION_U128:
261
+ case ValueType.TYPE_OPTION_U256:
262
+ case ValueType.TYPE_OPTION_U64:
263
+ case ValueType.TYPE_OPTION_U8:
264
+ case ValueType.TYPE_VEC_ADDRESS:
265
+ case ValueType.TYPE_VEC_BOOL:
266
+ case ValueType.TYPE_VEC_U128:
267
+ case ValueType.TYPE_VEC_U256:
268
+ let ser = SER_VALUE.find(s => s.type == type);
269
+ if (!ser)
270
+ ERROR(Errors.Fail, 'add_variable: invalid type');
271
+ bNeedSerialize ? variables.set(identifier, { type: type, value: Bcs.getInstance().ser(ser.name, value) }) :
298
272
  variables.set(identifier, { type: type, value: value });
299
- return true;
300
- case ContextType.TYPE_CONTEXT_u8:
301
- bNeedSerialize ? variables.set(identifier, { type: type, value: Bcs.getInstance().ser_u8(value) }) :
302
- variables.set(identifier, { type: type, value: value });
303
- return true;
304
- case ContextType.TYPE_CONTEXT_vec_u8:
305
- bNeedSerialize ? variables.set(identifier, { type: type, value: Bcs.getInstance().ser_string(value) }) :
273
+ return;
274
+ case ValueType.TYPE_VEC_U8:
275
+ if (typeof (value) === 'string') {
276
+ variables.set(identifier, { type: type, value: Bcs.getInstance().ser_string(value) });
277
+ }
278
+ else {
306
279
  variables.set(identifier, { type: type, value: value });
307
- return true;
280
+ }
281
+ return;
282
+ default:
283
+ ERROR(Errors.Fail, 'add_variable serialize not impl yet');
308
284
  }
309
- return false;
310
285
  }
311
286
  }
312
- export class GuardInputMaker {
287
+ export class GuardMaker {
313
288
  data = [];
314
289
  type_validator = [];
290
+ variable = new Map();
291
+ static index = 0;
292
+ static get_index() {
293
+ if (GuardMaker.index == 256) {
294
+ GuardMaker.index = 0;
295
+ }
296
+ return GuardMaker.index++;
297
+ }
315
298
  constructor() { }
299
+ add_variable(type, value, bNeedSerialize = true) {
300
+ let identifier = GuardMaker.get_index();
301
+ if (type == ContextType.TYPE_WITNESS_ID) {
302
+ // add witness to variable
303
+ GuardVariableHelper.add_future_variable(this.variable, identifier, value, undefined, bNeedSerialize);
304
+ }
305
+ else {
306
+ GuardVariableHelper.add_variable(this.variable, identifier, type, value, bNeedSerialize);
307
+ }
308
+ return identifier;
309
+ }
310
+ serValueParam(type, param) {
311
+ if (!param)
312
+ ERROR(Errors.InvalidParam, 'param');
313
+ this.data.push(Bcs.getInstance().ser_u8(type));
314
+ let ser = SER_VALUE.find(s => s.type == type);
315
+ if (!ser)
316
+ ERROR(Errors.Fail, 'serValueParam: invalid type');
317
+ this.data.push(Bcs.getInstance().ser(ser.name, param));
318
+ this.type_validator.push(type);
319
+ }
316
320
  // serialize const & data
317
- add_param(type, param, variable) {
321
+ add_param(type, param) {
318
322
  switch (type) {
319
- case ValueType.TYPE_STATIC_address:
320
- if (!param)
321
- ERROR(Errors.InvalidParam, 'param');
322
- this.data.push(Bcs.getInstance().ser_u8(type));
323
- this.data.push(Bcs.getInstance().ser_address(param));
324
- this.type_validator.push(type);
323
+ case ValueType.TYPE_ADDRESS:
324
+ case ValueType.TYPE_BOOL:
325
+ case ValueType.TYPE_U8:
326
+ case ValueType.TYPE_U64:
327
+ case ValueType.TYPE_U128:
328
+ case ValueType.TYPE_U256:
329
+ case ValueType.TYPE_VEC_ADDRESS:
330
+ case ValueType.TYPE_VEC_BOOL:
331
+ case ValueType.TYPE_VEC_U128:
332
+ case ValueType.TYPE_VEC_U64:
333
+ case ValueType.TYPE_VEC_VEC_U8:
334
+ case ValueType.TYPE_OPTION_U64:
335
+ case ValueType.TYPE_OPTION_ADDRESS:
336
+ case ValueType.TYPE_OPTION_BOOL:
337
+ case ValueType.TYPE_OPTION_U128:
338
+ case ValueType.TYPE_OPTION_U256:
339
+ case ValueType.TYPE_OPTION_U8:
340
+ case ValueType.TYPE_VEC_U256:
341
+ this.serValueParam(type, param);
325
342
  break;
326
- case ValueType.TYPE_STATIC_bool:
343
+ case ValueType.TYPE_VEC_U8:
327
344
  if (!param)
328
345
  ERROR(Errors.InvalidParam, 'param');
329
346
  this.data.push(Bcs.getInstance().ser_u8(type));
330
- this.data.push(Bcs.getInstance().ser_bool(param));
347
+ if (typeof (param) == 'string') {
348
+ this.data.push(Bcs.getInstance().ser_string(param));
349
+ }
350
+ else {
351
+ this.data.push(Bcs.getInstance().ser_vector_u8(param));
352
+ }
331
353
  this.type_validator.push(type);
332
354
  break;
333
- case ValueType.TYPE_STATIC_u8:
334
- if (!param)
335
- ERROR(Errors.InvalidParam, 'param');
355
+ case ContextType.TYPE_SIGNER:
336
356
  this.data.push(Bcs.getInstance().ser_u8(type));
337
- this.data.push(Bcs.getInstance().ser_u8(param));
338
- this.type_validator.push(type);
357
+ this.type_validator.push(ValueType.TYPE_ADDRESS);
339
358
  break;
340
- case ValueType.TYPE_STATIC_u64:
341
- if (!param)
342
- ERROR(Errors.InvalidParam, 'param');
359
+ case ContextType.TYPE_CLOCK:
343
360
  this.data.push(Bcs.getInstance().ser_u8(type));
344
- this.data.push(Bcs.getInstance().ser_u64(param));
345
- this.type_validator.push(type);
361
+ this.type_validator.push(ValueType.TYPE_U64);
346
362
  break;
347
- case ValueType.TYPE_STATIC_vec_u8:
363
+ case ContextType.TYPE_WITNESS_ID:
348
364
  if (!param)
349
365
  ERROR(Errors.InvalidParam, 'param');
350
366
  this.data.push(Bcs.getInstance().ser_u8(type));
351
- this.data.push(Bcs.getInstance().ser_string(param));
352
- this.type_validator.push(type);
353
- // this.data[this.data.length-1].forEach((item : number) => console.log(item))
354
- break;
355
- case ContextType.TYPE_CONTEXT_SIGNER:
356
- this.data.push(Bcs.getInstance().ser_u8(type));
357
- this.type_validator.push(ValueType.TYPE_STATIC_address);
358
- break;
359
- case ContextType.TYPE_CONTEXT_CLOCK:
360
- this.data.push(Bcs.getInstance().ser_u8(type));
361
- this.type_validator.push(ValueType.TYPE_STATIC_u64);
367
+ this.data.push(Bcs.getInstance().ser_address(param));
368
+ this.type_validator.push(ValueType.TYPE_ADDRESS);
362
369
  break;
363
- case ContextType.TYPE_CONTEXT_bool:
364
- case ContextType.TYPE_CONTEXT_u8:
365
- case ContextType.TYPE_CONTEXT_u64:
366
- case ContextType.TYPE_CONTEXT_vec_u8:
367
- case ContextType.TYPE_CONTEXT_address:
368
- case ContextType.TYPE_CONTEXT_FUTURE_ID:
369
- if (!variable || !param) {
370
- ERROR(Errors.InvalidParam, 'variable or param');
370
+ case ContextType.TYPE_VARIABLE:
371
+ if (!param) {
372
+ ERROR(Errors.InvalidParam, 'param invalid');
371
373
  }
372
374
  if (typeof (param) != 'number' || !IsValidInt(param) || param > 255) {
373
- ERROR(Errors.InvalidParam, 'param');
375
+ ERROR(Errors.InvalidParam, 'add_param param');
374
376
  }
375
- var v = variable.get(param);
376
- if (v?.type == type) {
377
- this.data.push(Bcs.getInstance().ser_u8(type));
378
- this.data.push(Bcs.getInstance().ser_u8(param));
379
- if (type == ContextType.TYPE_CONTEXT_bool) {
380
- this.type_validator.push(ValueType.TYPE_STATIC_bool);
381
- }
382
- else if (type == ContextType.TYPE_CONTEXT_u8) {
383
- this.type_validator.push(ValueType.TYPE_STATIC_u8);
384
- }
385
- else if (type == ContextType.TYPE_CONTEXT_u64) {
386
- this.type_validator.push(ValueType.TYPE_STATIC_u64);
387
- }
388
- else if (type == ContextType.TYPE_CONTEXT_vec_u8) {
389
- this.type_validator.push(ValueType.TYPE_STATIC_vec_u8);
390
- }
391
- else if (type == ContextType.TYPE_CONTEXT_address) {
392
- this.type_validator.push(ValueType.TYPE_STATIC_address);
393
- }
394
- else if (type == ContextType.TYPE_CONTEXT_FUTURE_ID) {
395
- this.type_validator.push(ValueType.TYPE_STATIC_address);
396
- }
397
- break;
398
- }
399
- ;
400
- ERROR(Errors.InvalidParam, 'variable');
377
+ var v = this.variable.get(param);
378
+ if (!v)
379
+ ERROR(Errors.Fail, 'identifier not in variable');
380
+ this.type_validator.push(v.type);
381
+ this.data.push(Bcs.getInstance().ser_u8(type));
382
+ this.data.push(Bcs.getInstance().ser_u8(param));
383
+ break;
401
384
  default:
402
- ERROR(Errors.InvalidParam, 'type');
385
+ ERROR(Errors.InvalidParam, 'add_param type');
403
386
  }
404
387
  ;
388
+ return this;
405
389
  }
406
- static query_index(module, query_name) {
407
- for (let i = 0; i < Guard.QUERIES.length; i++) {
408
- if (Guard.QUERIES[i][0] == module && Guard.QUERIES[i][1] == query_name) {
409
- return i;
410
- }
411
- }
412
- return -1;
413
- }
414
- add_future_query(identifier, module, query_name, variable) {
415
- let query_index = GuardInputMaker.query_index(module, query_name);
416
- if (!GuardVariableMaker.IsValidIndentifier(identifier) || query_index == -1) {
417
- ERROR(Errors.InvalidParam, 'identifier or query_name');
418
- }
419
- if (module != MODULES.order && module != MODULES.progress) {
420
- ERROR(Errors.InvalidParam, 'module');
421
- }
422
- if (!variable || variable.get(identifier)?.type != OperatorType.TYPE_FUTURE_QUERY) {
423
- ERROR(Errors.InvalidParam, 'variable');
424
- }
425
- let offset = this.type_validator.length - Guard.QUERIES[query_index][3].length;
426
- if (offset < 0) {
427
- ERROR(Errors.InvalidParam, 'query_name');
428
- }
429
- let types = this.type_validator.slice(offset);
430
- if (!array_equal(types, Guard.QUERIES[query_index][3])) { // type validate
431
- ERROR(Errors.Fail, 'array_equal');
432
- }
433
- this.data.push(Bcs.getInstance().ser_u8(OperatorType.TYPE_FUTURE_QUERY)); // TYPE
434
- this.data.push(Bcs.getInstance().ser_u8(identifier)); // variable identifier
435
- this.data.push(Bcs.getInstance().ser_u8(Guard.QUERIES[query_index][2])); // cmd
436
- this.type_validator.splice(offset, Guard.QUERIES[query_index][3].length); // delete type stack
437
- this.type_validator.push(Guard.QUERIES[query_index][4]); // add the return value type to type stack
438
- // console.log(this.type_validator)
439
- }
440
- // object_address_from: string for static address; number as identifier for variable
441
- add_query(module, query_name, object_address_from) {
442
- let query_index = GuardInputMaker.query_index(module, query_name); // query_index: index(from 0) of array Guard.QUERIES
390
+ // object_address_from: string for static address; number as identifier invariable
391
+ add_query(module, query_name, object_address_from, bWitness = false) {
392
+ let query_index = Guard.QUERIES.findIndex((q) => { return q[0] == module && q[1] == query_name; });
443
393
  if (query_index == -1) {
444
394
  ERROR(Errors.InvalidParam, 'query_name');
445
395
  }
446
396
  if (typeof (object_address_from) == 'number') {
447
- if (!GuardVariableMaker.IsValidIndentifier(object_address_from)) {
397
+ if (!GuardVariableHelper.IsValidIndentifier(object_address_from)) {
448
398
  ERROR(Errors.InvalidParam, 'object_address_from');
449
399
  }
450
400
  }
@@ -461,43 +411,53 @@ export class GuardInputMaker {
461
411
  if (!array_equal(types, Guard.QUERIES[query_index][3])) { // type validate
462
412
  ERROR(Errors.Fail, 'array_equal');
463
413
  }
414
+ this.data.push(Bcs.getInstance().ser_u8(OperatorType.TYPE_QUERY)); // QUERY TYPE
464
415
  if (typeof (object_address_from) == 'string') {
465
- this.data.push(Bcs.getInstance().ser_u8(OperatorType.TYPE_QUERY)); // TYPE
416
+ bWitness ? this.data.push(Bcs.getInstance().ser_u8(ContextType.TYPE_WITNESS_ID)) :
417
+ this.data.push(Bcs.getInstance().ser_u8(ValueType.TYPE_ADDRESS));
466
418
  this.data.push(Bcs.getInstance().ser_address(object_address_from)); // object address
467
419
  }
468
420
  else {
469
- this.data.push(Bcs.getInstance().ser_u8(OperatorType.TYPE_QUERY_FROM_CONTEXT)); // TYPE
470
- this.data.push(Bcs.getInstance().ser_u8(object_address_from)); // object identifer in variables
421
+ let v = this.variable.get(object_address_from);
422
+ if (!v)
423
+ ERROR(Errors.Fail, 'object_address_from not in variable');
424
+ if ((bWitness && v?.type == ContextType.TYPE_WITNESS_ID) || (!bWitness && v?.type == ValueType.TYPE_ADDRESS)) {
425
+ this.data.push(Bcs.getInstance().ser_u8(ContextType.TYPE_VARIABLE));
426
+ this.data.push(Bcs.getInstance().ser_u8(object_address_from)); // object identifer in variables
427
+ }
428
+ else {
429
+ ERROR(Errors.Fail, 'type bWitness not match');
430
+ }
471
431
  }
472
432
  this.data.push(Bcs.getInstance().ser_u8(Guard.QUERIES[query_index][2])); // cmd
473
433
  this.type_validator.splice(offset, Guard.QUERIES[query_index][3].length); // delete type stack
474
434
  this.type_validator.push(Guard.QUERIES[query_index][4]); // add the return value type to type stack
475
- // console.log(this.type_validator)
435
+ return this;
476
436
  }
477
437
  add_logic(type) {
478
438
  let splice_len = 2;
479
439
  switch (type) {
480
- case OperatorType.TYPE_LOGIC_OPERATOR_U128_GREATER:
481
- case OperatorType.TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL:
482
- case OperatorType.TYPE_LOGIC_OPERATOR_U128_LESSER:
483
- case OperatorType.TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL:
484
- case OperatorType.TYPE_LOGIC_OPERATOR_U128_EQUAL:
440
+ case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
441
+ case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
442
+ case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
443
+ case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
444
+ case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
485
445
  if (this.type_validator.length < splice_len) {
486
446
  ERROR(Errors.Fail, 'type_validator.length');
487
447
  }
488
- if (!GuardInputMaker.match_u128(this.type_validator[this.type_validator.length - 1])) {
448
+ if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1])) {
489
449
  ERROR(Errors.Fail, 'type_validator check');
490
450
  }
491
- if (!GuardInputMaker.match_u128(this.type_validator[this.type_validator.length - 2])) {
451
+ if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) {
492
452
  ERROR(Errors.Fail, 'type_validator check');
493
453
  }
494
454
  break;
495
- case OperatorType.TYPE_LOGIC_OPERATOR_EQUAL:
455
+ case OperatorType.TYPE_LOGIC_EQUAL:
496
456
  if (this.type_validator.length < splice_len) {
497
457
  ERROR(Errors.Fail, 'type_validator.length');
498
458
  }
499
459
  break;
500
- case OperatorType.TYPE_LOGIC_OPERATOR_HAS_SUBSTRING:
460
+ case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
501
461
  if (this.type_validator.length < splice_len) {
502
462
  ERROR(Errors.Fail, 'type_validator.length');
503
463
  }
@@ -507,7 +467,7 @@ export class GuardInputMaker {
507
467
  if (this.type_validator.length < splice_len) {
508
468
  ERROR(Errors.Fail, 'type_validator.length');
509
469
  }
510
- if (this.type_validator[this.type_validator.length - 1] != ValueType.TYPE_STATIC_bool) {
470
+ if (this.type_validator[this.type_validator.length - 1] != ValueType.TYPE_BOOL) {
511
471
  ERROR(Errors.Fail, 'type_validator check');
512
472
  }
513
473
  break;
@@ -516,10 +476,10 @@ export class GuardInputMaker {
516
476
  if (this.type_validator.length < splice_len) {
517
477
  ERROR(Errors.Fail, 'type_validator.length');
518
478
  }
519
- if (this.type_validator[this.type_validator.length - 1] != ValueType.TYPE_STATIC_bool) {
479
+ if (this.type_validator[this.type_validator.length - 1] != ValueType.TYPE_BOOL) {
520
480
  ERROR(Errors.Fail, 'type_validator check');
521
481
  }
522
- if (this.type_validator[this.type_validator.length - 2] != ValueType.TYPE_STATIC_bool) {
482
+ if (this.type_validator[this.type_validator.length - 2] != ValueType.TYPE_BOOL) {
523
483
  ERROR(Errors.Fail, 'type_validator check');
524
484
  }
525
485
  break;
@@ -528,31 +488,60 @@ export class GuardInputMaker {
528
488
  }
529
489
  this.data.push(Bcs.getInstance().ser_u8(type)); // TYPE
530
490
  this.type_validator.splice(this.type_validator.length - splice_len); // delete type stack
531
- this.type_validator.push(ValueType.TYPE_STATIC_bool); // add bool to type stack
491
+ this.type_validator.push(ValueType.TYPE_BOOL); // add bool to type stack
492
+ return this;
532
493
  }
533
- make(bNot = false) {
494
+ build(bNot = false) {
534
495
  //console.log(this.type_validator);
535
496
  //this.data.forEach((value:Uint8Array) => console.log(value));
536
- if (this.type_validator.length != 1 || this.type_validator[0] != ValueType.TYPE_STATIC_bool) {
537
- console.log(this.type_validator);
497
+ if (this.type_validator.length != 1 || this.type_validator[0] != ValueType.TYPE_BOOL) {
538
498
  ERROR(Errors.Fail, 'type_validator check');
539
499
  } // ERROR
540
500
  if (bNot) {
541
501
  this.add_logic(OperatorType.TYPE_LOGIC_NOT);
542
502
  }
543
- return concatenate(Uint8Array, ...this.data);
503
+ this.data.push(concatenate(Uint8Array, ...this.data));
504
+ this.data.splice(0, this.data.length - 1);
505
+ return this;
506
+ }
507
+ IsReady() {
508
+ return this.type_validator.length == 1 && this.type_validator[0] == ValueType.TYPE_BOOL && this.data.length == 1;
509
+ }
510
+ combine(otherBuilt, bAnd = true, bCombinVariable = false) {
511
+ if (!otherBuilt.IsReady() || !this.IsReady()) {
512
+ ERROR(Errors.Fail, 'both should built yet');
513
+ }
514
+ ;
515
+ let maker = new GuardMaker();
516
+ this.variable.forEach((v, k) => {
517
+ maker.variable.set(k, { type: v.type, value: v.value, witness: v.witness });
518
+ });
519
+ otherBuilt.variable.forEach((v, k) => {
520
+ if (maker.variable.has(k) && !bCombinVariable) {
521
+ ERROR(Errors.Fail, 'variable identifier exist');
522
+ }
523
+ maker.variable.set(k, { type: v.type, value: v.value, witness: v.witness });
524
+ });
525
+ let op = bAnd ? OperatorType.TYPE_LOGIC_AND : OperatorType.TYPE_LOGIC_OR;
526
+ maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser_u8(op)));
527
+ this.data.splice(0, this.data.length - 1);
528
+ maker.type_validator = this.type_validator;
529
+ return maker;
544
530
  }
545
- static combine(input1, input2, bAnd = true) {
531
+ get_variable() { return this.variable; }
532
+ get_input() { return this.data; }
533
+ static input_combine(input1, input2, bAnd = true) {
546
534
  let op = bAnd ? OperatorType.TYPE_LOGIC_AND : OperatorType.TYPE_LOGIC_OR;
547
535
  return concatenate(Uint8Array, input1, input2, Bcs.getInstance().ser_u8(op));
548
536
  }
549
- static not(input) {
537
+ static input_not(input) {
550
538
  return concatenate(Uint8Array, input, Bcs.getInstance().ser_u8(OperatorType.TYPE_LOGIC_NOT));
551
539
  }
552
- static match_u128(type) {
553
- if (type == ValueType.TYPE_STATIC_u8 ||
554
- type == ValueType.TYPE_STATIC_u64 ||
555
- type == ValueType.TYPE_STATIC_u128) {
540
+ static match_u256(type) {
541
+ if (type == ValueType.TYPE_U8 ||
542
+ type == ValueType.TYPE_U64 ||
543
+ type == ValueType.TYPE_U128 ||
544
+ type == ValueType.TYPE_U256) {
556
545
  return true;
557
546
  }
558
547
  return false;