cariboujs 2.0.6 → 2.0.7

package/miniscript/MiniscriptParser.js

@@ -0,0 +1,2620 @@
+// Generated from Miniscript.g4 by ANTLR 4.13.2
+// jshint ignore: start
+import antlr4 from 'antlr4';
+import MiniscriptListener from './MiniscriptListener.js';
+import MiniscriptVisitor from './MiniscriptVisitor.js';
+
+const serializedATN = [4,1,35,312,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,
+4,2,5,7,5,2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,
+2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,1,0,1,0,1,0,
+1,1,1,1,3,1,44,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,54,8,2,1,3,1,3,1,
+4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+4,1,4,3,4,78,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,90,8,5,1,6,
+1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,
+1,6,3,6,112,8,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,
+3,7,128,8,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,
+1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,
+1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,179,
+8,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,1,
+10,5,10,197,8,10,10,10,12,10,200,9,10,1,10,1,10,1,11,1,11,1,11,1,12,1,12,
+1,13,1,13,1,14,1,14,1,14,5,14,214,8,14,10,14,12,14,217,9,14,1,15,1,15,1,
+15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,
+1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,
+15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,258,8,15,3,15,260,8,15,3,15,262,
+8,15,3,15,264,8,15,3,15,266,8,15,3,15,268,8,15,3,15,270,8,15,3,15,272,8,
+15,3,15,274,8,15,3,15,276,8,15,3,15,278,8,15,3,15,280,8,15,3,15,282,8,15,
+3,15,284,8,15,3,15,286,8,15,3,15,288,8,15,3,15,290,8,15,3,15,292,8,15,3,
+15,294,8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,306,8,
+16,1,17,1,17,1,18,1,18,1,18,0,0,19,0,2,4,6,8,10,12,14,16,18,20,22,24,26,
+28,30,32,34,36,0,5,1,0,31,32,2,0,27,27,29,29,2,0,28,28,30,30,1,0,1,21,2,
+0,27,28,32,33,344,0,38,1,0,0,0,2,43,1,0,0,0,4,53,1,0,0,0,6,55,1,0,0,0,8,
+77,1,0,0,0,10,89,1,0,0,0,12,111,1,0,0,0,14,127,1,0,0,0,16,178,1,0,0,0,18,
+180,1,0,0,0,20,189,1,0,0,0,22,203,1,0,0,0,24,206,1,0,0,0,26,208,1,0,0,0,
+28,210,1,0,0,0,30,218,1,0,0,0,32,305,1,0,0,0,34,307,1,0,0,0,36,309,1,0,0,
+0,38,39,3,2,1,0,39,40,5,0,0,1,40,1,1,0,0,0,41,44,3,22,11,0,42,44,3,4,2,0,
+43,41,1,0,0,0,43,42,1,0,0,0,44,3,1,0,0,0,45,54,3,6,3,0,46,54,3,8,4,0,47,
+54,3,10,5,0,48,54,3,12,6,0,49,54,3,14,7,0,50,54,3,16,8,0,51,54,3,18,9,0,
+52,54,3,20,10,0,53,45,1,0,0,0,53,46,1,0,0,0,53,47,1,0,0,0,53,48,1,0,0,0,
+53,49,1,0,0,0,53,50,1,0,0,0,53,51,1,0,0,0,53,52,1,0,0,0,54,5,1,0,0,0,55,
+56,7,0,0,0,56,7,1,0,0,0,57,58,5,1,0,0,58,59,5,22,0,0,59,60,3,32,16,0,60,
+61,5,23,0,0,61,78,1,0,0,0,62,63,5,2,0,0,63,64,5,22,0,0,64,65,3,32,16,0,65,
+66,5,23,0,0,66,78,1,0,0,0,67,68,5,3,0,0,68,69,5,22,0,0,69,70,3,32,16,0,70,
+71,5,23,0,0,71,78,1,0,0,0,72,73,5,4,0,0,73,74,5,22,0,0,74,75,3,32,16,0,75,
+76,5,23,0,0,76,78,1,0,0,0,77,57,1,0,0,0,77,62,1,0,0,0,77,67,1,0,0,0,77,72,
+1,0,0,0,78,9,1,0,0,0,79,80,5,5,0,0,80,81,5,22,0,0,81,82,3,36,18,0,82,83,
+5,23,0,0,83,90,1,0,0,0,84,85,5,6,0,0,85,86,5,22,0,0,86,87,3,36,18,0,87,88,
+5,23,0,0,88,90,1,0,0,0,89,79,1,0,0,0,89,84,1,0,0,0,90,11,1,0,0,0,91,92,5,
+7,0,0,92,93,5,22,0,0,93,94,3,24,12,0,94,95,5,23,0,0,95,112,1,0,0,0,96,97,
+5,8,0,0,97,98,5,22,0,0,98,99,3,24,12,0,99,100,5,23,0,0,100,112,1,0,0,0,101,
+102,5,9,0,0,102,103,5,22,0,0,103,104,3,26,13,0,104,105,5,23,0,0,105,112,
+1,0,0,0,106,107,5,10,0,0,107,108,5,22,0,0,108,109,3,26,13,0,109,110,5,23,
+0,0,110,112,1,0,0,0,111,91,1,0,0,0,111,96,1,0,0,0,111,101,1,0,0,0,111,106,
+1,0,0,0,112,13,1,0,0,0,113,114,5,11,0,0,114,115,5,22,0,0,115,116,3,36,18,
+0,116,117,5,24,0,0,117,118,3,30,15,0,118,119,5,23,0,0,119,128,1,0,0,0,120,
+121,5,12,0,0,121,122,5,22,0,0,122,123,3,36,18,0,123,124,5,24,0,0,124,125,
+3,28,14,0,125,126,5,23,0,0,126,128,1,0,0,0,127,113,1,0,0,0,127,120,1,0,0,
+0,128,15,1,0,0,0,129,130,5,13,0,0,130,131,5,22,0,0,131,132,3,2,1,0,132,133,
+5,24,0,0,133,134,3,2,1,0,134,135,5,23,0,0,135,179,1,0,0,0,136,137,5,14,0,
+0,137,138,5,22,0,0,138,139,3,2,1,0,139,140,5,24,0,0,140,141,3,2,1,0,141,
+142,5,23,0,0,142,179,1,0,0,0,143,144,5,15,0,0,144,145,5,22,0,0,145,146,3,
+2,1,0,146,147,5,24,0,0,147,148,3,2,1,0,148,149,5,23,0,0,149,179,1,0,0,0,
+150,151,5,16,0,0,151,152,5,22,0,0,152,153,3,2,1,0,153,154,5,24,0,0,154,155,
+3,2,1,0,155,156,5,23,0,0,156,179,1,0,0,0,157,158,5,17,0,0,158,159,5,22,0,
+0,159,160,3,2,1,0,160,161,5,24,0,0,161,162,3,2,1,0,162,163,5,23,0,0,163,
+179,1,0,0,0,164,165,5,18,0,0,165,166,5,22,0,0,166,167,3,2,1,0,167,168,5,
+24,0,0,168,169,3,2,1,0,169,170,5,23,0,0,170,179,1,0,0,0,171,172,5,19,0,0,
+172,173,5,22,0,0,173,174,3,2,1,0,174,175,5,24,0,0,175,176,3,2,1,0,176,177,
+5,23,0,0,177,179,1,0,0,0,178,129,1,0,0,0,178,136,1,0,0,0,178,143,1,0,0,0,
+178,150,1,0,0,0,178,157,1,0,0,0,178,164,1,0,0,0,178,171,1,0,0,0,179,17,1,
+0,0,0,180,181,5,20,0,0,181,182,5,22,0,0,182,183,3,2,1,0,183,184,5,24,0,0,
+184,185,3,2,1,0,185,186,5,24,0,0,186,187,3,2,1,0,187,188,5,23,0,0,188,19,
+1,0,0,0,189,190,5,21,0,0,190,191,5,22,0,0,191,192,3,36,18,0,192,193,5,24,
+0,0,193,198,3,2,1,0,194,195,5,24,0,0,195,197,3,2,1,0,196,194,1,0,0,0,197,
+200,1,0,0,0,198,196,1,0,0,0,198,199,1,0,0,0,199,201,1,0,0,0,200,198,1,0,
+0,0,201,202,5,23,0,0,202,21,1,0,0,0,203,204,5,25,0,0,204,205,3,4,2,0,205,
+23,1,0,0,0,206,207,7,1,0,0,207,25,1,0,0,0,208,209,7,2,0,0,209,27,1,0,0,0,
+210,215,3,32,16,0,211,212,5,24,0,0,212,214,3,32,16,0,213,211,1,0,0,0,214,
+217,1,0,0,0,215,213,1,0,0,0,215,216,1,0,0,0,216,29,1,0,0,0,217,215,1,0,0,
+0,218,293,3,32,16,0,219,220,5,24,0,0,220,291,3,32,16,0,221,222,5,24,0,0,
+222,289,3,32,16,0,223,224,5,24,0,0,224,287,3,32,16,0,225,226,5,24,0,0,226,
+285,3,32,16,0,227,228,5,24,0,0,228,283,3,32,16,0,229,230,5,24,0,0,230,281,
+3,32,16,0,231,232,5,24,0,0,232,279,3,32,16,0,233,234,5,24,0,0,234,277,3,
+32,16,0,235,236,5,24,0,0,236,275,3,32,16,0,237,238,5,24,0,0,238,273,3,32,
+16,0,239,240,5,24,0,0,240,271,3,32,16,0,241,242,5,24,0,0,242,269,3,32,16,
+0,243,244,5,24,0,0,244,267,3,32,16,0,245,246,5,24,0,0,246,265,3,32,16,0,
+247,248,5,24,0,0,248,263,3,32,16,0,249,250,5,24,0,0,250,261,3,32,16,0,251,
+252,5,24,0,0,252,259,3,32,16,0,253,254,5,24,0,0,254,257,3,32,16,0,255,256,
+5,24,0,0,256,258,3,32,16,0,257,255,1,0,0,0,257,258,1,0,0,0,258,260,1,0,0,
+0,259,253,1,0,0,0,259,260,1,0,0,0,260,262,1,0,0,0,261,251,1,0,0,0,261,262,
+1,0,0,0,262,264,1,0,0,0,263,249,1,0,0,0,263,264,1,0,0,0,264,266,1,0,0,0,
+265,247,1,0,0,0,265,266,1,0,0,0,266,268,1,0,0,0,267,245,1,0,0,0,267,268,
+1,0,0,0,268,270,1,0,0,0,269,243,1,0,0,0,269,270,1,0,0,0,270,272,1,0,0,0,
+271,241,1,0,0,0,271,272,1,0,0,0,272,274,1,0,0,0,273,239,1,0,0,0,273,274,
+1,0,0,0,274,276,1,0,0,0,275,237,1,0,0,0,275,276,1,0,0,0,276,278,1,0,0,0,
+277,235,1,0,0,0,277,278,1,0,0,0,278,280,1,0,0,0,279,233,1,0,0,0,279,280,
+1,0,0,0,280,282,1,0,0,0,281,231,1,0,0,0,281,282,1,0,0,0,282,284,1,0,0,0,
+283,229,1,0,0,0,283,284,1,0,0,0,284,286,1,0,0,0,285,227,1,0,0,0,285,286,
+1,0,0,0,286,288,1,0,0,0,287,225,1,0,0,0,287,288,1,0,0,0,288,290,1,0,0,0,
+289,223,1,0,0,0,289,290,1,0,0,0,290,292,1,0,0,0,291,221,1,0,0,0,291,292,
+1,0,0,0,292,294,1,0,0,0,293,219,1,0,0,0,293,294,1,0,0,0,294,31,1,0,0,0,295,
+306,5,26,0,0,296,306,5,29,0,0,297,306,5,30,0,0,298,306,5,27,0,0,299,306,
+5,28,0,0,300,306,5,34,0,0,301,306,5,31,0,0,302,306,5,32,0,0,303,306,5,33,
+0,0,304,306,3,34,17,0,305,295,1,0,0,0,305,296,1,0,0,0,305,297,1,0,0,0,305,
+298,1,0,0,0,305,299,1,0,0,0,305,300,1,0,0,0,305,301,1,0,0,0,305,302,1,0,
+0,0,305,303,1,0,0,0,305,304,1,0,0,0,306,33,1,0,0,0,307,308,7,3,0,0,308,35,
+1,0,0,0,309,310,7,4,0,0,310,37,1,0,0,0,29,43,53,77,89,111,127,178,198,215,
+257,259,261,263,265,267,269,271,273,275,277,279,281,283,285,287,289,291,
+293,305];
+
+
+const atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+const decisionsToDFA = atn.decisionToState.map( (ds, index) => new antlr4.dfa.DFA(ds, index) );
+
+const sharedContextCache = new antlr4.atn.PredictionContextCache();
+
+export default class MiniscriptParser extends antlr4.Parser {
+
+    static grammarFileName = "Miniscript.g4";
+    static literalNames = [ null, "'pk'", "'pkh'", "'pk_k'", "'pk_h'", "'older'", 
+                            "'after'", "'sha256'", "'hash256'", "'hash160'", 
+                            "'ripemd160'", "'multi'", "'multi_a'", "'and_v'", 
+                            "'and_b'", "'and_n'", "'or_b'", "'or_c'", "'or_d'", 
+                            "'or_i'", "'andor'", "'thresh'", "'('", "')'", 
+                            "','", null, null, null, null, null, null, "'0'", 
+                            "'1'" ];
+    static symbolicNames = [ null, "PK", "PKH", "PK_K", "PK_H", "OLDER", 
+                             "AFTER", "SHA256", "HASH256", "HASH160", "RIPEMD160", 
+                             "MULTI", "MULTI_A", "AND_V", "AND_B", "AND_N", 
+                             "OR_B", "OR_C", "OR_D", "OR_I", "ANDOR", "THRESH", 
+                             "LPAREN", "RPAREN", "COMMA", "WRAPPER_SEQUENCE", 
+                             "COMPRESSED_PUBLIC_KEY", "DIGITS_64", "DIGITS_40", 
+                             "HEX32_BYTES", "HEX20_BYTES", "ZERO", "ONE", 
+                             "POSITIVE_INTEGER", "KEY", "WS" ];
+    static ruleNames = [ "miniscript", "expression", "baseExpression", "constant", 
+                         "keyExpression", "timeExpression", "hashExpression", 
+                         "multisigExpression", "binaryExpression", "ternaryExpression", 
+                         "thresholdExpression", "wrappedExpression", "hash32", 
+                         "hash20", "keyList", "keyList1To20", "key", "reservedKeyWord", 
+                         "positiveInteger" ];
+
+    constructor(input) {
+        super(input);
+        this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
+        this.ruleNames = MiniscriptParser.ruleNames;
+        this.literalNames = MiniscriptParser.literalNames;
+        this.symbolicNames = MiniscriptParser.symbolicNames;
+    }
+
+
+
+	miniscript() {
+	    let localctx = new MiniscriptContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 0, MiniscriptParser.RULE_miniscript);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 38;
+	        this.expression();
+	        this.state = 39;
+	        this.match(MiniscriptParser.EOF);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	expression() {
+	    let localctx = new ExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 2, MiniscriptParser.RULE_expression);
+	    try {
+	        this.state = 43;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 25:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 41;
+	            this.wrappedExpression();
+	            break;
+	        case 1:
+	        case 2:
+	        case 3:
+	        case 4:
+	        case 5:
+	        case 6:
+	        case 7:
+	        case 8:
+	        case 9:
+	        case 10:
+	        case 11:
+	        case 12:
+	        case 13:
+	        case 14:
+	        case 15:
+	        case 16:
+	        case 17:
+	        case 18:
+	        case 19:
+	        case 20:
+	        case 21:
+	        case 31:
+	        case 32:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 42;
+	            this.baseExpression();
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	baseExpression() {
+	    let localctx = new BaseExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 4, MiniscriptParser.RULE_baseExpression);
+	    try {
+	        this.state = 53;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 31:
+	        case 32:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 45;
+	            this.constant();
+	            break;
+	        case 1:
+	        case 2:
+	        case 3:
+	        case 4:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 46;
+	            this.keyExpression();
+	            break;
+	        case 5:
+	        case 6:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 47;
+	            this.timeExpression();
+	            break;
+	        case 7:
+	        case 8:
+	        case 9:
+	        case 10:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 48;
+	            this.hashExpression();
+	            break;
+	        case 11:
+	        case 12:
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 49;
+	            this.multisigExpression();
+	            break;
+	        case 13:
+	        case 14:
+	        case 15:
+	        case 16:
+	        case 17:
+	        case 18:
+	        case 19:
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 50;
+	            this.binaryExpression();
+	            break;
+	        case 20:
+	            this.enterOuterAlt(localctx, 7);
+	            this.state = 51;
+	            this.ternaryExpression();
+	            break;
+	        case 21:
+	            this.enterOuterAlt(localctx, 8);
+	            this.state = 52;
+	            this.thresholdExpression();
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	constant() {
+	    let localctx = new ConstantContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 6, MiniscriptParser.RULE_constant);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 55;
+	        _la = this._input.LA(1);
+	        if(!(_la===31 || _la===32)) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	keyExpression() {
+	    let localctx = new KeyExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 8, MiniscriptParser.RULE_keyExpression);
+	    try {
+	        this.state = 77;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 57;
+	            this.match(MiniscriptParser.PK);
+	            this.state = 58;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 59;
+	            this.key();
+	            this.state = 60;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 62;
+	            this.match(MiniscriptParser.PKH);
+	            this.state = 63;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 64;
+	            this.key();
+	            this.state = 65;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 3:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 67;
+	            this.match(MiniscriptParser.PK_K);
+	            this.state = 68;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 69;
+	            this.key();
+	            this.state = 70;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 4:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 72;
+	            this.match(MiniscriptParser.PK_H);
+	            this.state = 73;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 74;
+	            this.key();
+	            this.state = 75;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	timeExpression() {
+	    let localctx = new TimeExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 10, MiniscriptParser.RULE_timeExpression);
+	    try {
+	        this.state = 89;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 5:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 79;
+	            this.match(MiniscriptParser.OLDER);
+	            this.state = 80;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 81;
+	            this.positiveInteger();
+	            this.state = 82;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 6:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 84;
+	            this.match(MiniscriptParser.AFTER);
+	            this.state = 85;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 86;
+	            this.positiveInteger();
+	            this.state = 87;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	hashExpression() {
+	    let localctx = new HashExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 12, MiniscriptParser.RULE_hashExpression);
+	    try {
+	        this.state = 111;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 7:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 91;
+	            this.match(MiniscriptParser.SHA256);
+	            this.state = 92;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 93;
+	            this.hash32();
+	            this.state = 94;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 8:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 96;
+	            this.match(MiniscriptParser.HASH256);
+	            this.state = 97;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 98;
+	            this.hash32();
+	            this.state = 99;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 9:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 101;
+	            this.match(MiniscriptParser.HASH160);
+	            this.state = 102;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 103;
+	            this.hash20();
+	            this.state = 104;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 10:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 106;
+	            this.match(MiniscriptParser.RIPEMD160);
+	            this.state = 107;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 108;
+	            this.hash20();
+	            this.state = 109;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	multisigExpression() {
+	    let localctx = new MultisigExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 14, MiniscriptParser.RULE_multisigExpression);
+	    try {
+	        this.state = 127;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 11:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 113;
+	            this.match(MiniscriptParser.MULTI);
+	            this.state = 114;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 115;
+	            this.positiveInteger();
+	            this.state = 116;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 117;
+	            this.keyList1To20();
+	            this.state = 118;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 12:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 120;
+	            this.match(MiniscriptParser.MULTI_A);
+	            this.state = 121;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 122;
+	            this.positiveInteger();
+	            this.state = 123;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 124;
+	            this.keyList();
+	            this.state = 125;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	binaryExpression() {
+	    let localctx = new BinaryExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 16, MiniscriptParser.RULE_binaryExpression);
+	    try {
+	        this.state = 178;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 13:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 129;
+	            this.match(MiniscriptParser.AND_V);
+	            this.state = 130;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 131;
+	            this.expression();
+	            this.state = 132;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 133;
+	            this.expression();
+	            this.state = 134;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 14:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 136;
+	            this.match(MiniscriptParser.AND_B);
+	            this.state = 137;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 138;
+	            this.expression();
+	            this.state = 139;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 140;
+	            this.expression();
+	            this.state = 141;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 15:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 143;
+	            this.match(MiniscriptParser.AND_N);
+	            this.state = 144;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 145;
+	            this.expression();
+	            this.state = 146;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 147;
+	            this.expression();
+	            this.state = 148;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 16:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 150;
+	            this.match(MiniscriptParser.OR_B);
+	            this.state = 151;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 152;
+	            this.expression();
+	            this.state = 153;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 154;
+	            this.expression();
+	            this.state = 155;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 17:
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 157;
+	            this.match(MiniscriptParser.OR_C);
+	            this.state = 158;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 159;
+	            this.expression();
+	            this.state = 160;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 161;
+	            this.expression();
+	            this.state = 162;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 18:
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 164;
+	            this.match(MiniscriptParser.OR_D);
+	            this.state = 165;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 166;
+	            this.expression();
+	            this.state = 167;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 168;
+	            this.expression();
+	            this.state = 169;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        case 19:
+	            this.enterOuterAlt(localctx, 7);
+	            this.state = 171;
+	            this.match(MiniscriptParser.OR_I);
+	            this.state = 172;
+	            this.match(MiniscriptParser.LPAREN);
+	            this.state = 173;
+	            this.expression();
+	            this.state = 174;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 175;
+	            this.expression();
+	            this.state = 176;
+	            this.match(MiniscriptParser.RPAREN);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	ternaryExpression() {
+	    let localctx = new TernaryExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 18, MiniscriptParser.RULE_ternaryExpression);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 180;
+	        this.match(MiniscriptParser.ANDOR);
+	        this.state = 181;
+	        this.match(MiniscriptParser.LPAREN);
+	        this.state = 182;
+	        this.expression();
+	        this.state = 183;
+	        this.match(MiniscriptParser.COMMA);
+	        this.state = 184;
+	        this.expression();
+	        this.state = 185;
+	        this.match(MiniscriptParser.COMMA);
+	        this.state = 186;
+	        this.expression();
+	        this.state = 187;
+	        this.match(MiniscriptParser.RPAREN);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	thresholdExpression() {
+	    let localctx = new ThresholdExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 20, MiniscriptParser.RULE_thresholdExpression);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 189;
+	        this.match(MiniscriptParser.THRESH);
+	        this.state = 190;
+	        this.match(MiniscriptParser.LPAREN);
+	        this.state = 191;
+	        this.positiveInteger();
+	        this.state = 192;
+	        this.match(MiniscriptParser.COMMA);
+	        this.state = 193;
+	        this.expression();
+	        this.state = 198;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===24) {
+	            this.state = 194;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 195;
+	            this.expression();
+	            this.state = 200;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 201;
+	        this.match(MiniscriptParser.RPAREN);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	wrappedExpression() {
+	    let localctx = new WrappedExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 22, MiniscriptParser.RULE_wrappedExpression);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 203;
+	        this.match(MiniscriptParser.WRAPPER_SEQUENCE);
+	        this.state = 204;
+	        this.baseExpression();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	hash32() {
+	    let localctx = new Hash32Context(this, this._ctx, this.state);
+	    this.enterRule(localctx, 24, MiniscriptParser.RULE_hash32);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 206;
+	        _la = this._input.LA(1);
+	        if(!(_la===27 || _la===29)) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	hash20() {
+	    let localctx = new Hash20Context(this, this._ctx, this.state);
+	    this.enterRule(localctx, 26, MiniscriptParser.RULE_hash20);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 208;
+	        _la = this._input.LA(1);
+	        if(!(_la===28 || _la===30)) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	keyList() {
+	    let localctx = new KeyListContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 28, MiniscriptParser.RULE_keyList);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 210;
+	        this.key();
+	        this.state = 215;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===24) {
+	            this.state = 211;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 212;
+	            this.key();
+	            this.state = 217;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	keyList1To20() {
+	    let localctx = new KeyList1To20Context(this, this._ctx, this.state);
+	    this.enterRule(localctx, 30, MiniscriptParser.RULE_keyList1To20);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 218;
+	        this.key();
+	        this.state = 293;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===24) {
+	            this.state = 219;
+	            this.match(MiniscriptParser.COMMA);
+	            this.state = 220;
+	            this.key();
+	            this.state = 291;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if(_la===24) {
+	                this.state = 221;
+	                this.match(MiniscriptParser.COMMA);
+	                this.state = 222;
+	                this.key();
+	                this.state = 289;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	                if(_la===24) {
+	                    this.state = 223;
+	                    this.match(MiniscriptParser.COMMA);
+	                    this.state = 224;
+	                    this.key();
+	                    this.state = 287;
+	                    this._errHandler.sync(this);
+	                    _la = this._input.LA(1);
+	                    if(_la===24) {
+	                        this.state = 225;
+	                        this.match(MiniscriptParser.COMMA);
+	                        this.state = 226;
+	                        this.key();
+	                        this.state = 285;
+	                        this._errHandler.sync(this);
+	                        _la = this._input.LA(1);
+	                        if(_la===24) {
+	                            this.state = 227;
+	                            this.match(MiniscriptParser.COMMA);
+	                            this.state = 228;
+	                            this.key();
+	                            this.state = 283;
+	                            this._errHandler.sync(this);
+	                            _la = this._input.LA(1);
+	                            if(_la===24) {
+	                                this.state = 229;
+	                                this.match(MiniscriptParser.COMMA);
+	                                this.state = 230;
+	                                this.key();
+	                                this.state = 281;
+	                                this._errHandler.sync(this);
+	                                _la = this._input.LA(1);
+	                                if(_la===24) {
+	                                    this.state = 231;
+	                                    this.match(MiniscriptParser.COMMA);
+	                                    this.state = 232;
+	                                    this.key();
+	                                    this.state = 279;
+	                                    this._errHandler.sync(this);
+	                                    _la = this._input.LA(1);
+	                                    if(_la===24) {
+	                                        this.state = 233;
+	                                        this.match(MiniscriptParser.COMMA);
+	                                        this.state = 234;
+	                                        this.key();
+	                                        this.state = 277;
+	                                        this._errHandler.sync(this);
+	                                        _la = this._input.LA(1);
+	                                        if(_la===24) {
+	                                            this.state = 235;
+	                                            this.match(MiniscriptParser.COMMA);
+	                                            this.state = 236;
+	                                            this.key();
+	                                            this.state = 275;
+	                                            this._errHandler.sync(this);
+	                                            _la = this._input.LA(1);
+	                                            if(_la===24) {
+	                                                this.state = 237;
+	                                                this.match(MiniscriptParser.COMMA);
+	                                                this.state = 238;
+	                                                this.key();
+	                                                this.state = 273;
+	                                                this._errHandler.sync(this);
+	                                                _la = this._input.LA(1);
+	                                                if(_la===24) {
+	                                                    this.state = 239;
+	                                                    this.match(MiniscriptParser.COMMA);
+	                                                    this.state = 240;
+	                                                    this.key();
+	                                                    this.state = 271;
+	                                                    this._errHandler.sync(this);
+	                                                    _la = this._input.LA(1);
+	                                                    if(_la===24) {
+	                                                        this.state = 241;
+	                                                        this.match(MiniscriptParser.COMMA);
+	                                                        this.state = 242;
+	                                                        this.key();
+	                                                        this.state = 269;
+	                                                        this._errHandler.sync(this);
+	                                                        _la = this._input.LA(1);
+	                                                        if(_la===24) {
+	                                                            this.state = 243;
+	                                                            this.match(MiniscriptParser.COMMA);
+	                                                            this.state = 244;
+	                                                            this.key();
+	                                                            this.state = 267;
+	                                                            this._errHandler.sync(this);
+	                                                            _la = this._input.LA(1);
+	                                                            if(_la===24) {
+	                                                                this.state = 245;
+	                                                                this.match(MiniscriptParser.COMMA);
+	                                                                this.state = 246;
+	                                                                this.key();
+	                                                                this.state = 265;
+	                                                                this._errHandler.sync(this);
+	                                                                _la = this._input.LA(1);
+	                                                                if(_la===24) {
+	                                                                    this.state = 247;
+	                                                                    this.match(MiniscriptParser.COMMA);
+	                                                                    this.state = 248;
+	                                                                    this.key();
+	                                                                    this.state = 263;
+	                                                                    this._errHandler.sync(this);
+	                                                                    _la = this._input.LA(1);
+	                                                                    if(_la===24) {
+	                                                                        this.state = 249;
+	                                                                        this.match(MiniscriptParser.COMMA);
+	                                                                        this.state = 250;
+	                                                                        this.key();
+	                                                                        this.state = 261;
+	                                                                        this._errHandler.sync(this);
+	                                                                        _la = this._input.LA(1);
+	                                                                        if(_la===24) {
+	                                                                            this.state = 251;
+	                                                                            this.match(MiniscriptParser.COMMA);
+	                                                                            this.state = 252;
+	                                                                            this.key();
+	                                                                            this.state = 259;
+	                                                                            this._errHandler.sync(this);
+	                                                                            _la = this._input.LA(1);
+	                                                                            if(_la===24) {
+	                                                                                this.state = 253;
+	                                                                                this.match(MiniscriptParser.COMMA);
+	                                                                                this.state = 254;
+	                                                                                this.key();
+	                                                                                this.state = 257;
+	                                                                                this._errHandler.sync(this);
+	                                                                                _la = this._input.LA(1);
+	                                                                                if(_la===24) {
+	                                                                                    this.state = 255;
+	                                                                                    this.match(MiniscriptParser.COMMA);
+	                                                                                    this.state = 256;
+	                                                                                    this.key();
+	                                                                                }
+
+	                                                                            }
+
+	                                                                        }
+
+	                                                                    }
+
+	                                                                }
+
+	                                                            }
+
+	                                                        }
+
+	                                                    }
+
+	                                                }
+
+	                                            }
+
+	                                        }
+
+	                                    }
+
+	                                }
+
+	                            }
+
+	                        }
+
+	                    }
+
+	                }
+
+	            }
+
+	        }
+
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	key() {
+	    let localctx = new KeyContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 32, MiniscriptParser.RULE_key);
+	    try {
+	        this.state = 305;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 26:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 295;
+	            this.match(MiniscriptParser.COMPRESSED_PUBLIC_KEY);
+	            break;
+	        case 29:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 296;
+	            this.match(MiniscriptParser.HEX32_BYTES);
+	            break;
+	        case 30:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 297;
+	            this.match(MiniscriptParser.HEX20_BYTES);
+	            break;
+	        case 27:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 298;
+	            this.match(MiniscriptParser.DIGITS_64);
+	            break;
+	        case 28:
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 299;
+	            this.match(MiniscriptParser.DIGITS_40);
+	            break;
+	        case 34:
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 300;
+	            this.match(MiniscriptParser.KEY);
+	            break;
+	        case 31:
+	            this.enterOuterAlt(localctx, 7);
+	            this.state = 301;
+	            this.match(MiniscriptParser.ZERO);
+	            break;
+	        case 32:
+	            this.enterOuterAlt(localctx, 8);
+	            this.state = 302;
+	            this.match(MiniscriptParser.ONE);
+	            break;
+	        case 33:
+	            this.enterOuterAlt(localctx, 9);
+	            this.state = 303;
+	            this.match(MiniscriptParser.POSITIVE_INTEGER);
+	            break;
+	        case 1:
+	        case 2:
+	        case 3:
+	        case 4:
+	        case 5:
+	        case 6:
+	        case 7:
+	        case 8:
+	        case 9:
+	        case 10:
+	        case 11:
+	        case 12:
+	        case 13:
+	        case 14:
+	        case 15:
+	        case 16:
+	        case 17:
+	        case 18:
+	        case 19:
+	        case 20:
+	        case 21:
+	            this.enterOuterAlt(localctx, 10);
+	            this.state = 304;
+	            this.reservedKeyWord();
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	reservedKeyWord() {
+	    let localctx = new ReservedKeyWordContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 34, MiniscriptParser.RULE_reservedKeyWord);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 307;
+	        _la = this._input.LA(1);
+	        if(!((((_la) & ~0x1f) === 0 && ((1 << _la) & 4194302) !== 0))) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	positiveInteger() {
+	    let localctx = new PositiveIntegerContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 36, MiniscriptParser.RULE_positiveInteger);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 309;
+	        _la = this._input.LA(1);
+	        if(!(((((_la - 27)) & ~0x1f) === 0 && ((1 << (_la - 27)) & 99) !== 0))) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+}
+
+MiniscriptParser.EOF = antlr4.Token.EOF;
+MiniscriptParser.PK = 1;
+MiniscriptParser.PKH = 2;
+MiniscriptParser.PK_K = 3;
+MiniscriptParser.PK_H = 4;
+MiniscriptParser.OLDER = 5;
+MiniscriptParser.AFTER = 6;
+MiniscriptParser.SHA256 = 7;
+MiniscriptParser.HASH256 = 8;
+MiniscriptParser.HASH160 = 9;
+MiniscriptParser.RIPEMD160 = 10;
+MiniscriptParser.MULTI = 11;
+MiniscriptParser.MULTI_A = 12;
+MiniscriptParser.AND_V = 13;
+MiniscriptParser.AND_B = 14;
+MiniscriptParser.AND_N = 15;
+MiniscriptParser.OR_B = 16;
+MiniscriptParser.OR_C = 17;
+MiniscriptParser.OR_D = 18;
+MiniscriptParser.OR_I = 19;
+MiniscriptParser.ANDOR = 20;
+MiniscriptParser.THRESH = 21;
+MiniscriptParser.LPAREN = 22;
+MiniscriptParser.RPAREN = 23;
+MiniscriptParser.COMMA = 24;
+MiniscriptParser.WRAPPER_SEQUENCE = 25;
+MiniscriptParser.COMPRESSED_PUBLIC_KEY = 26;
+MiniscriptParser.DIGITS_64 = 27;
+MiniscriptParser.DIGITS_40 = 28;
+MiniscriptParser.HEX32_BYTES = 29;
+MiniscriptParser.HEX20_BYTES = 30;
+MiniscriptParser.ZERO = 31;
+MiniscriptParser.ONE = 32;
+MiniscriptParser.POSITIVE_INTEGER = 33;
+MiniscriptParser.KEY = 34;
+MiniscriptParser.WS = 35;
+
+MiniscriptParser.RULE_miniscript = 0;
+MiniscriptParser.RULE_expression = 1;
+MiniscriptParser.RULE_baseExpression = 2;
+MiniscriptParser.RULE_constant = 3;
+MiniscriptParser.RULE_keyExpression = 4;
+MiniscriptParser.RULE_timeExpression = 5;
+MiniscriptParser.RULE_hashExpression = 6;
+MiniscriptParser.RULE_multisigExpression = 7;
+MiniscriptParser.RULE_binaryExpression = 8;
+MiniscriptParser.RULE_ternaryExpression = 9;
+MiniscriptParser.RULE_thresholdExpression = 10;
+MiniscriptParser.RULE_wrappedExpression = 11;
+MiniscriptParser.RULE_hash32 = 12;
+MiniscriptParser.RULE_hash20 = 13;
+MiniscriptParser.RULE_keyList = 14;
+MiniscriptParser.RULE_keyList1To20 = 15;
+MiniscriptParser.RULE_key = 16;
+MiniscriptParser.RULE_reservedKeyWord = 17;
+MiniscriptParser.RULE_positiveInteger = 18;
+
+class MiniscriptContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_miniscript;
+    }
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	EOF() {
+	    return this.getToken(MiniscriptParser.EOF, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterMiniscript(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitMiniscript(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitMiniscript(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_expression;
+    }
+
+	wrappedExpression() {
+	    return this.getTypedRuleContext(WrappedExpressionContext,0);
+	};
+
+	baseExpression() {
+	    return this.getTypedRuleContext(BaseExpressionContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class BaseExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_baseExpression;
+    }
+
+	constant() {
+	    return this.getTypedRuleContext(ConstantContext,0);
+	};
+
+	keyExpression() {
+	    return this.getTypedRuleContext(KeyExpressionContext,0);
+	};
+
+	timeExpression() {
+	    return this.getTypedRuleContext(TimeExpressionContext,0);
+	};
+
+	hashExpression() {
+	    return this.getTypedRuleContext(HashExpressionContext,0);
+	};
+
+	multisigExpression() {
+	    return this.getTypedRuleContext(MultisigExpressionContext,0);
+	};
+
+	binaryExpression() {
+	    return this.getTypedRuleContext(BinaryExpressionContext,0);
+	};
+
+	ternaryExpression() {
+	    return this.getTypedRuleContext(TernaryExpressionContext,0);
+	};
+
+	thresholdExpression() {
+	    return this.getTypedRuleContext(ThresholdExpressionContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterBaseExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitBaseExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitBaseExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ConstantContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_constant;
+    }
+
+	ZERO() {
+	    return this.getToken(MiniscriptParser.ZERO, 0);
+	};
+
+	ONE() {
+	    return this.getToken(MiniscriptParser.ONE, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterConstant(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitConstant(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitConstant(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class KeyExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_keyExpression;
+    }
+
+	PK() {
+	    return this.getToken(MiniscriptParser.PK, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(MiniscriptParser.LPAREN, 0);
+	};
+
+	key() {
+	    return this.getTypedRuleContext(KeyContext,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(MiniscriptParser.RPAREN, 0);
+	};
+
+	PKH() {
+	    return this.getToken(MiniscriptParser.PKH, 0);
+	};
+
+	PK_K() {
+	    return this.getToken(MiniscriptParser.PK_K, 0);
+	};
+
+	PK_H() {
+	    return this.getToken(MiniscriptParser.PK_H, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterKeyExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitKeyExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitKeyExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class TimeExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_timeExpression;
+    }
+
+	OLDER() {
+	    return this.getToken(MiniscriptParser.OLDER, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(MiniscriptParser.LPAREN, 0);
+	};
+
+	positiveInteger() {
+	    return this.getTypedRuleContext(PositiveIntegerContext,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(MiniscriptParser.RPAREN, 0);
+	};
+
+	AFTER() {
+	    return this.getToken(MiniscriptParser.AFTER, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterTimeExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitTimeExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitTimeExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class HashExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_hashExpression;
+    }
+
+	SHA256() {
+	    return this.getToken(MiniscriptParser.SHA256, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(MiniscriptParser.LPAREN, 0);
+	};
+
+	hash32() {
+	    return this.getTypedRuleContext(Hash32Context,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(MiniscriptParser.RPAREN, 0);
+	};
+
+	HASH256() {
+	    return this.getToken(MiniscriptParser.HASH256, 0);
+	};
+
+	HASH160() {
+	    return this.getToken(MiniscriptParser.HASH160, 0);
+	};
+
+	hash20() {
+	    return this.getTypedRuleContext(Hash20Context,0);
+	};
+
+	RIPEMD160() {
+	    return this.getToken(MiniscriptParser.RIPEMD160, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterHashExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitHashExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitHashExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class MultisigExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_multisigExpression;
+    }
+
+	MULTI() {
+	    return this.getToken(MiniscriptParser.MULTI, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(MiniscriptParser.LPAREN, 0);
+	};
+
+	positiveInteger() {
+	    return this.getTypedRuleContext(PositiveIntegerContext,0);
+	};
+
+	COMMA() {
+	    return this.getToken(MiniscriptParser.COMMA, 0);
+	};
+
+	keyList1To20() {
+	    return this.getTypedRuleContext(KeyList1To20Context,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(MiniscriptParser.RPAREN, 0);
+	};
+
+	MULTI_A() {
+	    return this.getToken(MiniscriptParser.MULTI_A, 0);
+	};
+
+	keyList() {
+	    return this.getTypedRuleContext(KeyListContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterMultisigExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitMultisigExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitMultisigExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class BinaryExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_binaryExpression;
+    }
+
+	AND_V() {
+	    return this.getToken(MiniscriptParser.AND_V, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(MiniscriptParser.LPAREN, 0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	COMMA() {
+	    return this.getToken(MiniscriptParser.COMMA, 0);
+	};
+
+	RPAREN() {
+	    return this.getToken(MiniscriptParser.RPAREN, 0);
+	};
+
+	AND_B() {
+	    return this.getToken(MiniscriptParser.AND_B, 0);
+	};
+
+	AND_N() {
+	    return this.getToken(MiniscriptParser.AND_N, 0);
+	};
+
+	OR_B() {
+	    return this.getToken(MiniscriptParser.OR_B, 0);
+	};
+
+	OR_C() {
+	    return this.getToken(MiniscriptParser.OR_C, 0);
+	};
+
+	OR_D() {
+	    return this.getToken(MiniscriptParser.OR_D, 0);
+	};
+
+	OR_I() {
+	    return this.getToken(MiniscriptParser.OR_I, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterBinaryExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitBinaryExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitBinaryExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class TernaryExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_ternaryExpression;
+    }
+
+	ANDOR() {
+	    return this.getToken(MiniscriptParser.ANDOR, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(MiniscriptParser.LPAREN, 0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MiniscriptParser.COMMA);
+	    } else {
+	        return this.getToken(MiniscriptParser.COMMA, i);
+	    }
+	};
+
+
+	RPAREN() {
+	    return this.getToken(MiniscriptParser.RPAREN, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterTernaryExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitTernaryExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitTernaryExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ThresholdExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_thresholdExpression;
+    }
+
+	THRESH() {
+	    return this.getToken(MiniscriptParser.THRESH, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(MiniscriptParser.LPAREN, 0);
+	};
+
+	positiveInteger() {
+	    return this.getTypedRuleContext(PositiveIntegerContext,0);
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MiniscriptParser.COMMA);
+	    } else {
+	        return this.getToken(MiniscriptParser.COMMA, i);
+	    }
+	};
+
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	RPAREN() {
+	    return this.getToken(MiniscriptParser.RPAREN, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterThresholdExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitThresholdExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitThresholdExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class WrappedExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_wrappedExpression;
+    }
+
+	WRAPPER_SEQUENCE() {
+	    return this.getToken(MiniscriptParser.WRAPPER_SEQUENCE, 0);
+	};
+
+	baseExpression() {
+	    return this.getTypedRuleContext(BaseExpressionContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterWrappedExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitWrappedExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitWrappedExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class Hash32Context extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_hash32;
+    }
+
+	HEX32_BYTES() {
+	    return this.getToken(MiniscriptParser.HEX32_BYTES, 0);
+	};
+
+	DIGITS_64() {
+	    return this.getToken(MiniscriptParser.DIGITS_64, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterHash32(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitHash32(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitHash32(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class Hash20Context extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_hash20;
+    }
+
+	HEX20_BYTES() {
+	    return this.getToken(MiniscriptParser.HEX20_BYTES, 0);
+	};
+
+	DIGITS_40() {
+	    return this.getToken(MiniscriptParser.DIGITS_40, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterHash20(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitHash20(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitHash20(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class KeyListContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_keyList;
+    }
+
+	key = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(KeyContext);
+	    } else {
+	        return this.getTypedRuleContext(KeyContext,i);
+	    }
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MiniscriptParser.COMMA);
+	    } else {
+	        return this.getToken(MiniscriptParser.COMMA, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterKeyList(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitKeyList(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitKeyList(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class KeyList1To20Context extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_keyList1To20;
+    }
+
+	key = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(KeyContext);
+	    } else {
+	        return this.getTypedRuleContext(KeyContext,i);
+	    }
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MiniscriptParser.COMMA);
+	    } else {
+	        return this.getToken(MiniscriptParser.COMMA, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterKeyList1To20(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitKeyList1To20(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitKeyList1To20(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class KeyContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_key;
+    }
+
+	COMPRESSED_PUBLIC_KEY() {
+	    return this.getToken(MiniscriptParser.COMPRESSED_PUBLIC_KEY, 0);
+	};
+
+	HEX32_BYTES() {
+	    return this.getToken(MiniscriptParser.HEX32_BYTES, 0);
+	};
+
+	HEX20_BYTES() {
+	    return this.getToken(MiniscriptParser.HEX20_BYTES, 0);
+	};
+
+	DIGITS_64() {
+	    return this.getToken(MiniscriptParser.DIGITS_64, 0);
+	};
+
+	DIGITS_40() {
+	    return this.getToken(MiniscriptParser.DIGITS_40, 0);
+	};
+
+	KEY() {
+	    return this.getToken(MiniscriptParser.KEY, 0);
+	};
+
+	ZERO() {
+	    return this.getToken(MiniscriptParser.ZERO, 0);
+	};
+
+	ONE() {
+	    return this.getToken(MiniscriptParser.ONE, 0);
+	};
+
+	POSITIVE_INTEGER() {
+	    return this.getToken(MiniscriptParser.POSITIVE_INTEGER, 0);
+	};
+
+	reservedKeyWord() {
+	    return this.getTypedRuleContext(ReservedKeyWordContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterKey(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitKey(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitKey(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ReservedKeyWordContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_reservedKeyWord;
+    }
+
+	PK() {
+	    return this.getToken(MiniscriptParser.PK, 0);
+	};
+
+	PKH() {
+	    return this.getToken(MiniscriptParser.PKH, 0);
+	};
+
+	PK_K() {
+	    return this.getToken(MiniscriptParser.PK_K, 0);
+	};
+
+	PK_H() {
+	    return this.getToken(MiniscriptParser.PK_H, 0);
+	};
+
+	OLDER() {
+	    return this.getToken(MiniscriptParser.OLDER, 0);
+	};
+
+	AFTER() {
+	    return this.getToken(MiniscriptParser.AFTER, 0);
+	};
+
+	SHA256() {
+	    return this.getToken(MiniscriptParser.SHA256, 0);
+	};
+
+	HASH256() {
+	    return this.getToken(MiniscriptParser.HASH256, 0);
+	};
+
+	HASH160() {
+	    return this.getToken(MiniscriptParser.HASH160, 0);
+	};
+
+	RIPEMD160() {
+	    return this.getToken(MiniscriptParser.RIPEMD160, 0);
+	};
+
+	MULTI() {
+	    return this.getToken(MiniscriptParser.MULTI, 0);
+	};
+
+	MULTI_A() {
+	    return this.getToken(MiniscriptParser.MULTI_A, 0);
+	};
+
+	AND_V() {
+	    return this.getToken(MiniscriptParser.AND_V, 0);
+	};
+
+	AND_B() {
+	    return this.getToken(MiniscriptParser.AND_B, 0);
+	};
+
+	AND_N() {
+	    return this.getToken(MiniscriptParser.AND_N, 0);
+	};
+
+	OR_B() {
+	    return this.getToken(MiniscriptParser.OR_B, 0);
+	};
+
+	OR_C() {
+	    return this.getToken(MiniscriptParser.OR_C, 0);
+	};
+
+	OR_D() {
+	    return this.getToken(MiniscriptParser.OR_D, 0);
+	};
+
+	OR_I() {
+	    return this.getToken(MiniscriptParser.OR_I, 0);
+	};
+
+	ANDOR() {
+	    return this.getToken(MiniscriptParser.ANDOR, 0);
+	};
+
+	THRESH() {
+	    return this.getToken(MiniscriptParser.THRESH, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterReservedKeyWord(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitReservedKeyWord(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitReservedKeyWord(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class PositiveIntegerContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MiniscriptParser.RULE_positiveInteger;
+    }
+
+	ONE() {
+	    return this.getToken(MiniscriptParser.ONE, 0);
+	};
+
+	DIGITS_64() {
+	    return this.getToken(MiniscriptParser.DIGITS_64, 0);
+	};
+
+	DIGITS_40() {
+	    return this.getToken(MiniscriptParser.DIGITS_40, 0);
+	};
+
+	POSITIVE_INTEGER() {
+	    return this.getToken(MiniscriptParser.POSITIVE_INTEGER, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.enterPositiveInteger(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MiniscriptListener ) {
+	        listener.exitPositiveInteger(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MiniscriptVisitor ) {
+	        return visitor.visitPositiveInteger(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+
+MiniscriptParser.MiniscriptContext = MiniscriptContext; 
+MiniscriptParser.ExpressionContext = ExpressionContext; 
+MiniscriptParser.BaseExpressionContext = BaseExpressionContext; 
+MiniscriptParser.ConstantContext = ConstantContext; 
+MiniscriptParser.KeyExpressionContext = KeyExpressionContext; 
+MiniscriptParser.TimeExpressionContext = TimeExpressionContext; 
+MiniscriptParser.HashExpressionContext = HashExpressionContext; 
+MiniscriptParser.MultisigExpressionContext = MultisigExpressionContext; 
+MiniscriptParser.BinaryExpressionContext = BinaryExpressionContext; 
+MiniscriptParser.TernaryExpressionContext = TernaryExpressionContext; 
+MiniscriptParser.ThresholdExpressionContext = ThresholdExpressionContext; 
+MiniscriptParser.WrappedExpressionContext = WrappedExpressionContext; 
+MiniscriptParser.Hash32Context = Hash32Context; 
+MiniscriptParser.Hash20Context = Hash20Context; 
+MiniscriptParser.KeyListContext = KeyListContext; 
+MiniscriptParser.KeyList1To20Context = KeyList1To20Context; 
+MiniscriptParser.KeyContext = KeyContext; 
+MiniscriptParser.ReservedKeyWordContext = ReservedKeyWordContext; 
+MiniscriptParser.PositiveIntegerContext = PositiveIntegerContext;