wowok 1.3.11 → 1.4.16

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 (9) hide show
  1. package/package.json +1 -1
  2. package/src/exception.ts +1 -1
  3. package/src/guard.ts +240 -194
  4. package/src/machine.ts +13 -6
  5. package/src/passport.ts +42 -30
  6. package/src/permission.ts +3 -2
  7. package/src/protocol.ts +27 -16
  8. package/src/repository.ts +12 -7
  9. package/src/utils.ts +29 -14
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "wowok",
3
- "version": "1.3.11",
3
+ "version": "1.4.16",
4
4
  "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
5
5
  "main": "./src/index.ts",
6
6
  "types": "./src/index.ts",
package/src/exception.ts CHANGED
@@ -25,6 +25,6 @@ export enum Errors {
25
25
  }
26
26
 
27
27
  export const ERROR = (error:Errors, info?:any) => {
28
- const e = error + info ? (': ' + info) : '';
28
+ const e = error + info ? (' ' + info) : '';
29
29
  throw e;
30
30
  }
package/src/guard.ts CHANGED
@@ -2,13 +2,13 @@
2
2
 
3
3
  import { Protocol, LogicsInfo, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType, OperatorType, ConstantType, SER_VALUE} from './protocol';
4
4
  import { concatenate, array_equal } from './utils';
5
- import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercase } from './utils';
5
+ import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercase, insertAtHead } from './utils';
6
6
  import { ERROR, Errors } from './exception';
7
7
  import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
8
8
 
9
- export type GuardConstant = Map<number, Guard_Vriable>;
9
+ export type GuardConstant = Map<number, Guard_Variable>;
10
10
 
