wowok 1.1.2 → 1.1.3

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