@@ -2,89 +2,109 @@ import harden from '@agoric/harden';
22import { assert , details } from '@agoric/assert' ;
33import { mustBeComparable } from '@agoric/same-structure' ;
44
5- import { arrayToObj } from './objArrayConversion' ;
5+ import { arrayToObj , assertSubset } from './objArrayConversion' ;
66
7- // cleanProposal checks the keys and values of the proposal, including
8- // the keys and values of the internal objects. The proposal may have
9- // the following keys: `give`, `want`, and `exit`. These keys may be
10- // omitted in the `proposal` argument passed to cleanProposal, but
11- // anything other than these keys is not allowed. The values of `give`
12- // and `want` must be "amountKeywordRecords", meaning that the keys
13- // must be keywords and the values must be amounts. The value of
14- // `exit`, if present, must be a record of one of the following forms:
15- // `{ waived: null }` `{ onDemand: null }` `{ afterDeadline: { timer
16- // :Timer, deadline :Number } }
7+ export const assertCapASCII = keyword => {
8+ assert . typeof ( keyword , 'string' ) ;
9+ const firstCapASCII = / ^ [ A - Z ] [ a - z A - Z 0 - 9 _ $ ] * $ / ;
10+ assert (
11+ firstCapASCII . test ( keyword ) ,
12+ details `keyword ${ keyword } ,
13+ ) ;
14+ } ;
1715
18- // Assert that the keys of record, if present, are in expectedKeys.
19- // Return the keys after asserting this.
20- const checkKeys = ( expectedKeys , record ) => {
21- // Assert that keys, if present, match expectedKeys.
16+ // Assert that the keys of ` record` are all in `allowedKeys`. If a key
17+ // of `record` is not in `allowedKeys`, throw an error. If a key in
18+ // `allowedKeys` is not a key of record, we do not throw an error.
19+ const assertKeysAllowed = ( allowedKeys , record ) => {
2220 const keys = Object . getOwnPropertyNames ( record ) ;
23- keys . forEach ( key => {
24- assert . typeof ( key , 'string' ) ;
25- assert (
26- expectedKeys . includes ( key ) ,
27- details `key ${ key } ,
28- ) ;
29- } ) ;
21+ assertSubset ( allowedKeys , keys ) ;
3022 // assert that there are no symbol properties.
3123 assert (
3224 Object . getOwnPropertySymbols ( record ) . length === 0 ,
3325 details `no symbol properties allowed` ,
3426 ) ;
35- return keys ;
3627} ;
3728
38- const coerceAmountKeywordRecordValues = (
29+ const cleanKeys = ( allowedKeys , record ) => {
30+ assertKeysAllowed ( allowedKeys , record ) ;
31+ return Object . getOwnPropertyNames ( record ) ;
32+ } ;
33+
34+ export const getKeywords = keywordRecord =>
35+ harden ( Object . getOwnPropertyNames ( keywordRecord ) ) ;
36+
37+ export const coerceAmountKeywordRecord = (
3938 amountMathKeywordRecord ,
40- validatedKeywords ,
39+ allKeywords ,
4140 allegedAmountKeywordRecord ,
4241) => {
42+ const sparseKeywords = cleanKeys ( allKeywords , allegedAmountKeywordRecord ) ;
4343 // Check that each value can be coerced using the amountMath indexed
4444 // by keyword. `AmountMath.coerce` throws if coercion fails.
45- const coercedAmounts = validatedKeywords . map ( keyword =>
45+ const coercedAmounts = sparseKeywords . map ( keyword =>
4646 amountMathKeywordRecord [ keyword ] . coerce (
4747 allegedAmountKeywordRecord [ keyword ] ,
4848 ) ,
4949 ) ;
5050
5151 // Recreate the amountKeywordRecord with coercedAmounts.
52- return arrayToObj ( coercedAmounts , validatedKeywords ) ;
52+ return arrayToObj ( coercedAmounts , sparseKeywords ) ;
5353} ;
5454
55- export const coerceAmountKeywordRecord = (
56- amountMathKeywordRecord ,
57- keywords ,
58- allegedAmountKeywordRecord ,
59- ) => {
60- const validatedKeywords = checkKeys ( keywords , allegedAmountKeywordRecord ) ;
61- return coerceAmountKeywordRecordValues (
62- amountMathKeywordRecord ,
63- validatedKeywords ,
64- allegedAmountKeywordRecord ,
55+ export const cleanKeywords = keywordRecord => {
56+ // `getOwnPropertyNames` returns all the non-symbol properties
57+ // (both enumerable and non-enumerable).
58+ const keywords = Object . getOwnPropertyNames ( keywordRecord ) ;
59+
60+ // Insist that there are no symbol properties.
61+ assert (
62+ Object . getOwnPropertySymbols ( keywordRecord ) . length === 0 ,
63+ details `no symbol properties allowed` ,
6564 ) ;
65+
66+ // Assert all key characters are ascii and keys start with a
67+ // capital letter.
68+ keywords . forEach ( assertCapASCII ) ;
69+
70+ return keywords ;
6671} ;
6772
68- export const cleanProposal = ( keywords , amountMathKeywordRecord , proposal ) => {
69- const expectedRootKeys = [ 'want' , 'give' , 'exit' ] ;
73+ // cleanProposal checks the keys and values of the proposal, including
74+ // the keys and values of the internal objects. The proposal may have
75+ // the following keys: `give`, `want`, and `exit`. These keys may be
76+ // omitted in the `proposal` argument passed to cleanProposal, but
77+ // anything other than these keys is not allowed. The values of `give`
78+ // and `want` must be "amountKeywordRecords", meaning that the keys
79+ // must be keywords and the values must be amounts. The value of
80+ // `exit`, if present, must be a record of one of the following forms:
81+ // `{ waived: null }` `{ onDemand: null }` `{ afterDeadline: { timer
82+ // :Timer, deadline :Number } }
83+ export const cleanProposal = (
84+ issuerKeywordRecord ,
85+ amountMathKeywordRecord ,
86+ proposal ,
87+ ) => {
88+ const rootKeysAllowed = [ 'want' , 'give' , 'exit' ] ;
7089 mustBeComparable ( proposal ) ;
71- checkKeys ( expectedRootKeys , proposal ) ;
90+ assertKeysAllowed ( rootKeysAllowed , proposal ) ;
7291
7392 // We fill in the default values if the keys are undefined.
7493 let { want = harden ( { } ) , give = harden ( { } ) } = proposal ;
7594 const { exit = harden ( { onDemand : null } ) } = proposal ;
7695
77- want = coerceAmountKeywordRecord ( amountMathKeywordRecord , keywords , want ) ;
78- give = coerceAmountKeywordRecord ( amountMathKeywordRecord , keywords , give ) ;
96+ const allKeywords = getKeywords ( issuerKeywordRecord ) ;
97+ want = coerceAmountKeywordRecord ( amountMathKeywordRecord , allKeywords , want ) ;
98+ give = coerceAmountKeywordRecord ( amountMathKeywordRecord , allKeywords , give ) ;
7999
80100 // Check exit
81101 assert (
82102 Object . getOwnPropertyNames ( exit ) . length === 1 ,
83103 details `exit ${ proposal . exit } ,
84104 ) ;
85105 // We expect the single exit key to be one of the following:
86- const expectedExitKeys = [ 'onDemand' , 'afterDeadline' , 'waived' ] ;
87- const [ exitKey ] = checkKeys ( expectedExitKeys , exit ) ;
106+ const allowedExitKeys = [ 'onDemand' , 'afterDeadline' , 'waived' ] ;
107+ const [ exitKey ] = cleanKeys ( allowedExitKeys , exit ) ;
88108 if ( exitKey === 'onDemand' || exitKey === 'waived' ) {
89109 assert (
90110 exit [ exitKey ] === null ,
@@ -93,37 +113,32 @@ export const cleanProposal = (keywords, amountMathKeywordRecord, proposal) => {
93113 }
94114 if ( exitKey === 'afterDeadline' ) {
95115 const expectedAfterDeadlineKeys = [ 'timer' , 'deadline' ] ;
96- checkKeys ( expectedAfterDeadlineKeys , exit . afterDeadline ) ;
116+ assertKeysAllowed ( expectedAfterDeadlineKeys , exit . afterDeadline ) ;
117+ assert (
118+ exit . afterDeadline . timer !== undefined ,
119+ details `timer must be defined` ,
120+ ) ;
121+ assert (
122+ exit . afterDeadline . deadline !== undefined ,
123+ details `deadline must be defined` ,
124+ ) ;
97125 // timers must have a 'setWakeup' function which takes a deadline
98126 // and an object as arguments.
99127 // TODO: document timer interface
100128 // https://github.com/Agoric/agoric-sdk/issues/751
101129 // TODO: how to check methods on presences?
102130 }
103131
104- const hasPropDefined = ( obj , prop ) => obj [ prop ] !== undefined ;
132+ // check that keyword is not in both 'want' and 'give'.
133+ const wantKeywordSet = new Set ( Object . getOwnPropertyNames ( want ) ) ;
134+ const giveKeywords = Object . getOwnPropertyNames ( give ) ;
105135
106- // Create an unfrozen version of 'want' in case we need to add
107- // properties.
108- const wantObj = { ...want } ;
109-
110- keywords . forEach ( keyword => {
111- // check that keyword is not in both 'want' and 'give'.
112- const wantHas = hasPropDefined ( wantObj , keyword ) ;
113- const giveHas = hasPropDefined ( give , keyword ) ;
136+ giveKeywords . forEach ( keyword => {
114137 assert (
115- ! ( wantHas && giveHas ) ,
138+ ! wantKeywordSet . has ( keyword ) ,
116139 details `a keyword cannot be in both 'want' and 'give'` ,
117140 ) ;
118- // If keyword is in neither, fill in with a 'want' of empty.
119- if ( ! ( wantHas || giveHas ) ) {
120- wantObj [ keyword ] = amountMathKeywordRecord [ keyword ] . getEmpty ( ) ;
121- }
122141 } ) ;
123142
124- return harden ( {
125- want : wantObj ,
126- give,
127- exit,
128- } ) ;
143+ return harden ( { want, give, exit } ) ;
129144} ;
0 commit comments