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