11
- export interface Guard_Vriable {
11
+ export interface Guard_Variable {
12
12
  type: ConstantType ,
13
13
  value?: Uint8Array,
14
14
  witness?: Uint8Array,
@@ -22,7 +22,7 @@ export interface Guard_Options {
22
22
  }
23
23
 
24
24
  export class Guard {
25
- static MAX_INPUT_LENGTH = 2048;
25
+ static MAX_INPUT_LENGTH = 10240;
26
26
  static launch(txb:TransactionBlock, description:string, maker:GuardMaker) : GuardAddress {
27
27
  if (!maker.IsReady()) {
28
28
  ERROR(Errors.InvalidParam, 'launch maker');
@@ -59,19 +59,19 @@ export class Guard {
59
59
  if (!v.witness) {
60
60
  ERROR(Errors.InvalidParam, 'constants type')
61
61
  }
62
-
62
+ const n = insertAtHead(v.witness!, v.type);
63
63
  txb.moveCall({
64
64
  target:Protocol.Instance().GuardFn("constant_add") as FnCallType,
65
- arguments:[guard, txb.pure.u8(k), txb.pure.u8(v.type), txb.pure.vector('u8', [].slice.call(v.witness)), txb.pure.bool(true)]
65
+ arguments:[guard, txb.pure.u8(k), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(true)]
66
66
  })
67
67
  } else {
68
68
  if (!v.value) {
69
69
  ERROR(Errors.InvalidParam, 'constants type')
70
70
  }
71
-
71
+ const n = insertAtHead(v.value!, v.type);
72
72
  txb.moveCall({
73
73
  target:Protocol.Instance().GuardFn("constant_add") as FnCallType,
74
- arguments:[guard, txb.pure.u8(k), txb.pure.u8(v.type), txb.pure.vector('u8', [].slice.call(v.value)), txb.pure.bool(true)]
74
+ arguments:[guard, txb.pure.u8(k), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(true)]
75
75
  })
76
76
  }
77
77
  });
@@ -98,111 +98,120 @@ export class Guard {
98
98
 
99
99
  static QUERIES:any[] = [
100
100
  // module, 'name', 'id', [input], output
101
- [MODULES.permission, 'Builder', 1, [], ValueType.TYPE_ADDRESS],
102
- [MODULES.permission, 'Has Admin', 2, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
103
- [MODULES.permission, 'Has Rights', 3, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
104
- [MODULES.permission, 'Contains Address', 4, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
105
- [MODULES.permission, 'Contains Index of Address', 5, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
106
- [MODULES.permission, 'Contains Guard of Address', 6, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
107
- [MODULES.permission, 'Guard of Address', 7, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_ADDRESS],
108
- [MODULES.permission, 'Entity Count', 8, [], ValueType.TYPE_U64],
109
- [MODULES.permission, 'Admin Count', 9, [], ValueType.TYPE_U64],
101
+ [MODULES.permission, 'Owner', 1, [], ValueType.TYPE_ADDRESS, "Owner's address."],
102
+ [MODULES.permission, 'Is Admin', 2, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a certain address an administrator?', 'Input:address'],
103
+ [MODULES.permission, 'Has Rights', 3, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL, 'Does an address have a certain permission(Admin always have permissions)?', 'Input 1:address; Input 2:permission index'],
104
+ [MODULES.permission, 'Contains Address', 4, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is included in the personnel permission table?', 'Input:address'],
105
+ [MODULES.permission, 'Contains Permission', 5, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL, 'Whether a certain permission for a certain address is defined in the personnel permission table?', 'Input 1:address; Input 2:permission index'],
106
+ [MODULES.permission, 'Contains Permission Guard', 6, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL, 'Whether a permission guard for a certain address is defined in the personnel permission table?', 'Input 1:address; Input 2:permission index'],
107
+ [MODULES.permission, 'Permission Guard', 7, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_ADDRESS, 'Permission guard for a certain address.', 'Input 1:address; Input 2:permission index'],
108
+ [MODULES.permission, 'Number of Entities', 8, [], ValueType.TYPE_U64, 'Number of entities in the personnel permission table.'],
109
+ [MODULES.permission, 'Number of Admin', 9, [], ValueType.TYPE_U64, 'Number of administrators.'],
110
110
 
111
- [MODULES.repository, 'Permission', 11, [], ValueType.TYPE_ADDRESS],
112
- [MODULES.repository, 'Contains Policy', 12, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],
113
- [MODULES.repository, 'Has Permission of Policy', 13, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],
114
- [MODULES.repository, 'Permission of Policy', 14, [ValueType.TYPE_STRING], ValueType.TYPE_U64],
115
- [MODULES.repository, 'Value Type of Policy', 15, [ValueType.TYPE_STRING], ValueType.TYPE_U8],
116
- [MODULES.repository, 'Contains Id', 16, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
117
- [MODULES.repository, 'Contains Value', 17, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_BOOL],
118
- [MODULES.repository, 'Value without Type', 18, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8],
119
- [MODULES.repository, 'Value', 19, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8],
120
- [MODULES.repository, 'Type', 20, [], ValueType.TYPE_U8],
121
- [MODULES.repository, 'Policy Mode', 21, [], ValueType.TYPE_U8],
122
- [MODULES.repository, 'Reference Count', 22, [], ValueType.TYPE_U64],
123
- [MODULES.repository, 'Has Reference', 23, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
124
-
125
- [MODULES.machine, 'Permission', 31, [], ValueType.TYPE_ADDRESS],
126
- [MODULES.machine, 'Paused', 32, [], ValueType.TYPE_BOOL],
127
- [MODULES.machine, 'Published', 33, [], ValueType.TYPE_BOOL],
128
- [MODULES.machine, 'Is Consensus Repository', 34, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
129
- [MODULES.machine, 'Has Endpoint', 35, [], ValueType.TYPE_BOOL],
130
- [MODULES.machine, 'Endpoint', 36, [], ValueType.TYPE_STRING],
111
+ [MODULES.repository, 'Permission', 11, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
112
+ [MODULES.repository, 'Contains Policy', 12, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Is a consensus policy included?', 'Input:the filed name'],
113
+ [MODULES.repository, 'Is Permission set of Policy', 13, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Does a certain consensus policy set data operation permissions?', 'Input:the policy name'],
114
+ [MODULES.repository, 'Permission of Policy', 14, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The permission index of a certain consensus policy in the Permission object.', 'Input:the policy name'],
115
+ [MODULES.repository, 'Value Type of Policy', 15, [ValueType.TYPE_STRING], ValueType.TYPE_U8, 'Data types defined by consensus policy.', 'Input:the policy name'],
116
+ [MODULES.repository, 'Contains Data for An Address', 16, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether data exists at a certain address?', 'Input:address'],
117
+ [MODULES.repository, 'Contains Data', 17, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Does it contain data for a certain field of an address?', 'Input 1:address, Input 2:the field name'],
118
+ [MODULES.repository, 'Raw data without Type', 18, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8, 'Data for a field at an address and does not contain data type information.', 'Input 1:address, Input 2:the field name'],
119
+ [MODULES.repository, 'Raw data', 19, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8, 'Data for a field at an address, and the first byte contains data type information.', 'Input 1:address, Input 2:the field name'],
120
+ [MODULES.repository, 'Type', 20, [], ValueType.TYPE_U8, 'The repository Type. 0: Normal; 1: Wowok greenee.'],
121
+ [MODULES.repository, 'Policy Mode', 21, [], ValueType.TYPE_U8, 'Policy Mode. 0: Free mode; 1: Strict mode.'],
122
+ [MODULES.repository, 'Reference Count', 22, [], ValueType.TYPE_U64, 'The number of times it is referenced by other objects.'],
123
+ [MODULES.repository, 'Is Referenced by An Object', 23, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is it referenced by an object?', 'Input:address'],
124
+ [MODULES.repository, 'Data Number', 24, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_U256, 'Data for a field at an address and get unsigned integer type data.', 'Input 1:address, Input 2:the field name'],
125
+ [MODULES.repository, 'Data String', 25, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_STRING, 'Data for a field at an address and get string type data.', 'Input 1:address, Input 2:the field name'],
126
+ [MODULES.repository, 'Data Address', 26, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'Data for a field at an address and get address type data.', 'Input 1:address, Input 2:the field name'],
127
+ [MODULES.repository, 'Data Bool', 27, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Data for a field at an address and get bool type data.', 'Input 1:address, Input 2:the field name'],
128
+ [MODULES.repository, 'Data Number Vector', 28, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U256, 'Data for a field at an address and get unsigned integer vector type data.', 'Input 1:address, Input 2:the field name'],
129
+ [MODULES.repository, 'Data String Vector', 29, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_STRING, 'Data for a field at an address and get string vector type data.', 'Input 1:address, Input 2:the field name'],
130
+ [MODULES.repository, 'Data Address Vector', 30, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_ADDRESS, 'Data for a field at an address and get address vector type data.', 'Input 1:address, Input 2:the field name'],
131
+ [MODULES.repository, 'Data Bool Vector', 31, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_BOOL, 'Data for a field at an address and get bool vector type data.', 'Input 1:address, Input 2:the field name'],
132
+
133
+ // , means that data fields and data outside the consensus policy definition are allowed to be written
134
+ // , means that only data fields and data defined by the consensus policy are allowed to be written.
135
+ [MODULES.machine, 'Permission', 41, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
136
+ [MODULES.machine, 'Paused', 42, [], ValueType.TYPE_BOOL, 'Pause the creation of new Progress?'],
137
+ [MODULES.machine, 'Published', 43, [], ValueType.TYPE_BOOL, 'Is it allowed to create Progress?'],
138
+ [MODULES.machine, 'Is Consensus Repository', 44, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is a consensus repository?', 'Input:adddress'],
139
+ [MODULES.machine, 'Has Endpoint', 45, [], ValueType.TYPE_BOOL, 'Is the endpoint set?'],
140
+ [MODULES.machine, 'Endpoint', 46, [], ValueType.TYPE_STRING, 'Endpoint url/ipfs.'],
131
141
 
132
- [MODULES.progress, 'Machine', 51, [], ValueType.TYPE_ADDRESS],
133
- [MODULES.progress, 'Current Node', 52, [], ValueType.TYPE_STRING],
134
- [MODULES.progress, 'Has Parent', 53, [], ValueType.TYPE_BOOL],
135
- [MODULES.progress, 'Parent', 54, [], ValueType.TYPE_ADDRESS],
136
- [MODULES.progress, 'Has Task', 55, [], ValueType.TYPE_BOOL],
137
- [MODULES.progress, 'Task', 56, [], ValueType.TYPE_ADDRESS],
138
- [MODULES.progress, 'Has Operator', 57, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],
139
- [MODULES.progress, 'Is Operator for Address', 58, [ValueType.TYPE_STRING, ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
140
- [MODULES.progress, 'Has Context Repository', 59, [], ValueType.TYPE_BOOL],
141
- [MODULES.progress, 'Context Repository', 60, [], ValueType.TYPE_ADDRESS],
142
- [MODULES.progress, 'Last session time', 61, [], ValueType.TYPE_U64],
143
- [MODULES.progress, 'Session time', 62, [ValueType.TYPE_STRING], ValueType.TYPE_U64],
144
-
145
- [MODULES.demand, 'Permission', 71, [], ValueType.TYPE_ADDRESS],
146
- [MODULES.demand, 'Has Deadline', 72, [], ValueType.TYPE_BOOL],
147
- [MODULES.demand, 'Deadline', 73, [], ValueType.TYPE_U64],
148
- [MODULES.demand, 'Bounty Count', 74, [], ValueType.TYPE_U64],
149
- [MODULES.demand, 'Has Guard', 75, [], ValueType.TYPE_BOOL],
150
- [MODULES.demand, 'Guard', 76, [], ValueType.TYPE_ADDRESS],
151
- [MODULES.demand, 'Has Service Picked', 77, [], ValueType.TYPE_BOOL],
152
- [MODULES.demand, 'Service Picked', 78, [], ValueType.TYPE_ADDRESS],
153
- [MODULES.demand, 'Presenter Count', 79, [], ValueType.TYPE_U64],
154
- [MODULES.demand, 'Is Presenter', 80, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
155
- [MODULES.demand, 'Who Got Bounty', 81, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS],
142
+ [MODULES.progress, 'Machine', 51, [], ValueType.TYPE_ADDRESS, 'The Machine object that created this Progress.'],
143
+ [MODULES.progress, 'Current Node', 52, [], ValueType.TYPE_STRING, 'The name of the currently running node.'],
144
+ [MODULES.progress, 'Has Parent', 53, [], ValueType.TYPE_BOOL, 'Is the parent Progress defined?'],
145
+ [MODULES.progress, 'Parent', 54, [], ValueType.TYPE_ADDRESS, 'The parent Progress, that contains some child Progress.'],
146
+ [MODULES.progress, 'Has Task', 55, [], ValueType.TYPE_BOOL, 'Does it contain clear task(eg. an Order)?'],
147
+ [MODULES.progress, 'Task', 56, [], ValueType.TYPE_ADDRESS, 'Task object address.'],
148
+ [MODULES.progress, 'Has Unique Permission', 57, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Does Progress define a unique operation permission?', 'Input:opertor name'],
149
+ [MODULES.progress, 'Is Unique Permission Operator', 58, [ValueType.TYPE_STRING, ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is an address an operator with unique permissions?', 'Input 1:operator name; Input 2:address'],
150
+ [MODULES.progress, 'Has Context Repository', 59, [], ValueType.TYPE_BOOL, 'Whether the repository reference for Progress is set?'],
151
+ [MODULES.progress, 'Context Repository', 60, [], ValueType.TYPE_ADDRESS, 'Repository reference for Progress.'],
152
+ [MODULES.progress, 'Last Session Time', 61, [], ValueType.TYPE_U64, 'Time when the previous session was completed.'],
153
+ [MODULES.progress, 'Session Time', 62, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'Time a node completes its session.', 'Input:the node name'],
154
+
155
+ [MODULES.demand, 'Permission', 71, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
156
+ [MODULES.demand, 'Has Deadline', 72, [], ValueType.TYPE_BOOL, 'Whether to set the expiration time of presenting?'],
157
+ [MODULES.demand, 'Deadline', 73, [], ValueType.TYPE_U64, 'The expiration time of presenting.'],
158
+ [MODULES.demand, 'Bounty Count', 74, [], ValueType.TYPE_U64, 'Number of Bounties.'],
159
+ [MODULES.demand, 'Has Guard', 75, [], ValueType.TYPE_BOOL, 'Whether the present guard is set?'],
160
+ [MODULES.demand, 'Guard', 76, [], ValueType.TYPE_ADDRESS, 'The present guard address.'],
161
+ [MODULES.demand, 'Has Service Picked', 77, [], ValueType.TYPE_BOOL, 'Whether a service has been picked and bounties given?'],
162
+ [MODULES.demand, 'Service Picked', 78, [], ValueType.TYPE_ADDRESS, 'Service address that has been picked.'],
163
+ [MODULES.demand, 'Presenter Count', 79, [], ValueType.TYPE_U64, 'Number of presenters.'],
164
+ [MODULES.demand, 'Has Presenter', 80, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a certain address a presenter?', 'Input:address'],
165
+ [MODULES.demand, 'Who Got Bounty', 81, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'The address that bounties given.', 'Input:address'],
156
166
 
157
- [MODULES.order, 'Amount', 91, [], ValueType.TYPE_U64],
158
- [MODULES.order, 'Payer', 92, [], ValueType.TYPE_ADDRESS],
159
- [MODULES.order, 'Service', 93, [], ValueType.TYPE_ADDRESS],
160
- [MODULES.order, 'Has Progress', 94, [], ValueType.TYPE_BOOL],
161
- [MODULES.order, 'Progress', 95, [], ValueType.TYPE_ADDRESS],
162
- [MODULES.order, 'Required Info Counts', 96, [], ValueType.TYPE_U64],
163
- [MODULES.order, 'Discount Used', 97, [], ValueType.TYPE_BOOL],
164
- [MODULES.order, 'Discount', 98, [], ValueType.TYPE_ADDRESS],
165
- [MODULES.order, 'Balance', 99, [], ValueType.TYPE_U64],
166
- [MODULES.order, 'Be Refunded', 100, [], ValueType.TYPE_BOOL],
167
- [MODULES.order, 'Be Withdrawed', 101, [], ValueType.TYPE_BOOL],
167
+ [MODULES.order, 'Amount', 91, [], ValueType.TYPE_U64, 'Order amount.'],
168
+ [MODULES.order, 'Payer', 92, [], ValueType.TYPE_ADDRESS, 'Order payer.'],
169
+ [MODULES.order, 'Service', 93, [], ValueType.TYPE_ADDRESS, 'Service for creating orders.'],
170
+ [MODULES.order, 'Has Progress', 94, [], ValueType.TYPE_BOOL, 'Is there a Progress for executing the order process?'],
171
+ [MODULES.order, 'Progress', 95, [], ValueType.TYPE_ADDRESS, 'Progress address for executing the order process.'],
172
+ [MODULES.order, 'Required Info Counts', 96, [], ValueType.TYPE_U64, 'How much customer information is required for this order?'],
173
+ [MODULES.order, 'Discount Used', 97, [], ValueType.TYPE_BOOL, 'Discount coupon used for this order?'],
174
+ [MODULES.order, 'Discount', 98, [], ValueType.TYPE_ADDRESS, 'Discount address that already used.'],
175
+ [MODULES.order, 'Balance', 99, [], ValueType.TYPE_U64, 'The amount currently in the order.'],
176
+ [MODULES.order, 'Refunded', 100, [], ValueType.TYPE_BOOL, 'Whether a refund has occurred?'],
177
+ [MODULES.order, 'Withdrawed', 101, [], ValueType.TYPE_BOOL, 'Whether a service provider withdrawal has occurred?'],
168
178
 
169
- [MODULES.service, 'Permission', 111, [], ValueType.TYPE_ADDRESS],
170
- [MODULES.service, 'Payee', 112, [], ValueType.TYPE_ADDRESS],
171
- [MODULES.service, 'Has Buy-Guard', 113, [], ValueType.TYPE_BOOL],
172
- [MODULES.service, 'Buy-Guard', 114, [], ValueType.TYPE_ADDRESS],
173
- [MODULES.service, 'Contains Repository', 115, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
174
- [MODULES.service, 'Has Withdraw-Guard', 116, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
175
- [MODULES.service, 'Withdraw-Guard Percent', 117, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
176
- [MODULES.service, 'Has Refund-Guard', 118, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
177
- [MODULES.service, 'Refund-Guard Percent', 119, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
178
- [MODULES.service, 'Has Sale Item', 120, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],
179
- [MODULES.service, 'Sale Item Price', 121, [ValueType.TYPE_STRING], ValueType.TYPE_U64],
180
- [MODULES.service, 'Sale Item Inventory', 122, [ValueType.TYPE_STRING], ValueType.TYPE_U64],
181
- [MODULES.service, 'Has Machine', 123, [], ValueType.TYPE_BOOL],
182
- [MODULES.service, 'Machine', 124, [], ValueType.TYPE_ADDRESS],
183
- [MODULES.service, 'Paused', 125, [], ValueType.TYPE_BOOL],
184
- [MODULES.service, 'Published', 126, [], ValueType.TYPE_BOOL],
185
- [MODULES.service, 'Has Required Info', 127, [], ValueType.TYPE_BOOL],
186
- [MODULES.service, 'Required Info of Service-Pubkey', 128, [], ValueType.TYPE_STRING],
187
- [MODULES.service, 'Required Info', 129, [], ValueType.TYPE_STRING],
179
+ [MODULES.service, 'Permission', 111, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
180
+ [MODULES.service, 'Payee', 112, [], ValueType.TYPE_ADDRESS, 'Payee address, that all order withdrawals will be collected to this address.'],
181
+ [MODULES.service, 'Has Buying Guard', 113, [], ValueType.TYPE_BOOL, 'Is the guard condition of buying set?'],
182
+ [MODULES.service, 'Buying Guard', 114, [], ValueType.TYPE_ADDRESS, 'Buying guard, that Purchase only if you meet the conditions of the guard.'],
183
+ [MODULES.service, 'Contains Repository', 115, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, "Is a certain repository one of the service's consensus repositories?", 'Input:address'],
184
+ [MODULES.service, 'Has Withdrawing Guard', 116, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a certain guard is set when withdrawing money?', 'Input:address'],
185
+ [MODULES.service, 'Withdrawing Guard Percent', 117, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The percentage of withdrawals allowed by a certain withdrawal guard.', 'Input:address'],
186
+ [MODULES.service, 'Has Refunding Guard', 118, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a certain guard is set when refunding money?', 'Input:address'],
187
+ [MODULES.service, 'Refunding Guard Percent', 119, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The percentage of refund allowed by a certain refund guard.', 'Input:address'],
188
+ [MODULES.service, 'Has Sales Item', 120, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Is there a sales item for the service?', 'Input:the item name'],
189
+ [MODULES.service, 'Sale Item Price', 121, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'What is the price of a certain sale item?', 'Input:the item name'],
190
+ [MODULES.service, 'Sale Item Inventory', 122, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'How much inventory is there for a certain sales item?', 'Input:the item name'],
191
+ [MODULES.service, 'Has Machine', 123, [], ValueType.TYPE_BOOL, "Has the machine(progress generator) that serves the order been set up?"],
192
+ [MODULES.service, 'Machine', 124, [], ValueType.TYPE_ADDRESS, 'Machine address, that generate progresses serving the execution process of order.'],
193
+ [MODULES.service, 'Paused', 125, [], ValueType.TYPE_BOOL, 'Pause the creation of new order?'],
194
+ [MODULES.service, 'Published', 126, [], ValueType.TYPE_BOOL, 'Is it allowed to create orders?'],
195
+ [MODULES.service, 'Has Required Info', 127, [], ValueType.TYPE_BOOL, 'Whether the necessary information that needs to be provided by the customer is set?'],
196
+ [MODULES.service, 'Required Info of Service-Pubkey', 128, [], ValueType.TYPE_STRING, 'The public key used to encrypt customer information, and only the service provider can decrypt and view customer information.'],
197
+ [MODULES.service, 'Required Info', 129, [], ValueType.TYPE_VEC_STRING, 'Names of the required information item that needs to be provided by the customer.'],
188
198
 
189
- [MODULES.reward, 'Permission', 151, [], ValueType.TYPE_ADDRESS],
190
- [MODULES.reward, 'Reward Count Left', 152, [], ValueType.TYPE_U64],
191
- [MODULES.reward, 'Reward Count Supplied', 153, [], ValueType.TYPE_U64],
192
- [MODULES.reward, 'Guard Count', 154, [], ValueType.TYPE_U64],
193
- [MODULES.reward, 'Has Guard', 155, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
194
- [MODULES.reward, 'Guard Portion', 156, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
195
- [MODULES.reward, 'Deadline', 157, [], ValueType.TYPE_U64],
196
- [MODULES.reward, 'Has Claimed by Address', 158, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
197
- [MODULES.reward, 'Claimed by Address', 159, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
198
- [MODULES.reward, 'Address Count Claimed', 160, [], ValueType.TYPE_U64],
199
- [MODULES.reward, 'Is Sponsor', 161, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
200
- [MODULES.reward, 'Portion by Sponsor', 162, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
201
- [MODULES.reward, 'Sponsor Count', 163, [], ValueType.TYPE_U64],
202
- [MODULES.reward, 'Allow Repeat Claim', 164, [], ValueType.TYPE_BOOL],
203
- [MODULES.reward, 'Claimed Portion by Address', 165, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
199
+ [MODULES.reward, 'Permission', 151, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
200
+ [MODULES.reward, 'Rewards Remaining', 152, [], ValueType.TYPE_U64, 'Number of rewards to be claimed.'],
201
+ [MODULES.reward, 'Reward Count Supplied', 153, [], ValueType.TYPE_U64, 'Total rewards supplied.'],
202
+ [MODULES.reward, 'Guard Count', 154, [], ValueType.TYPE_U64, 'The number of claiming guards.'],
203
+ [MODULES.reward, 'Has Guard', 155, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a claiming guard is set up?', 'Input:address'],
204
+ [MODULES.reward, 'Guard Portion', 156, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The portions of rewards, that can be claimed if a certain guard condition is met.', 'Input:address'],
205
+ [MODULES.reward, 'Deadline', 157, [], ValueType.TYPE_U64, 'The expiration time of claiming.'],
206
+ [MODULES.reward, 'Has Claimed by An Address', 158, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a certain address has claimed rewards?', 'Input:address'],
207
+ [MODULES.reward, 'Portions Claimed by An Address', 159, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The portions of rewards that have been claimed by a certain address.'],
208
+ [MODULES.reward, 'Number of Addresses Claimed', 160, [], ValueType.TYPE_U64, 'Number of addresses that have claimed rewards.'],
209
+ [MODULES.reward, 'Is Sponsor', 161, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is a sponsor of the reward pool?', 'Input:address'],
210
+ [MODULES.reward, 'Portions by A Sponsor', 162, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The portions of sponsorship reward pools for a certain address.', 'Input:address'],
211
+ [MODULES.reward, 'Number of Sponsors', 163, [], ValueType.TYPE_U64, 'Number of sponsors in the sponsorship reward pool.'],
212
+ [MODULES.reward, 'Allow Repeated Claims', 164, [], ValueType.TYPE_BOOL, 'Whether to allow repeated claims?'],
204
213
 
205
- [MODULES.vote, 'Permission', 171, [], ValueType.TYPE_ADDRESS],
214
+ /* [MODULES.vote, 'Permission', 171, [], ValueType.TYPE_ADDRESS],
206
215
  [MODULES.vote, 'Options Locked', 172, [], ValueType.TYPE_BOOL],
207
216
  [MODULES.vote, 'Deadline Locked', 173, [], ValueType.TYPE_BOOL],
208
217
  [MODULES.vote, 'Vote-Guard Locked', 174, [], ValueType.TYPE_BOOL],
@@ -223,24 +232,24 @@ export class Guard {
223
232
  [MODULES.vote, 'Top1 Option by Addresses', 189, [], ValueType.TYPE_STRING],
224
233
  [MODULES.vote, 'Top1 Count by Addresses', 190, [], ValueType.TYPE_U64],
225
234
  [MODULES.vote, 'Top1 Option by Votes', 191, [], ValueType.TYPE_STRING],
226
- [MODULES.vote, 'Top1 Count by Votes', 192, [], ValueType.TYPE_U64],
227
-
228
- [MODULES.wowok, 'Builder', 210, [], ValueType.TYPE_ADDRESS],
229
- [MODULES.wowok, 'Everyone-Guard', 211, [], ValueType.TYPE_ADDRESS],
230
- [MODULES.wowok, 'Object of Entities', 212, [], ValueType.TYPE_ADDRESS],
231
- [MODULES.wowok, 'Grantor Count', 213, [], ValueType.TYPE_U64],
232
- [MODULES.wowok, 'Has Grantor', 214, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
233
- [MODULES.wowok, 'Grantor Name', 215, [ValueType.TYPE_ADDRESS], ValueType.TYPE_STRING],
234
- [MODULES.wowok, 'Grantor Registration Time', 216, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
235
- [MODULES.wowok, 'Grantor Expired Time', 217, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
236
- [MODULES.wowok, 'Grantee Object for Grantor', 218, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS],
237
-
238
- [MODULES.entity, 'Has Entity', 230, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
239
- [MODULES.entity, 'Likes', 231, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
240
- [MODULES.entity, 'Dislikes', 232, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
241
- [MODULES.entity, 'Entity Info', 233, [ValueType.TYPE_ADDRESS], ValueType.TYPE_VEC_U8],
242
- [MODULES.entity, 'Has Resource by Entity', 234, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
243
- [MODULES.entity, 'Entity Resource', 235, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS],
235
+ [MODULES.vote, 'Top1 Count by Votes', 192, [], ValueType.TYPE_U64], */
236
+
237
+ [MODULES.wowok, 'Builder', 210, [], ValueType.TYPE_ADDRESS, 'Builder address of Wowok.'],
238
+ [MODULES.wowok, 'Everyone Guard', 211, [], ValueType.TYPE_ADDRESS, 'A guard that all addresses can pass through.'],
239
+ [MODULES.wowok, 'Object of Entities', 212, [], ValueType.TYPE_ADDRESS, 'The address of entity information object.'],
240
+ [MODULES.wowok, 'Grantor Count', 213, [], ValueType.TYPE_U64, 'Number of registered grantors.'],
241
+ [MODULES.wowok, 'Has Grantor', 214, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address has been registered as a grantor?', , 'Input:address'],
242
+ [MODULES.wowok, 'Grantor Name', 215, [ValueType.TYPE_ADDRESS], ValueType.TYPE_STRING, "Name of a grantor.", 'Input:address'],
243
+ [MODULES.wowok, 'Grantor Registration Time', 216, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'Registration time of a grantor.', 'Input:address'],
244
+ [MODULES.wowok, 'Grantor Expired Time', 217, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The expiration time of a grantor.', 'Input:address'],
245
+ [MODULES.wowok, 'Grantee Object for Grantor', 218, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'Grantee repository address of a grantor.', 'Input:address'],
246
+
247
+ [MODULES.entity, 'Contains Entity?', 230, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is an entity already registered?', 'Input:address'],
248
+ [MODULES.entity, 'Likes', 231, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The number of likes for an address by other addresses.', 'Input:address'],
249
+ [MODULES.entity, 'Dislikes', 232, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The number of dislikes for an address by other addresses.', 'Input:address'],
250
+ [MODULES.entity, 'Entity Info', 233, [ValueType.TYPE_ADDRESS], ValueType.TYPE_VEC_U8, 'Public information about an entity.', 'Input:address'],
251
+ [MODULES.entity, 'Has Resource by Entity?', 234, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an entity created a resource?', 'Input:address'],
252
+ [MODULES.entity, 'Entity Resource', 235, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'The address of a resource object created by an entity.', 'Input:address'],
244
253
  ];
245
254
 
246
255
  static BoolCmd = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_BOOL);
@@ -270,34 +279,42 @@ export class Guard {
270
279
  const r: Guard_Options[] = [...Guard.CmdFilter(ValueType.TYPE_U8), ...Guard.CmdFilter(ValueType.TYPE_U64),
271
280
  ...Guard.CmdFilter(ValueType.TYPE_U128), ...Guard.CmdFilter(ValueType.TYPE_U256)].map((v)=> {
272
281
  return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
273
- r.push({from:'type', name:'Txn Time', value:ContextType.TYPE_CLOCK, group:'Txn Functions'});
274
- r.push({from:'type', name:'PositiveNumber Add (+)', value:OperatorType.TYPE_NUMBER_ADD, group:'Number Crunching'});
275
- r.push({from:'type', name:'PositiveNumber Subtract (-)', value:OperatorType.TYPE_NUMBER_SUBTRACT, group:'Number Crunching'});
276
- r.push({from:'type', name:'PositiveNumber Multiply (*)', value:OperatorType.TYPE_NUMBER_MULTIPLY, group:'Number Crunching'});
277
- r.push({from:'type', name:'PositiveNumber Devide (/)', value:OperatorType.TYPE_NUMBER_DEVIDE, group:'Number Crunching'});
278
- r.push({from:'type', name:'PositiveNumber Mod (%)', value:OperatorType.TYPE_NUMBER_MOD, group:'Number Crunching'});
279
- return r;
282
+ return r.concat(Guard.Crunchings);
280
283
  }
281
284
 
285
+ static Signer:Guard_Options = {from:'type', name:'Txn Signer', value:ContextType.TYPE_SIGNER, group:'Txn Functions'};
286
+ static Time:Guard_Options = {from:'type', name:'Txn Time', value:ContextType.TYPE_CLOCK, group:'Txn Functions'};
287
+ static Logics = () :Guard_Options[] => LogicsInfo.map((v) => { return {from:'type', name:v[1] as string, value:v[0] as number, group:'Compare or Logic'}});
288
+ static Crunchings: Guard_Options[] = [
289
+ {from:'type', name:'Txn Time', value:ContextType.TYPE_CLOCK, group:'Txn Functions'},
290
+ {from:'type', name:'PositiveNumber Add (+)', value:OperatorType.TYPE_NUMBER_ADD, group:'Number Crunching'},
291
+ {from:'type', name:'PositiveNumber Subtract (-)', value:OperatorType.TYPE_NUMBER_SUBTRACT, group:'Number Crunching'},
292
+ {from:'type', name:'PositiveNumber Multiply (*)', value:OperatorType.TYPE_NUMBER_MULTIPLY, group:'Number Crunching'},
293
+ {from:'type', name:'PositiveNumber Devide (/)', value:OperatorType.TYPE_NUMBER_DEVIDE, group:'Number Crunching'},
294
+ {from:'type', name:'PositiveNumber Mod (%)', value:OperatorType.TYPE_NUMBER_MOD, group:'Number Crunching'},
295
+ ]
296
+
282
297
  static CommonOptions = (retType:ValueType) : Guard_Options[] => {
283
298
  return Guard.CmdFilter(retType).map((v)=> {return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
284
299
  }
300
+
285
301
  static AllOptions = () : Guard_Options[] => {
286
- return Guard.QUERIES.map((v)=>{return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
302
+ var r:Guard_Options[] = Guard.QUERIES.map((v)=>{return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
303
+ return [...r, ...Guard.Crunchings, ...Guard.Logics(), Guard.Signer, Guard.Time]
287
304
  }
305
+
288
306
  static StringOptions = () : Guard_Options[] => {
289
- return [...Guard.CmdFilter(ValueType.TYPE_VEC_U8), ...Guard.CmdFilter(ValueType.TYPE_STRING)].map((v) => {
307
+ return [...Guard.CmdFilter(ValueType.TYPE_STRING)].map((v) => {
290
308
  return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])};
291
309
  });
292
310
  }
293
311
  static BoolOptions = () : Guard_Options[] => {
294
312
  const n1:Guard_Options[] = Guard.BoolCmd.map((v)=> { return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
295
- const n2:Guard_Options[] = LogicsInfo.map((v) => { return {from:'type', name:v[1] as string, value:v[0] as number, group:'Compare or Logic'}});
296
- return [...n1, ...n2]
313
+ return [...n1, ...Guard.Logics()];
297
314
  }
298
315
  static AddressOptions = () : Guard_Options[] => {
299
316
  const n1:Guard_Options[] = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_ADDRESS).map((v)=> { return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
300
- n1.push({from:'type', name:'Txn Signer', value:ContextType.TYPE_SIGNER, group:'Txn Functions'});
317
+ n1.push(Guard.Signer);
301
318
  return [...n1]
302
319
  }
303
320
 
@@ -355,8 +372,13 @@ export class GuardConstantHelper {
355
372
  }
356
373
 
357
374
  static add_constant(constants:GuardConstant, identifier:number, type:ValueType, value:any, bNeedSerialize=true) {
358
- if (!GuardConstantHelper.IsValidIndentifier(identifier)) return false;
359
- if (!value) return false;
375
+ const e = SER_VALUE.find((v:any)=>v.type===type)?.name ?? '' + ' invalid';
376
+ if (!GuardConstantHelper.IsValidIndentifier(identifier)) {
377
+ ERROR(Errors.InvalidParam, 'add_constant identifier')
378
+ }
379
+ if (value === undefined) {
380
+ ERROR(Errors.InvalidParam, 'add_constant value')
381
+ }
360
382
 
361
383
  switch (type) {
362
384
  case ValueType.TYPE_BOOL:
@@ -377,27 +399,28 @@ export class GuardConstantHelper {
377
399
  case ValueType.TYPE_VEC_BOOL:
378
400
  case ValueType.TYPE_VEC_U128:
379
401
  case ValueType.TYPE_VEC_U256:
380
- let ser = SER_VALUE.find(s=>s.type==type);
381
- if (!ser) ERROR(Errors.Fail, 'add_constant: invalid type');
382
- bNeedSerialize ? constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.type as number, value)}) :
383
- constants.set(identifier, {type:type, value:value})
384
- return
402
+ case ValueType.TYPE_STRING:
385
403
  case ValueType.TYPE_VEC_U8:
386
- if (typeof(value) === 'string') {
387
- constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ValueType.TYPE_STRING, value)})
404
+ case ValueType.TYPE_OPTION_STRING:
405
+ case ValueType.TYPE_OPTION_VEC_U8:
406
+ case ValueType.TYPE_VEC_STRING:
407
+ let ser = SER_VALUE.find(s=>s.type==type);
408
+ if (!ser) ERROR(Errors.Fail, 'add_constant: invalid type:'+e);
409
+ if (bNeedSerialize) {
410
+ constants.set(identifier, {type:type, value:Bcs.getInstance().ser(type, value)})
388
411
  } else {
389
- constants.set(identifier, {type:type, value:value})
412
+ constants.set(identifier, {type:type, value:value})
390
413
  }
391
- return;
414
+ return
392
415
  default:
393
- ERROR(Errors.Fail, 'add_constant serialize not impl yet')
416
+ ERROR(Errors.Fail, 'add_constant serialize not impl yet:'+e)
394
417
  }
395
418
  }
396
419
  }
397
420
  export class GuardMaker {
398
421
  protected data : Uint8Array[] = [];
399
422
  protected type_validator : Data_Type[] = [];
400
- protected constant : GuardConstant = new Map();
423
+ protected constant : GuardConstant = new Map<number, Guard_Variable>();
401
424
 
402
425
  private static index: number = 0;
403
426
  private static get_index() {
@@ -409,9 +432,9 @@ export class GuardMaker {
409
432
 
410
433
  constructor() { }
411
434
 
412
- add_constant(type:ConstantType, value:any, bNeedSerialize=true) : number {
413
- let identifier = GuardMaker.get_index();
414
- if (type == ContextType.TYPE_WITNESS_ID) {
435
+ add_constant(type:ConstantType, value:any, identifier?:number, bNeedSerialize=true) : number {
436
+ if (identifier === undefined) identifier = GuardMaker.get_index();
437
+ if (type === ContextType.TYPE_WITNESS_ID) {
415
438
  // add witness to constant
416
439
  GuardConstantHelper.add_future_constant(this.constant, identifier, value, undefined, bNeedSerialize);
417
440
  } else {
@@ -421,7 +444,7 @@ export class GuardMaker {
421
444
  }
422
445
 
423
446
  private serValueParam(type:ValueType, param?:any) {
424
- if (!param) ERROR(Errors.InvalidParam, 'param');
447
+ if (param === undefined) ERROR(Errors.InvalidParam, 'param');
425
448
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
426
449
  let ser = SER_VALUE.find(s=>s.type==type);
427
450
  if (!ser) ERROR(Errors.Fail, 'serValueParam: invalid type');
@@ -431,6 +454,8 @@ export class GuardMaker {
431
454
 
432
455
  // serialize const & data
433
456
  add_param(type:ValueType | ContextType, param?:any) : GuardMaker {
457
+ const e = SER_VALUE.find((v:any)=>v.type===type)?.name ?? '' + ' invalid';
458
+
434
459
  switch(type) {
435
460
  case ValueType.TYPE_ADDRESS:
436
461
  case ValueType.TYPE_BOOL:
@@ -454,7 +479,7 @@ export class GuardMaker {
454
479
  break;
455
480
  case ValueType.TYPE_STRING:
456
481
  case ValueType.TYPE_VEC_U8:
457
- if (!param) ERROR(Errors.InvalidParam, 'param');
482
+ if (!param) ERROR(Errors.InvalidParam, 'param:'+e);
458
483
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); //@ USE VEC-U8
459
484
  if (typeof(param) == 'string') {
460
485
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_STRING, param));
@@ -472,56 +497,56 @@ export class GuardMaker {
472
497
  this.type_validator.push(ValueType.TYPE_U64);
473
498
  break;
474
499
  case ContextType.TYPE_WITNESS_ID:
475
- if (!param) ERROR(Errors.InvalidParam, 'param');
500
+ if (!param) ERROR(Errors.InvalidParam, 'param:'+e);
476
501
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
477
502
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, param));
478
503
  this.type_validator.push(ValueType.TYPE_ADDRESS);
479
504
  break;
480
505
  case ContextType.TYPE_CONSTANT:
481
506
  if (!param) {
482
- ERROR(Errors.InvalidParam, 'param invalid');
507
+ ERROR(Errors.InvalidParam, 'param invalid:'+e);
483
508
  }
484
509
  if (typeof(param) != 'number' || !IsValidInt(param) || param > 255) {
485
- ERROR(Errors.InvalidParam, 'add_param param');
510
+ ERROR(Errors.InvalidParam, 'add_param param:'+type);
486
511
  }
487
512
 
488
513
  var v = this.constant.get(param);
489
- if (!v) ERROR(Errors.Fail, 'identifier not in constant');
514
+ if (!v) ERROR(Errors.Fail, 'identifier not in constant:'+e);
490
515
  this.type_validator.push(v!.type);
491
516
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
492
517
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, param));
493
518
  break;
494
519
  default:
495
- ERROR(Errors.InvalidParam, 'add_param type' + type);
520
+ ERROR(Errors.InvalidParam, 'add_param type:'+e);
496
521
  };
497
522
  return this;
498
523
  }
499
524
 
500
525
  // object_address_from: string for static address; number as identifier inconstant
501
- add_query(module:MODULES, query_name:string, object_address_from:string | number, bWitness:boolean=false) : GuardMaker {
526
+ add_query(module:MODULES, query_name:string, object_address_from:string | number, bWitness:boolean=false) : GuardMaker {
502
527
  let query_index = Guard.QUERIES.findIndex((q) => { return q[0] == module && q[1] == query_name})
503
528
  if (query_index == -1) {
504
- ERROR(Errors.InvalidParam, 'query_name');
529
+ ERROR(Errors.InvalidParam, 'query_name:'+query_name);
505
530
  }
506
531
 
507
532
  if (typeof(object_address_from) == 'number' ) {
508
533
  if (!GuardConstantHelper.IsValidIndentifier(object_address_from)) {
509
- ERROR(Errors.InvalidParam, 'object_address_from');
534
+ ERROR(Errors.InvalidParam, 'object_address_from:'+query_name);
510
535
  }
511
536
  } else {
512
537
  if (!IsValidAddress(object_address_from)) {
513
- ERROR(Errors.InvalidParam, 'object_address_from');
538
+ ERROR(Errors.InvalidParam, 'object_address_from:'+query_name);
514
539
  }
515
540
  }
516
541
 
517
542
  let offset = this.type_validator.length - Guard.QUERIES[query_index][3].length;
518
543
  if (offset < 0) {
519
- ERROR(Errors.InvalidParam, 'query_name');
544
+ ERROR(Errors.InvalidParam, 'query_name:'+query_name);
520
545
  }
521
546
 
522
547
  let types = this.type_validator.slice(offset);
523
548
  if (!array_equal(types, Guard.QUERIES[query_index][3])) { // type validate
524
- ERROR(Errors.Fail, 'array_equal');
549
+ ERROR(Errors.Fail, 'array_equal:'+query_name);
525
550
  }
526
551
 
527
552
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_QUERY)); // QUERY TYPE
@@ -531,12 +556,12 @@ export class GuardMaker {
531
556
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, object_address_from)); // object address
532
557
  } else {
533
558
  let v = this.constant.get(object_address_from);
534
- if (!v) ERROR(Errors.Fail, 'object_address_from not in constant');
559
+ if (!v) ERROR(Errors.Fail, 'object_address_from not in constant:'+query_name);
535
560
  if ((bWitness && v?.type == ContextType.TYPE_WITNESS_ID) || (!bWitness && v?.type == ValueType.TYPE_ADDRESS)) {
536
561
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT));
537
562
  this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, object_address_from)); // object identifer in constants
538
563
  } else {
539
- ERROR(Errors.Fail, 'type bWitness not match')
564
+ ERROR(Errors.Fail, 'type bWitness not match:'+query_name)
540
565
  }
541
566
  }
542
567
 
@@ -546,7 +571,10 @@ export class GuardMaker {
546
571
  return this;
547
572
  }
548
573
 
549
- add_logic(type:OperatorType) : GuardMaker {
574
+ add_logic(type:OperatorType, param:number=2) : GuardMaker {
575
+ var e:any = LogicsInfo.find((v:any) => v[0] === type);
576
+ if (e) { e=e[1] }
577
+
550
578
  let splice_len = 2;
551
579
  let ret = ValueType.TYPE_BOOL;
552
580
  switch (type) {
@@ -555,26 +583,41 @@ export class GuardMaker {
555
583
  case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
556
584
  case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
557
585
  case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
558
- if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length') }
559
- if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1])) { ERROR(Errors.Fail, 'type_validator check') }
560
- if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) { ERROR(Errors.Fail, 'type_validator check') }
586
+ if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length:' + e) }
587
+ if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1])) { ERROR(Errors.Fail, 'type_validator check:'+e) }
588
+ if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) { ERROR(Errors.Fail, 'type_validator check:'+e) }
561
589
  break;
562
590
  case OperatorType.TYPE_LOGIC_EQUAL:
563
- if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length') }
591
+ if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length:' + e) }
592
+ if (GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1]) &&
593
+ GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) {
594
+ break;
595
+ } else if (this.type_validator[this.type_validator.length - 1] === this.type_validator[this.type_validator.length - 2]) {
596
+ break;
597
+ } else {
598
+ ERROR(Errors.Fail, 'type_validator check:' + e) ;
599
+ }
564
600
  break;
565
601
  case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
566
- if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length') }
602
+ if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length:' + e) }
603
+ if (this.type_validator[this.type_validator.length - 1] !== ValueType.TYPE_STRING ||
604
+ this.type_validator[this.type_validator.length - 2] !== ValueType.TYPE_STRING) {
605
+ ERROR(Errors.Fail, 'type_validator check:' + e) ;
606
+ }
567
607
  break;
568
608
  case OperatorType.TYPE_LOGIC_NOT:
569
609
  splice_len = 1;
570
- if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length') }
571
- if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check') }
610
+ if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length:'+e) }
611
+ if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check:'+e) }
572
612
  break;
573
613
  case OperatorType.TYPE_LOGIC_AND:
574
- case OperatorType.TYPE_LOGIC_OR:
575
- if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length') }
576
- if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check') }
577
- if (this.type_validator[this.type_validator.length -2] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check') }
614
+ case OperatorType.TYPE_LOGIC_OR: //@ logics count
615
+ if (!param || param < 2) ERROR(Errors.Fail, 'logic param invalid:'+e);
616
+ splice_len = param!;
617
+ if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length:'+e) }
618
+ for (let i = 1; i <= splice_len; ++i) {
619
+ if (this.type_validator[this.type_validator.length -i] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check:'+e) }
620
+ }
578
621
  break;
579
622
  case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
580
623
  break;
@@ -583,15 +626,19 @@ export class GuardMaker {
583
626
  case OperatorType.TYPE_NUMBER_MULTIPLY:
584
627
  case OperatorType.TYPE_NUMBER_SUBTRACT:
585
628
  case OperatorType.TYPE_NUMBER_MOD:
586
- if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length') }
587
- if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -1])) { ERROR(Errors.Fail, 'type_validator check') }
588
- if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -2])) { ERROR(Errors.Fail, 'type_validator check') }
629
+ if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length:'+e) }
630
+ if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -1])) { ERROR(Errors.Fail, 'type_validator check:'+e) }
631
+ if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -2])) { ERROR(Errors.Fail, 'type_validator check:'+e) }
589
632
  ret = ValueType.TYPE_U256;
590
633
  break;
591
634
  default:
592
- ERROR(Errors.InvalidParam, 'add_logic type invalid' + type)
635
+ ERROR(Errors.InvalidParam, 'add_logic type invalid:' + e)
593
636
  }
594
- this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // TYPE
637
+
638
+ this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // TYPE
639
+ if (type === OperatorType.TYPE_LOGIC_AND || type === OperatorType.TYPE_LOGIC_OR) {
640
+ this.data.push((Bcs.getInstance().ser(ValueType.TYPE_U8, param))); //@ logics
641
+ }
595
642
  this.type_validator.splice(this.type_validator.length - splice_len); // delete type stack
596
643
  this.type_validator.push(ret); // add bool to type stack
597
644
  return this;
@@ -601,6 +648,10 @@ export class GuardMaker {
601
648
  return (type === ValueType.TYPE_U8 || type === ValueType.TYPE_U64 || type === ValueType.TYPE_U128 || type === ValueType.TYPE_U256)
602
649
  }
603
650
 
651
+ hasIdentifier(id:number) : boolean {
652
+ return this.constant.has(id)
653
+ }
654
+
604
655
  build(bNot = false) : GuardMaker {
605
656
  //console.log(this.type_validator);
606
657
  //this.data.forEach((value:Uint8Array) => console.log(value));
@@ -632,7 +683,7 @@ export class GuardMaker {
632
683
  maker.constant.set(k, {type:v.type, value:v.value, witness:v.witness});
633
684
  })
634
685
  let op = bAnd ? OperatorType.TYPE_LOGIC_AND : OperatorType.TYPE_LOGIC_OR;
635
- maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser(ValueType.TYPE_U8, op)));
686
+ maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser(ValueType.TYPE_U8, 2), Bcs.getInstance().ser(ValueType.TYPE_U8, op)));
636
687
  this.data.splice(0, this.data.length-1);
637
688
  maker.type_validator = this.type_validator;
638
689
  return maker
@@ -641,22 +692,17 @@ export class GuardMaker {
641
692
  get_constant() { return this.constant }
642
693
  get_input() { return this.data }
643
694
 
695
+ // and/or + logics count
644
696
  static input_combine(input1:Uint8Array, input2:Uint8Array, bAnd:boolean = true) : Uint8Array {
645
697
  let op = bAnd ? OperatorType.TYPE_LOGIC_AND : OperatorType.TYPE_LOGIC_OR;
646
- return concatenate(Uint8Array, input1, input2, Bcs.getInstance().ser(ValueType.TYPE_U8, op)) as Uint8Array;
698
+ return concatenate(Uint8Array, input1, input2, Bcs.getInstance().ser(ValueType.TYPE_U8, 2), Bcs.getInstance().ser(ValueType.TYPE_U8, op)) as Uint8Array;
647
699
  }
648
700
  static input_not(input:Uint8Array) : Uint8Array {
649
701
  return concatenate(Uint8Array, input, Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_LOGIC_NOT)) as Uint8Array;
650
702
  }
651
703
 
652
704
  static match_u256(type:number) : boolean {
653
- if (type == ValueType.TYPE_U8 ||
654
- type == ValueType.TYPE_U64 ||
655
- type == ValueType.TYPE_U128 ||
656
- type == ValueType.TYPE_U256) {
657
- return true;
658
- }
659
- return false;
705
+ return (type == ValueType.TYPE_U8 || type == ValueType.TYPE_U64 || type == ValueType.TYPE_U128 || type == ValueType.TYPE_U256);
660
706
  }
661
707
  }
662
708
 
package/src/machine.ts CHANGED
@@ -144,10 +144,17 @@ export class Machine {
144
144
  });
145
145
  }
146
146
  } else if (forward?.permission !== undefined && IsValidU64(forward.permission)) {
147
- f = this.txb.moveCall({
148
- target:Protocol.Instance().MachineFn('forward3') as FnCallType,
149
- arguments:[this.txb.pure.u64(forward.permission), this.txb.pure.u16(weight)]
150
- });
147
+ if (forward?.guard) {
148
+ f = this.txb.moveCall({
149
+ target:Protocol.Instance().MachineFn('forward3') as FnCallType,
150
+ arguments:[this.txb.pure.u64(forward.permission), this.txb.pure.u16(weight), this.txb.object(Protocol.TXB_OBJECT(this.txb, forward.guard))]
151
+ });
152
+ } else {
153
+ f = this.txb.moveCall({
154
+ target:Protocol.Instance().MachineFn('forward4') as FnCallType,
155
+ arguments:[this.txb.pure.u64(forward.permission), this.txb.pure.u16(weight)]
156
+ });
157
+ }
151
158
  } else {
152
159
  ERROR(Errors.InvalidParam, 'forward')
153
160
  }
@@ -511,8 +518,8 @@ export class Machine {
511
518
  if (!IsValidName(forward.name)) return 'Forward name invalid'
512
519
  if (forward?.namedOperator && !IsValidName_AllowEmpty(forward?.namedOperator)) return 'Progress Operator invalid';
513
520
  if (forward?.permission && !Permission.IsValidPermissionIndex(forward?.permission)) return 'Permission index invalid';
514
- if (!forward?.permission && !forward?.namedOperator) return 'Both Permission index and Progress Operator empty';
515
- if (forward?.weight && !IsValidUintLarge(forward.weight)) return 'Weight invalid';
521
+ if (!forward?.permission && !forward?.namedOperator) return 'Business-Permissions invalid';
522
+ if (forward?.weight && !IsValidU64(forward.weight)) return 'Weight invalid';
516
523
  return ''
517
524
  }
518
525
 
package/src/passport.ts CHANGED
@@ -50,6 +50,7 @@ export interface FutureFill {
50
50
  future?: string;
51
51
  cmd?: number;
52
52
  type?: string;
53
+ identifier?: number;
53
54
  }
54
55
  export interface PassportQuery {
55
56
  guard: (string | TransactionObjectInput)[];
@@ -70,12 +71,14 @@ export class GuardParser {
70
71
  static DeGuardObject_FromData = (guard_constants:any, guard_input_bytes:any) : {object:DeGuardData, constant:DeGuardConstant[]} => {
71
72
  let constants : DeGuardConstant[] = [];
72
73
  guard_constants.forEach((c:any) => {
73
- let value : any;
74
74
  let v = c?.fields ?? c; // graphql dosnot 'fields', but rpcall has.
75
- switch (v.type) {
75
+ const data:Uint8Array = Uint8Array.from(v.value);
76
+ const type = data.slice(0, 1)[0];
77
+ var value : any = data.slice(1);
78
+ switch (type) {
76
79
  case ContextType.TYPE_WITNESS_ID:
77
80
  case ValueType.TYPE_ADDRESS:
78
- value = '0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(v.value)).toString();
81
+ value = '0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(value)).toString();
79
82
  break;
80
83
  case ValueType.TYPE_BOOL:
81
84
  case ValueType.TYPE_U8:
@@ -95,15 +98,19 @@ export class GuardParser {
95
98
  case ValueType.TYPE_OPTION_U64:
96
99
  case ValueType.TYPE_OPTION_U256:
97
100
  case ValueType.TYPE_VEC_U256:
98
- let de = SER_VALUE.find(s=>s.type==v.type);
101
+ case ValueType.TYPE_STRING:
102
+ case ValueType.TYPE_OPTION_STRING:
103
+ case ValueType.TYPE_OPTION_VEC_U8:
104
+ case ValueType.TYPE_VEC_STRING:
105
+ let de = SER_VALUE.find(s=>s.type==type);
99
106
  if (!de) ERROR(Errors.Fail, 'GuardObject de error')
100
- value = Bcs.getInstance().de(de!.type as number, Uint8Array.from(v.value));
107
+ value = Bcs.getInstance().de(type as number, Uint8Array.from(value));
101
108
  break;
102
109
 
103
110
  default:
104
- ERROR(Errors.Fail, 'GuardObject constant type invalid')
111
+ ERROR(Errors.Fail, 'GuardObject constant type invalid:' +type)
105
112
  }
106
- constants.push({identifier:v.identifier, type:v.type, value:value});
113
+ constants.push({identifier:v.identifier, type:type, value:value});
107
114
  });
108
115
  // console.log(constants)
109
116
  let bytes = Uint8Array.from(guard_input_bytes);
@@ -111,7 +118,7 @@ export class GuardParser {
111
118
  let data : DeGuardData[] = [];
112
119
  while (arr.length > 0) {
113
120
  let type : unknown = arr.shift() ;
114
- let value:any; let cmd:any; let identifier:any;
121
+ let value:any; let cmd:any; let identifier:any;
115
122
  switch (type as Data_Type) {
116
123
  case ContextType.TYPE_SIGNER:
117
124
  case ContextType.TYPE_CLOCK:
@@ -124,14 +131,16 @@ export class GuardParser {
124
131
  case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
125
132
  case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
126
133
  case OperatorType.TYPE_LOGIC_NOT:
127
- case OperatorType.TYPE_LOGIC_AND:
128
- case OperatorType.TYPE_LOGIC_OR:
129
134
  case OperatorType.TYPE_NUMBER_ADD:
130
135
  case OperatorType.TYPE_NUMBER_DEVIDE:
131
136
  case OperatorType.TYPE_NUMBER_MOD:
132
137
  case OperatorType.TYPE_NUMBER_MULTIPLY:
133
138
  case OperatorType.TYPE_NUMBER_SUBTRACT:
134
139
  break;
140
+ case OperatorType.TYPE_LOGIC_AND: //@ with logics count
141
+ case OperatorType.TYPE_LOGIC_OR:
142
+ value = arr.shift()! as number;
143
+ break;
135
144
  case ContextType.TYPE_CONSTANT:
136
145
  identifier = arr.shift()! as number; // identifier
137
146
  break;
@@ -339,7 +348,7 @@ export class GuardParser {
339
348
  current.ret_type = ValueType.TYPE_BOOL;
340
349
  if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
341
350
  var p1 = stack.pop() as DeGuardData; var p2 = stack.pop() as DeGuardData;
342
- console.log(p1); console.log(p2)
351
+ //console.log(p1); console.log(p2)
343
352
  if (!p1.ret_type || !p2.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
344
353
  if (p1.ret_type != p2.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
345
354
 
@@ -352,7 +361,7 @@ export class GuardParser {
352
361
  if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
353
362
  var p1 = stack.pop() as DeGuardData; var p2 = stack.pop() as DeGuardData;
354
363
  if (!p1.ret_type || !p2.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
355
- if (p1.ret_type != ValueType.TYPE_VEC_U8 || p2.ret_type != ValueType.TYPE_VEC_U8) {
364
+ if (p1.ret_type != ValueType.TYPE_STRING || p2.ret_type != ValueType.TYPE_STRING) {
356
365
  ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
357
366
  }
358
367
 
@@ -363,15 +372,12 @@ export class GuardParser {
363
372
  case OperatorType.TYPE_LOGIC_AND:
364
373
  case OperatorType.TYPE_LOGIC_OR:
365
374
  current.ret_type = ValueType.TYPE_BOOL;
366
- if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
367
- var p1 = stack.pop() as DeGuardData; var p2 = stack.pop() as DeGuardData;
368
- if (!p1.ret_type || !p2.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
369
- if (p1.ret_type != ValueType.TYPE_BOOL || p2.ret_type != ValueType.TYPE_BOOL) {
370
- ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
375
+ if (stack.length < current.value || current.value < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
376
+ for (let i = 0; i < current.value; ++i) {
377
+ var p = stack.pop() as DeGuardData;
378
+ if (!p.ret_type || (p.ret_type != ValueType.TYPE_BOOL)) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
379
+ current.child.push(p);
371
380
  }
372
-
373
- current.child.push(p1);
374
- current.child.push(p2);
375
381
  stack.push(current);
376
382
  return
377
383
  case OperatorType.TYPE_QUERY:
@@ -517,15 +523,15 @@ export class GuardParser {
517
523
  this.guard_list.forEach((g) => {
518
524
  g.query_list.forEach((v) => {
519
525
  if (typeof(v) !== 'string') {
520
- ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, cmd:v.cmd});
526
+ ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, cmd:v.cmd, identifier:v?.identifier});
521
527
  }
522
528
  })
523
529
  // cmd already in query_list, so filter it out.
524
530
  g.constant.filter((v)=>v.type === ContextType.TYPE_WITNESS_ID && v.cmd === undefined).forEach((v) => {
525
- ret.push({guard:g.id, index:v.index, witness:v.value_or_witness});
531
+ ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, identifier:v?.identifier});
526
532
  })
527
533
  g.input_witness.forEach((v) => {
528
- ret.push({guard:g.id, index:v.index, witness:v.value_or_witness});
534
+ ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, identifier:v?.identifier});
529
535
  })
530
536
  }); return ret;
531
537
  }
@@ -534,12 +540,16 @@ export class GuardParser {
534
540
  constants.forEach((v:any) => {
535
541
  if (v.type == (Protocol.Instance().Package() + '::guard::Constant')) {
536
542
  // ValueType.TYPE_ADDRESS: Query_Cmd maybe used the address, so save it for querying
537
- if (v.fields.type == ContextType.TYPE_WITNESS_ID || v.fields.type == ValueType.TYPE_ADDRESS) {
538
- info.constant.push({identifier:v.fields.identifier, index:this.get_index(), type:v.fields.type,
539
- value_or_witness:'0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(v.fields.value))});
543
+ const data = Uint8Array.from(v.fields.value);
544
+ const type = data.slice(0, 1)[0];
545
+ const value = data.slice(1);
546
+ if (type == ContextType.TYPE_WITNESS_ID || type == ValueType.TYPE_ADDRESS) {
547
+ info.constant.push({identifier:v.fields.identifier, index:this.get_index(), type:type,
548
+ value_or_witness:'0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(value))});
540
549
  }
541
550
  }
542
551
  });
552
+ //console.log(info.constant)
543
553
  }
544
554
 
545
555
  parse_bcs = (info:GuardInfo, chain_bytes: Uint8Array) => {
@@ -559,14 +569,16 @@ export class GuardParser {
559
569
  case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
560
570
  case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
561
571
  case OperatorType.TYPE_LOGIC_NOT:
562
- case OperatorType.TYPE_LOGIC_AND:
563
- case OperatorType.TYPE_LOGIC_OR:
564
572
  case OperatorType.TYPE_NUMBER_ADD:
565
573
  case OperatorType.TYPE_NUMBER_DEVIDE:
566
574
  case OperatorType.TYPE_NUMBER_MOD:
567
575
  case OperatorType.TYPE_NUMBER_MULTIPLY:
568
576
  case OperatorType.TYPE_NUMBER_SUBTRACT:
569
577
  break;
578
+ case OperatorType.TYPE_LOGIC_AND: //@ logics count
579
+ case OperatorType.TYPE_LOGIC_OR:
580
+ arr.splice(0, 1); // identifier of constant
581
+ break;
570
582
  case ContextType.TYPE_CONSTANT:
571
583
  arr.splice(0, 1); // identifier of constant
572
584
  break;
@@ -765,13 +777,13 @@ export class Passport {
765
777
  const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
766
778
  // rules: 'verify' & 'query' in turns; 'verify' at final end.
767
779
  query?.query.forEach((q) => {
768
- let address = this.txb.moveCall({
780
+ this.txb.moveCall({
769
781
  target: Protocol.Instance().PassportFn('passport_verify') as FnCallType,
770
782
  arguments: [ this.passport, this.txb.object(clock)]
771
783
  });
772
784
  this.txb.moveCall({
773
785
  target: q.target as FnCallType,
774
- arguments: [ bObject ? this.txb.object(q.object) : this.txb.object(q.id), this.passport, address ],
786
+ arguments: [ bObject ? this.txb.object(q.object) : this.txb.object(q.id), this.passport],
775
787
  typeArguments: q.types,
776
788
  })
777
789
  })
package/src/permission.ts CHANGED
@@ -78,7 +78,7 @@ export enum PermissionIndex {
78
78
  progress_context_repository = 653,
79
79
  progress_unhold = 654,
80
80
  progress_parent = 655,
81
- user_defined_start = 10000,
81
+ user_defined_start = 1000,
82
82
  }
83
83
 
84
84
  export interface PermissionInfoType {
@@ -549,9 +549,10 @@ export class Permission {
549
549
  static PERMISSION_OWNER = 1;
550
550
  static PERMISSION_ADMIN = 2;
551
551
  static PERMISSION_OWNER_AND_ADMIN = 3;
552
+ static BUSINESS_PERMISSIONS_START = PermissionIndex.user_defined_start;
552
553
 
553
554
  static IsValidUserDefinedIndex = (index:number) => {
554
- return index >= PermissionIndex.user_defined_start && IsValidUintLarge(index)
555
+ return index >= Permission.BUSINESS_PERMISSIONS_START && IsValidUintLarge(index)
555
556
  }
556
557
 
557
558
  static IsValidPermissionIndex = (index:PermissionIndexType) : boolean => {
package/src/protocol.ts CHANGED
@@ -82,12 +82,12 @@ export enum OperatorType {
82
82
  }
83
83
 
84
84
  export const LogicsInfo = [
85
- [OperatorType.TYPE_LOGIC_AS_U256_GREATER, 'PositiveNumber >'],
86
- [OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL, 'PositiveNumber >='],
87
- [OperatorType.TYPE_LOGIC_AS_U256_LESSER, 'PositiveNumber <'],
88
- [OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL, 'PositiveNumber <='],
89
- [OperatorType.TYPE_LOGIC_AS_U256_EQUAL, 'PositiveNumber ='],
90
- [OperatorType.TYPE_LOGIC_EQUAL, 'Strict ='],
85
+ [OperatorType.TYPE_LOGIC_AS_U256_GREATER, 'Unsigned Integer >'],
86
+ [OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL, 'Unsigned Integer >='],
87
+ [OperatorType.TYPE_LOGIC_AS_U256_LESSER, 'Unsigned Integer <'],
88
+ [OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL, 'Unsigned Integer <='],
89
+ [OperatorType.TYPE_LOGIC_AS_U256_EQUAL, 'Unsigned Integer ='],
90
+ [OperatorType.TYPE_LOGIC_EQUAL, 'Equal'],
91
91
  [OperatorType.TYPE_LOGIC_HAS_SUBSTRING, 'Sub String'],
92
92
  [OperatorType.TYPE_LOGIC_ALWAYS_TRUE, 'Always True'],
93
93
  [OperatorType.TYPE_LOGIC_NOT, 'Not'],
@@ -128,21 +128,26 @@ export enum RepositoryValueType {
128
128
  PositiveNumber_Vec = 203,
129
129
  String = 204,
130
130
  String_Vec = 205,
131
+ Bool = 206,
131
132
  }
132
133
 
133
134
  export const RepositoryValueTypeInfo = [
134
- {type: RepositoryValueType.String, name:'String', description:'String.'},
135
- {type: RepositoryValueType.Address, name:'Address', description:'Object id or Personal address.'},
136
- {type: RepositoryValueType.PositiveNumber, name:'Positive number or Zero', description:'Positive number or 0. including u8, u16 ,..., u256'},
137
- {type: RepositoryValueType.String_Vec, name:'String vector', description:'Vector of string.'},
138
- {type: RepositoryValueType.Address_Vec, name:'Address vector', description:'Vector of address.'},
139
- {type: RepositoryValueType.PositiveNumber_Vec, name:'Positive number or Zero vector', description:'Vector of positive number or 0'},
135
+ {type: RepositoryValueType.String, name:'string', description:'String.'},
136
+ {type: RepositoryValueType.Address, name:'address', description:'Object id or Personal address.'},
137
+ {type: RepositoryValueType.PositiveNumber, name:'unsigned integer', description:'Including u8, u16 ,..., u256'},
138
+ {type: RepositoryValueType.String_Vec, name:'string vector', description:'Vector of string.'},
139
+ {type: RepositoryValueType.Address_Vec, name:'address vector', description:'Vector of address.'},
140
+ {type: RepositoryValueType.PositiveNumber_Vec, name:'unsigned integer vector', description:'Vector of unsigned integer'},
141
+ {type: RepositoryValueType.Bool, name:'bool', description:'True or False.'},
140
142
  ]
141
143
 
142
144
  export const OperatorTypeArray = (Object.values(OperatorType) as []).filter((v)=>typeof(v) === 'number') as number[];
143
145
  export const ValueTypeArray = (Object.values(ValueType) as []).filter((v)=>typeof(v) === 'number') as number[];
144
146
  export const IsValidOperatorType = (type:number) : boolean => { return OperatorTypeArray.includes(type)}
145
147
  export const IsValidValueType = (type:number) : boolean => { return ValueTypeArray.includes(type)}
148
+ export const IsNumberType = (type:ValueType | any) : boolean => { return type===ValueType.TYPE_U128 || type===ValueType.TYPE_U256 ||
149
+ type===ValueType.TYPE_U64 || type===ValueType.TYPE_U8
150
+ }
146
151
 
147
152
  export enum ContextType {
148
153
  TYPE_SIGNER = 60,
@@ -160,7 +165,7 @@ interface ValueTypeString {
160
165
  export const SER_VALUE: ValueTypeString[] = [
161
166
  {type: ValueType.TYPE_BOOL, name: 'bool', description:'boolean. eg:true or false', validator:(value:any) => { return (value === true || value === false)}},
162
167
  {type: ValueType.TYPE_ADDRESS, name: 'address', description:'address or object-id. eg:0x6789af', validator:IsValidAddress},
163
- {type: ContextType.TYPE_WITNESS_ID, name: 'future address', description:"eg: machine's future progress, service's future order", validator:IsValidAddress},
168
+ {type: ContextType.TYPE_WITNESS_ID, name: 'future address', description:"eg: address of the Machine that will generate future Progress, address of the Service that will generate future Order", validator:IsValidAddress},
164
169
  {type: ContextType.TYPE_SIGNER, name: 'txn signer', description:"signer address of the transaction, "},
165
170
  {type: ContextType.TYPE_CLOCK, name: 'txn time', description:"unsigned-64 number for the transaction time"},
166
171
  {type: ValueType.TYPE_U64, name: 'number', description:'unsigned-64 number. eg:23870233', validator:IsValidU64},
@@ -180,7 +185,7 @@ export const SER_VALUE: ValueTypeString[] = [
180
185
  {type: ValueType.TYPE_OPTION_U256, name: 'option', description:'option of u256. eg:none or u256 value'},
181
186
  {type: ValueType.TYPE_VEC_U256, name: '[number]', description:'unsigned-256 number array. eg:[123, 778888, 42312]'},
182
187
  {type: ValueType.TYPE_VEC_STRING, name: '[string]', description:'ascii string array. eg:["abc", "hi"]'},
183
- {type: ValueType.TYPE_STRING, name: 'string', description:'ascii string. eg:"wowok"', },
188
+ {type: ValueType.TYPE_STRING, name: 'string', description:'eg:"wowok"', },
184
189
  {type: ValueType.TYPE_OPTION_STRING, name: 'option', description:'option of string. eg:none or string value'},
185
190
  {type: ValueType.TYPE_U256, name: 'number', description:'unsigned-256 number. eg:12345678901233', validator:IsValidUintLarge},
186
191
  ]
@@ -194,14 +199,20 @@ export enum ENTRYPOINT {
194
199
  devnet = 'devnet',
195
200
  localnet = 'localnet'
196
201
  }
197
-
202
+ /*
198
203
  const TESTNET = {
199
204
  package: "0xbd3d0929072f7647e521bf72851ccdc7e2169052b22bfdc5b49439c48cfb119a",
200
205
  wowok_object: '0xb0a521a287e9d5e08932b3984dbe6ce159e836179c41bd08c556ef77ecdb7439',
201
206
  entity_object: '0x16aab98920e7341d1dc19631031253234b2b71fc2ab8c32d65ee3ded8072acef',
202
207
  treasury_cap:'0xb75a2ca2f651755c134ad521175f33f9e3f9008ad44340f76b3229e1f30cfdff',
203
208
  }
204
-
209
+ */
210
+ const TESTNET = {
211
+ package: "0x4ce36e03ef9cd230f1158e48293ee01cb572cdcd2f9cab7ac7b2fd2251bfe51e",
212
+ wowok_object: '0xd3639daf1daa300bbf694b21e42cecac6be242ad038fe48a7a1212e93f3845f6',
213
+ entity_object: '0x8de1e01e6baca0990ca18de3ec51b57183512deaeb76076be9161ca38988c74f',
214
+ treasury_cap:'0x2e05eda6ee5b0773854be6eb48c6cee2b5ca8aaa13ee810434d66232005b40ef',
215
+ }
205
216
  const MAINNET = {
206
217
  package: "",
207
218
  wowok_object: '',
package/src/repository.ts CHANGED
@@ -1,8 +1,8 @@
1
- import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject} from './protocol';
1
+ import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject, } from './protocol';
2
2
  import { PermissionIndexType, Permission } from './permission'
3
3
  import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, IsValidName, ValueTypeConvert} from './utils';
4
4
  import { ERROR, Errors } from './exception';
5
- import { MAX_U8, MAX_U128, MAX_U256, MAX_U64 } from './utils';
5
+ import { MAX_U8, MAX_U128, MAX_U256, MAX_U64, stringToUint8Array } from './utils';
6
6
  import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
7
7
 
8
8
  export enum Repository_Policy_Mode {
@@ -22,16 +22,16 @@ export type Repository_Policy = {
22
22
  key:string;
23
23
  description: string;
24
24
  data_type: RepositoryValueType;
25
- permission?: PermissionIndexType; // PermissionIndex like, must be geater than 10000
25
+ permission?: PermissionIndexType; // PermissionIndex like, must be geater than 1000
26
26
  }
27
27
  export type Repository_Policy_Data = {
28
28
  key: string;
29
- data: Repository_Value[];
30
- value_type?: ValueType;
29
+ data: Repository_Value[];
30
+ value_type?: ValueType; //
31
31
  }
32
32
  export type Repository_Value = {
33
33
  address: string; // UID: address or objectid
34
- bcsBytes: Uint8Array;
34
+ bcsBytes: Uint8Array; // BCS contents. Notice that: First Byte be the Type by caller, or specify type with 'Repository_Policy_Data.value_type' field.
35
35
  }
36
36
 
37
37
  export class Repository {
@@ -425,6 +425,8 @@ export class Repository {
425
425
  d = '0x' + d;
426
426
  } else if (type === ValueType.TYPE_VEC_ADDRESS) {
427
427
  d = d.map((v:string) => { return ('0x' + v) } );
428
+ } else if (type === ValueType.TYPE_BOOL) {
429
+ d = d ? 'True' : 'False'
428
430
  }
429
431
  };
430
432
  return {object:v?.data?.content?.fields?.id?.id, id:(v?.data?.content?.fields as any)?.name?.fields?.id,
@@ -454,7 +456,7 @@ export class Repository {
454
456
  } return undefined
455
457
  }
456
458
 
457
- static ResolveRepositoryData = (dataType:RepositoryValueType, data:string | string[]) : {type:ValueType, data: Uint8Array} | undefined => {
459
+ static ResolveRepositoryData = (dataType:RepositoryValueType, data:string | boolean | string[]) : {type:ValueType, data: Uint8Array} | undefined => {
458
460
  if (dataType === RepositoryValueType.String) {
459
461
  return {type: ValueType.TYPE_STRING, data: Bcs.getInstance().ser(ValueType.TYPE_VEC_U8, new TextEncoder().encode(data.toString()))}
460
462
  } else if (dataType === RepositoryValueType.PositiveNumber) {
@@ -491,6 +493,9 @@ export class Repository {
491
493
  return new TextEncoder().encode(v);
492
494
  })
493
495
  return {type: ValueType.TYPE_VEC_STRING, data: Bcs.getInstance().ser(ValueType.TYPE_VEC_VEC_U8, r)}
496
+ } else if (dataType === RepositoryValueType.Bool) {
497
+ if (typeof(data) !== 'boolean') return undefined;
498
+ return {type:ValueType.TYPE_BOOL, data:Bcs.getInstance().ser(ValueType.TYPE_BOOL, data)}
494
499
  }
495
500
  return undefined
496
501
  }
package/src/utils.ts CHANGED
@@ -2,7 +2,7 @@ import { BCS, getSuiMoveConfig, } from '@mysten/bcs';
2
2
  import { SuiObjectResponse, DynamicFieldPage } from '@mysten/sui/client';
3
3
  import { ERROR, Errors } from './exception';
4
4
  import { isValidSuiAddress} from '@mysten/sui/utils'
5
- import { RepositoryValueType, ValueType, Protocol } from './protocol'
5
+ import { RepositoryValueType, ValueType, Protocol, ContextType, OperatorType } from './protocol'
6
6
 
7
7
  export const MAX_U8 = BigInt('255');
8
8
  export const MAX_U64 = BigInt('18446744073709551615');
@@ -13,7 +13,7 @@ export const OPTION_NONE = 0;
13
13
 
14
14
  export const ValueTypeConvert = (type:ValueType | null | undefined) : RepositoryValueType | number => {
15
15
  if (type === ValueType.TYPE_U8 || type === ValueType.TYPE_U64 || type === ValueType.TYPE_U128 ||
16
- type === ValueType.TYPE_U256 || type === ValueType.TYPE_BOOL) {
16
+ type === ValueType.TYPE_U256) {
17
17
  return RepositoryValueType.PositiveNumber
18
18
  } else if (type === ValueType.TYPE_VEC_U8 || type === ValueType.TYPE_VEC_U64 || type === ValueType.TYPE_VEC_U128 ||
19
19
  type === ValueType.TYPE_VEC_U256|| type === ValueType.TYPE_VEC_BOOL) {
@@ -26,7 +26,9 @@ export const ValueTypeConvert = (type:ValueType | null | undefined) : Repository
26
26
  return RepositoryValueType.String
27
27
  } else if (type === ValueType.TYPE_VEC_STRING) {
28
28
  return RepositoryValueType.String_Vec
29
- }
29
+ } else if (type === ValueType.TYPE_BOOL) {
30
+ return RepositoryValueType.Bool
31
+ }
30
32
  return -1;
31
33
  }
32
34
 
@@ -192,7 +194,7 @@ export class Bcs {
192
194
  return this.bcs.ser('Option<u32>', {'some': data}).toBytes();
193
195
  }
194
196
 
195
- ser(type:ValueType | string, data:Uint8Array | any) : Uint8Array {
197
+ ser(type:ValueType | ContextType | string, data:Uint8Array | any) : Uint8Array {
196
198
  if (typeof(type) === 'string') {
197
199
  return this.bcs.ser(type, data).toBytes();
198
200
  }
@@ -239,9 +241,12 @@ export class Bcs {
239
241
  case ValueType.TYPE_U256:
240
242
  return this.bcs.ser(BCS.U256, data).toBytes();
241
243
  case ValueType.TYPE_STRING:
242
- return this.bcs.ser(BCS.STRING, data).toBytes();
244
+ const d = new TextEncoder().encode(data);
245
+ return this.bcs.ser('vector<u8>', d).toBytes();
243
246
  case ValueType.TYPE_VEC_STRING:
244
- return this.bcs.ser('vector<string>', data).toBytes();
247
+ return this.bcs.ser('vector<vector<u8>>', data.map((v:string)=>{return new TextEncoder().encode(v)})).toBytes();
248
+ case ContextType.TYPE_WITNESS_ID:
249
+ return this.bcs.ser(BCS.ADDRESS, data).toBytes();
245
250
  default:
246
251
  ERROR(Errors.bcsTypeInvalid, 'ser');
247
252
  }
@@ -293,7 +298,8 @@ export class Bcs {
293
298
  case ValueType.TYPE_VEC_U256:
294
299
  return this.bcs.de('vector<u256>', data);
295
300
  case ValueType.TYPE_STRING:
296
- return this.bcs.de(BCS.STRING, data);
301
+ const r = new TextDecoder().decode(Uint8Array.from(this.bcs.de('vector<u8>', data)));
302
+ return r
297
303
  case ValueType.TYPE_VEC_STRING:
298
304
  return this.bcs.de('vector<string>', data);
299
305
  case ValueType.TYPE_U256:
@@ -325,13 +331,10 @@ export class Bcs {
325
331
  }
326
332
  }
327
333
 
328
- export function stringToUint8Array(str:string) : Uint8Array {
329
- var arr = [];
330
- for (var i = 0, j = str.length; i < j; ++i) {
331
- arr.push(str.charCodeAt(i));
332
- }
333
- var tmpUint8Array = new Uint8Array(arr);
334
- return tmpUint8Array
334
+ export function stringToUint8Array(str:string) {
335
+ const encoder = new TextEncoder();
336
+ const view = encoder.encode(str);
337
+ return new Uint8Array(view.buffer);
335
338
  }
336
339
 
337
340
  export function numToUint8Array(num:number) : Uint8Array {
@@ -411,6 +414,9 @@ export const IsValidU64 = (value:string | number | undefined | bigint) : boolean
411
414
  export const IsValidU128 = (value:string | number | undefined | bigint) : boolean => {
412
415
  return IsValidBigint(value, MAX_U128, BigInt(0))
413
416
  }
417
+ export const IsValidU256 = (value:string | number | undefined | bigint) : boolean => {
418
+ return IsValidBigint(value, MAX_U256, BigInt(0))
419
+ }
414
420
 
415
421
  export const IsValidTokenType = (argType: string) : boolean => {
416
422
  if (!argType || argType.length === 0) {
@@ -502,6 +508,15 @@ export const ParseType = (type:string) : ArgType => {
502
508
  return {isCoin:false, coin:'', token:''}
503
509
  }
504
510
 
511
+
512
+ export function insertAtHead(array:Uint8Array, value:number) {
513
+ const newLength = array.length + 1;
514
+ const newArray = new Uint8Array(newLength);
515
+ newArray.set([value], 0);
516
+ newArray.set(array, 1);
517
+ return newArray;
518
+ }
519
+
505
520
  export function toFixed(x:number) {
506
521
  let res = '';
507
522
  if (Math.abs(x) < 1.0) {