Moved QueryStringArgs into Protocol.Constants.

26 files changed, 337 insertions, 343 deletions

diff --git a/src/DotNetOpenId.Test/EndToEndTesting.cs b/src/DotNetOpenId.Test/EndToEndTesting.cs
index 54e6e37..46390dc 100644
--- a/src/DotNetOpenId.Test/EndToEndTesting.cs
+++ b/src/DotNetOpenId.Test/EndToEndTesting.cs
@@ -37,8 +37,8 @@ namespace DotNetOpenId.Test {
 			// Verify the redirect URL

 			Assert.IsNotNull(request.RedirectToProviderUrl);

 			var consumerToProviderQuery = HttpUtility.ParseQueryString(request.RedirectToProviderUrl.Query);

-			Assert.IsTrue(consumerToProviderQuery[QueryStringArgs.openid.return_to].StartsWith(returnTo.AbsoluteUri, StringComparison.Ordinal));

-			Assert.AreEqual(realm.ToString(), consumerToProviderQuery[QueryStringArgs.openid.trust_root]);

+			Assert.IsTrue(consumerToProviderQuery[Protocol.Constants.openid.return_to].StartsWith(returnTo.AbsoluteUri, StringComparison.Ordinal));

+			Assert.AreEqual(realm.ToString(), consumerToProviderQuery[Protocol.Constants.openid.trust_root]);

 

 			HttpWebRequest providerRequest = (HttpWebRequest)WebRequest.Create(request.RedirectToProviderUrl);

 			providerRequest.AllowAutoRedirect = false;

diff --git a/src/DotNetOpenId.Test/ExtensionsArgumentsManagerTests.cs b/src/DotNetOpenId.Test/ExtensionsArgumentsManagerTests.cs
index ff0cb07..e7c155f 100644
--- a/src/DotNetOpenId.Test/ExtensionsArgumentsManagerTests.cs
+++ b/src/DotNetOpenId.Test/ExtensionsArgumentsManagerTests.cs
@@ -114,15 +114,15 @@ namespace DotNetOpenId.Test {
 				{"openid.sreg.nickname", "andy"},

 			};

 			IIncomingExtensions mgr = ExtensionArgumentsManager.CreateIncomingExtensions(args);

-			Assert.IsTrue(mgr.ContainsExtension(QueryStringArgs.sreg_ns));

-			Assert.AreEqual("andy", mgr.GetExtensionArguments(QueryStringArgs.sreg_ns)["nickname"]);

+			Assert.IsTrue(mgr.ContainsExtension(Protocol.Constants.sreg_ns));

+			Assert.AreEqual("andy", mgr.GetExtensionArguments(Protocol.Constants.sreg_ns)["nickname"]);

 			// Now imagine that sreg was used explicitly by something else...

 			args = new Dictionary<string, string>() {

 				{"openid.sreg.nickname", "andy"},

 				{"openid.ns.sreg", "someOtherNS"},

 			};

 			mgr = ExtensionArgumentsManager.CreateIncomingExtensions(args);

-			Assert.IsFalse(mgr.ContainsExtension(QueryStringArgs.sreg_ns));

+			Assert.IsFalse(mgr.ContainsExtension(Protocol.Constants.sreg_ns));

 			Assert.AreEqual("andy", mgr.GetExtensionArguments("someOtherNS")["nickname"]);

 		}

 

@@ -132,10 +132,10 @@ namespace DotNetOpenId.Test {
 				{"nickname", "andy"},

 			};

 			var mgr = ExtensionArgumentsManager.CreateOutgoingExtensions();

-			mgr.AddExtensionArguments(QueryStringArgs.sreg_ns, args);

+			mgr.AddExtensionArguments(Protocol.Constants.sreg_ns, args);

 			var results = mgr.GetArgumentsToSend(true);

 			Assert.IsTrue(results.ContainsKey("openid.ns.sreg"));

-			Assert.AreEqual(QueryStringArgs.sreg_ns, results["openid.ns.sreg"]);

+			Assert.AreEqual(Protocol.Constants.sreg_ns, results["openid.ns.sreg"]);

 			Assert.IsTrue(results.ContainsKey("openid.sreg.nickname"));

 			Assert.AreEqual("andy", results["openid.sreg.nickname"]);

 		}

@@ -146,10 +146,10 @@ namespace DotNetOpenId.Test {
 				{"nickname", "andy"},

 			};

 			var mgr = ExtensionArgumentsManager.CreateOutgoingExtensions();

-			mgr.AddExtensionArguments(QueryStringArgs.sreg_ns, args);

+			mgr.AddExtensionArguments(Protocol.Constants.sreg_ns, args);

 			var results = mgr.GetArgumentsToSend(false);

 			Assert.IsTrue(results.ContainsKey("ns.sreg"));

-			Assert.AreEqual(QueryStringArgs.sreg_ns, results["ns.sreg"]);

+			Assert.AreEqual(Protocol.Constants.sreg_ns, results["ns.sreg"]);

 			Assert.IsTrue(results.ContainsKey("sreg.nickname"));

 			Assert.AreEqual("andy", results["sreg.nickname"]);

 		}

@@ -185,7 +185,7 @@ namespace DotNetOpenId.Test {
 				{"openid.sreg", "v1"},

 			};

 			var mgr = ExtensionArgumentsManager.CreateIncomingExtensions(args);

-			var result = mgr.GetExtensionArguments(QueryStringArgs.sreg_ns);

+			var result = mgr.GetExtensionArguments(Protocol.Constants.sreg_ns);

 			Assert.AreEqual("v1", result[string.Empty]);

 		}

 

@@ -195,7 +195,7 @@ namespace DotNetOpenId.Test {
 				{"", "v1"},

 			};

 			var mgr = ExtensionArgumentsManager.CreateOutgoingExtensions();

-			mgr.AddExtensionArguments(QueryStringArgs.sreg_ns, args);

+			mgr.AddExtensionArguments(Protocol.Constants.sreg_ns, args);

 			var result = mgr.GetArgumentsToSend(true);

 			Assert.AreEqual(2, result.Count);

 			Assert.AreEqual("v1", result["openid.sreg"]);

diff --git a/src/DotNetOpenId/ExtensionArgumentsManager.cs b/src/DotNetOpenId/ExtensionArgumentsManager.cs
index 3113ae5..07b9bc6 100644
--- a/src/DotNetOpenId/ExtensionArgumentsManager.cs
+++ b/src/DotNetOpenId/ExtensionArgumentsManager.cs
@@ -23,7 +23,7 @@ namespace DotNetOpenId {
 		/// match to namespaces for backward compatibility with other OpenID libraries.

 		/// </summary>

 		static readonly Dictionary<string, string> typeUriToAliasAffinity = new Dictionary<string, string> {

-			{ QueryStringArgs.sreg_ns, QueryStringArgs.sreg_compatibility_alias },

+			{ Protocol.Constants.sreg_ns, Protocol.Constants.sreg_compatibility_alias },

 		};

 

 		private ExtensionArgumentsManager() { }

@@ -32,7 +32,7 @@ namespace DotNetOpenId {
 			var mgr = new ExtensionArgumentsManager();

 			mgr.isReadMode = true;

 			var aliasToTypeUriMap = new Dictionary<string, string>();

-			string aliasPrefix = QueryStringArgs.openid.ns + ".";

+			string aliasPrefix = Protocol.Constants.openid.ns + ".";

 			// First pass looks for namespace aliases

 			foreach (var pair in query) {

 				if (pair.Key.StartsWith(aliasPrefix, StringComparison.Ordinal)) {

@@ -50,15 +50,15 @@ namespace DotNetOpenId {
 			}

 			// Second pass looks for extensions using those aliases

 			foreach (var pair in query) {

-				if (!pair.Key.StartsWith(QueryStringArgs.openid.Prefix)) continue;

-				string possibleAlias = pair.Key.Substring(QueryStringArgs.openid.Prefix.Length);

+				if (!pair.Key.StartsWith(Protocol.Constants.openid.Prefix)) continue;

+				string possibleAlias = pair.Key.Substring(Protocol.Constants.openid.Prefix.Length);

 				int periodIndex = possibleAlias.IndexOf(".", StringComparison.Ordinal);

 				if (periodIndex >= 0) possibleAlias = possibleAlias.Substring(0, periodIndex);

 				string typeUri;

 				if (aliasToTypeUriMap.TryGetValue(possibleAlias, out typeUri)) {

 					if (!mgr.extensions.ContainsKey(typeUri))

 						mgr.extensions[typeUri] = new Dictionary<string, string>();

-					string key = periodIndex >= 0 ? pair.Key.Substring(QueryStringArgs.openid.Prefix.Length + possibleAlias.Length + 1) : string.Empty;

+					string key = periodIndex >= 0 ? pair.Key.Substring(Protocol.Constants.openid.Prefix.Length + possibleAlias.Length + 1) : string.Empty;

 					mgr.extensions[typeUri].Add(key, pair.Value);

 				}

 			}

@@ -87,8 +87,8 @@ namespace DotNetOpenId {
 				if (extensionArgs.Count == 0) continue;

 				string alias = typeUriToAliasMap[typeUri];

 				// send out the alias declaration

-				string openidPrefix = includeOpenIdPrefix ? QueryStringArgs.openid.Prefix : string.Empty;

-				args.Add(openidPrefix + QueryStringArgs.openidnp.ns + "." + alias, typeUri);

+				string openidPrefix = includeOpenIdPrefix ? Protocol.Constants.openid.Prefix : string.Empty;

+				args.Add(openidPrefix + Protocol.Constants.openidnp.ns + "." + alias, typeUri);

 				string prefix = openidPrefix + alias;

 				foreach (var pair in extensionArgs) {

 					string key = prefix;

diff --git a/src/DotNetOpenId/Extensions/SimpleRegistrationFieldValues.cs b/src/DotNetOpenId/Extensions/SimpleRegistrationFieldValues.cs
index 5ea4bc3..e37d14b 100644
--- a/src/DotNetOpenId/Extensions/SimpleRegistrationFieldValues.cs
+++ b/src/DotNetOpenId/Extensions/SimpleRegistrationFieldValues.cs
@@ -73,62 +73,62 @@ namespace DotNetOpenId.Extensions
 			if (authenticationRequest == null) throw new ArgumentNullException("authenticationRequest");

 			Dictionary<string, string> fields = new Dictionary<string, string>();

 			if (BirthDate != null) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.dob, BirthDate.ToString());

+				fields.Add(Protocol.Constants.openidnp.sregnp.dob, BirthDate.ToString());

 			}

 			if (!String.IsNullOrEmpty(Country)) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.country, Country);

+				fields.Add(Protocol.Constants.openidnp.sregnp.country, Country);

 			}

 			if (Email != null) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.email, Email.ToString());

+				fields.Add(Protocol.Constants.openidnp.sregnp.email, Email.ToString());

 			}

 			if ((!String.IsNullOrEmpty(FullName))) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.fullname, FullName);

+				fields.Add(Protocol.Constants.openidnp.sregnp.fullname, FullName);

 			}

 			if (Gender != null) {

 				if (Gender == DotNetOpenId.Extensions.Gender.Female) {

-					fields.Add(QueryStringArgs.openidnp.sregnp.gender, QueryStringArgs.Genders.Female);

+					fields.Add(Protocol.Constants.openidnp.sregnp.gender, Protocol.Constants.Genders.Female);

 				} else {

-					fields.Add(QueryStringArgs.openidnp.sregnp.gender, QueryStringArgs.Genders.Male);

+					fields.Add(Protocol.Constants.openidnp.sregnp.gender, Protocol.Constants.Genders.Male);

 				}

 			}

 			if (!String.IsNullOrEmpty(Language)) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.language, Language);

+				fields.Add(Protocol.Constants.openidnp.sregnp.language, Language);

 			}

 			if (!String.IsNullOrEmpty(Nickname)) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.nickname, Nickname);

+				fields.Add(Protocol.Constants.openidnp.sregnp.nickname, Nickname);

 			}

 			if (!String.IsNullOrEmpty(PostalCode)) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.postcode, PostalCode);

+				fields.Add(Protocol.Constants.openidnp.sregnp.postcode, PostalCode);

 			}

 			if (!String.IsNullOrEmpty(TimeZone)) {

-				fields.Add(QueryStringArgs.openidnp.sregnp.timezone, TimeZone);

+				fields.Add(Protocol.Constants.openidnp.sregnp.timezone, TimeZone);

 			}

-			authenticationRequest.AddExtensionArguments(QueryStringArgs.sreg_ns, fields);

+			authenticationRequest.AddExtensionArguments(Protocol.Constants.sreg_ns, fields);

 		}

 		public static SimpleRegistrationFieldValues ReadFromResponse(IAuthenticationResponse response) {

-			var sreg = response.GetExtensionArguments(QueryStringArgs.sreg_ns);

+			var sreg = response.GetExtensionArguments(Protocol.Constants.sreg_ns);

 			if (sreg == null) return new SimpleRegistrationFieldValues();

 			string nickname, email, fullName, dob, genderString, postalCode, country, language, timeZone;

 			DateTime? birthDate = null;

 			Gender? gender = null;

-			sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.nickname, out nickname);

-			sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.email, out email);

-			sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.fullname, out fullName);

-			if (sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.dob, out dob)) {

+			sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.nickname, out nickname);

+			sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.email, out email);

+			sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.fullname, out fullName);

+			if (sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.dob, out dob)) {

 				DateTime bd;

 				if (DateTime.TryParse(dob, out bd))

 					birthDate = bd;

 			}

-			if (sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.gender, out genderString)) {

+			if (sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.gender, out genderString)) {

 				switch (genderString) {

-					case QueryStringArgs.Genders.Male: gender = DotNetOpenId.Extensions.Gender.Male; break;

-					case QueryStringArgs.Genders.Female: gender = DotNetOpenId.Extensions.Gender.Female; break;

+					case Protocol.Constants.Genders.Male: gender = DotNetOpenId.Extensions.Gender.Male; break;

+					case Protocol.Constants.Genders.Female: gender = DotNetOpenId.Extensions.Gender.Female; break;

 				}

 			}

-			sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.postcode, out postalCode);

-			sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.country, out country);

-			sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.language, out language);

-			sreg.TryGetValue(QueryStringArgs.openidnp.sregnp.timezone, out timeZone);

+			sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.postcode, out postalCode);

+			sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.country, out country);

+			sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.language, out language);

+			sreg.TryGetValue(Protocol.Constants.openidnp.sregnp.timezone, out timeZone);

 

 			return new SimpleRegistrationFieldValues() {

 				Nickname = nickname,

diff --git a/src/DotNetOpenId/Extensions/SimpleRegistrationRequestFields.cs b/src/DotNetOpenId/Extensions/SimpleRegistrationRequestFields.cs
index 78a5c10..f0f152e 100644
--- a/src/DotNetOpenId/Extensions/SimpleRegistrationRequestFields.cs
+++ b/src/DotNetOpenId/Extensions/SimpleRegistrationRequestFields.cs
@@ -44,31 +44,31 @@ namespace DotNetOpenId.Extensions {
 		internal void SetProfileRequestFromList(ICollection<string> fieldNames, SimpleRegistrationRequest requestLevel) {

 			foreach (string field in fieldNames) {

 				switch (field) {

-					case QueryStringArgs.openidnp.sregnp.nickname:

+					case Protocol.Constants.openidnp.sregnp.nickname:

 						Nickname = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.email:

+					case Protocol.Constants.openidnp.sregnp.email:

 						Email = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.fullname:

+					case Protocol.Constants.openidnp.sregnp.fullname:

 						FullName = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.dob:

+					case Protocol.Constants.openidnp.sregnp.dob:

 						BirthDate = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.gender:

+					case Protocol.Constants.openidnp.sregnp.gender:

 						Gender = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.postcode:

+					case Protocol.Constants.openidnp.sregnp.postcode:

 						PostalCode = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.country:

+					case Protocol.Constants.openidnp.sregnp.country:

 						Country = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.language:

+					case Protocol.Constants.openidnp.sregnp.language:

 						Language = requestLevel;

 						break;

-					case QueryStringArgs.openidnp.sregnp.timezone:

+					case Protocol.Constants.openidnp.sregnp.timezone:

 						TimeZone = requestLevel;

 						break;

 					default:

@@ -80,23 +80,23 @@ namespace DotNetOpenId.Extensions {
 		string[] assembleProfileFields(SimpleRegistrationRequest level) {

 			List<string> fields = new List<string>(10);

 			if (Nickname == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.nickname);

+				fields.Add(Protocol.Constants.openidnp.sregnp.nickname);

 			if (Email == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.email);

+				fields.Add(Protocol.Constants.openidnp.sregnp.email);

 			if (FullName == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.fullname);

+				fields.Add(Protocol.Constants.openidnp.sregnp.fullname);

 			if (BirthDate == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.dob);

+				fields.Add(Protocol.Constants.openidnp.sregnp.dob);

 			if (Gender == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.gender);

+				fields.Add(Protocol.Constants.openidnp.sregnp.gender);

 			if (PostalCode == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.postcode);

+				fields.Add(Protocol.Constants.openidnp.sregnp.postcode);

 			if (Country == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.country);

+				fields.Add(Protocol.Constants.openidnp.sregnp.country);

 			if (Language == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.language);

+				fields.Add(Protocol.Constants.openidnp.sregnp.language);

 			if (TimeZone == level)

-				fields.Add(QueryStringArgs.openidnp.sregnp.timezone);

+				fields.Add(Protocol.Constants.openidnp.sregnp.timezone);

 

 			return fields.ToArray();

 		}

@@ -106,22 +106,22 @@ namespace DotNetOpenId.Extensions {
 		/// </summary>

 		public static SimpleRegistrationRequestFields ReadFromRequest(IRequest request) {

 			SimpleRegistrationRequestFields fields = new SimpleRegistrationRequestFields();

-			var args = request.GetExtensionArguments(QueryStringArgs.sreg_ns);

+			var args = request.GetExtensionArguments(Protocol.Constants.sreg_ns);

 			if (args == null) return fields;

 

 			string policyUrl;

-			if (args.TryGetValue(QueryStringArgs.openidnp.sregnp.policy_url, out policyUrl)

+			if (args.TryGetValue(Protocol.Constants.openidnp.sregnp.policy_url, out policyUrl)

 				&& !string.IsNullOrEmpty(policyUrl)) {

 				fields.PolicyUrl = new Uri(policyUrl);

 			}

 

 			string optionalFields;

-			if (args.TryGetValue(QueryStringArgs.openidnp.sregnp.optional, out optionalFields)) {

+			if (args.TryGetValue(Protocol.Constants.openidnp.sregnp.optional, out optionalFields)) {

 				fields.SetProfileRequestFromList(optionalFields.Split(','), SimpleRegistrationRequest.Request);

 			}

 

 			string requiredFields;

-			if (args.TryGetValue(QueryStringArgs.openidnp.sregnp.required, out requiredFields)) {

+			if (args.TryGetValue(Protocol.Constants.openidnp.sregnp.required, out requiredFields)) {

 				fields.SetProfileRequestFromList(requiredFields.Split(','), SimpleRegistrationRequest.Require);

 			}

 

@@ -130,12 +130,12 @@ namespace DotNetOpenId.Extensions {
 		public void AddToRequest(RelyingParty.IAuthenticationRequest request) {

 			var fields = new Dictionary<string, string>();

 			if (PolicyUrl != null)

-				fields.Add(QueryStringArgs.openidnp.sregnp.policy_url, PolicyUrl.AbsoluteUri);

+				fields.Add(Protocol.Constants.openidnp.sregnp.policy_url, PolicyUrl.AbsoluteUri);

 

-			fields.Add(QueryStringArgs.openidnp.sregnp.required, string.Join(",", assembleProfileFields(SimpleRegistrationRequest.Require)));

-			fields.Add(QueryStringArgs.openidnp.sregnp.optional, string.Join(",", assembleProfileFields(SimpleRegistrationRequest.Request)));

+			fields.Add(Protocol.Constants.openidnp.sregnp.required, string.Join(",", assembleProfileFields(SimpleRegistrationRequest.Require)));

+			fields.Add(Protocol.Constants.openidnp.sregnp.optional, string.Join(",", assembleProfileFields(SimpleRegistrationRequest.Request)));

 

-			request.AddExtensionArguments(QueryStringArgs.sreg_ns, fields);

+			request.AddExtensionArguments(Protocol.Constants.sreg_ns, fields);

 		}

 

 		public override string ToString() {

diff --git a/src/DotNetOpenId/HmacSha1Association.cs b/src/DotNetOpenId/HmacSha1Association.cs
index 390e546..ee8af28 100644
--- a/src/DotNetOpenId/HmacSha1Association.cs
+++ b/src/DotNetOpenId/HmacSha1Association.cs
@@ -10,7 +10,7 @@ namespace DotNetOpenId {
 		}

 

 		protected internal override string AssociationType {

-			get { return QueryStringArgs.SignatureAlgorithms.HMAC_SHA1; }

+			get { return Protocol.Constants.SignatureAlgorithms.HMAC_SHA1; }

 		}

 

 		protected internal override byte[] Sign(IDictionary<string, string> data, IList<string> keyOrder) {

diff --git a/src/DotNetOpenId/HmacSha256Association.cs b/src/DotNetOpenId/HmacSha256Association.cs
index 001dd71..cbf8c4c 100644
--- a/src/DotNetOpenId/HmacSha256Association.cs
+++ b/src/DotNetOpenId/HmacSha256Association.cs
@@ -10,7 +10,7 @@ namespace DotNetOpenId {
 		}

 

 		protected internal override string AssociationType {

-			get { return QueryStringArgs.SignatureAlgorithms.HMAC_SHA256; }

+			get { return Protocol.Constants.SignatureAlgorithms.HMAC_SHA256; }

 		}

 

 		protected internal override byte[] Sign(IDictionary<string, string> data, IList<string> keyOrder) {

diff --git a/src/DotNetOpenId/OpenIdException.cs b/src/DotNetOpenId/OpenIdException.cs
index a1d0e43..e0cac04 100644
--- a/src/DotNetOpenId/OpenIdException.cs
+++ b/src/DotNetOpenId/OpenIdException.cs
@@ -56,7 +56,7 @@ namespace DotNetOpenId {
 

 		internal bool HasReturnTo {

 			get {

-				return query == null ? false : query.ContainsKey(QueryStringArgs.openid.return_to);

+				return query == null ? false : query.ContainsKey(Protocol.Constants.openid.return_to);

 			}

 		}

 

@@ -68,10 +68,10 @@ namespace DotNetOpenId {
 					return EncodingType.RedirectBrowserUrl;

 

 				if (query != null) {

-					string mode = Util.GetOptionalArg(query, QueryStringArgs.openid.mode);

+					string mode = Util.GetOptionalArg(query, Protocol.Constants.openid.mode);

 					if (mode != null)

-						if (mode != QueryStringArgs.Modes.checkid_setup &&

-							mode != QueryStringArgs.Modes.checkid_immediate)

+						if (mode != Protocol.Constants.Modes.checkid_setup &&

+							mode != Protocol.Constants.Modes.checkid_immediate)

 							return EncodingType.ResponseBody;

 				}

 

@@ -95,8 +95,8 @@ namespace DotNetOpenId {
 		public IDictionary<string, string> EncodedFields {

 			get {

 				var q = new Dictionary<string, string>();

-				q.Add(QueryStringArgs.openid.mode, QueryStringArgs.Modes.error);

-				q.Add(QueryStringArgs.openid.error, Message);

+				q.Add(Protocol.Constants.openid.mode, Protocol.Constants.Modes.error);

+				q.Add(Protocol.Constants.openid.error, Message);

 				return q;

 			}

 		}

@@ -104,7 +104,7 @@ namespace DotNetOpenId {
 			get {

 				if (query == null)

 					return null;

-				return new Uri(Util.GetRequiredArg(query, QueryStringArgs.openid.return_to));

+				return new Uri(Util.GetRequiredArg(query, Protocol.Constants.openid.return_to));

 			}

 		}

 

diff --git a/src/DotNetOpenId/Protocol.cs b/src/DotNetOpenId/Protocol.cs
index 9ad2a44..1b348ff 100644
--- a/src/DotNetOpenId/Protocol.cs
+++ b/src/DotNetOpenId/Protocol.cs
@@ -12,35 +12,35 @@ namespace DotNetOpenId {
 

 		// Well-known, supported versions of the OpenID spec.

 		public static readonly Protocol v10 = new Protocol {

-				Version = new Version(1, 0),

-				XmlNamespace = "http://openid.net/xmlns/1.0",

-				QueryDeclaredNamespaceVersion = null,

-				ClaimedIdentifierServiceTypeURI = "http://openid.net/signon/1.0",

-				OPIdentifierServiceTypeURI = null, // not supported

-				ClaimedIdentifierForOPIdentifier = null, // not supported

-				HtmlDiscoveryProviderKey = "openid.server",

-				HtmlDiscoveryLocalIdKey = "openid.delegate",

-			};

+			Version = new Version(1, 0),

+			XmlNamespace = "http://openid.net/xmlns/1.0",

+			QueryDeclaredNamespaceVersion = null,

+			ClaimedIdentifierServiceTypeURI = "http://openid.net/signon/1.0",

+			OPIdentifierServiceTypeURI = null, // not supported

+			ClaimedIdentifierForOPIdentifier = null, // not supported

+			HtmlDiscoveryProviderKey = "openid.server",

+			HtmlDiscoveryLocalIdKey = "openid.delegate",

+		};

 		public static readonly Protocol v11 = new Protocol {

-				Version = new Version(1, 1),

-				XmlNamespace = "http://openid.net/xmlns/1.0",

-				QueryDeclaredNamespaceVersion = null,

-				ClaimedIdentifierServiceTypeURI = "http://openid.net/signon/1.1",

-				OPIdentifierServiceTypeURI = null, // not supported

-				ClaimedIdentifierForOPIdentifier = null, // not supported

-				HtmlDiscoveryProviderKey = "openid.server",

-				HtmlDiscoveryLocalIdKey = "openid.delegate",

-			};

+			Version = new Version(1, 1),

+			XmlNamespace = "http://openid.net/xmlns/1.0",

+			QueryDeclaredNamespaceVersion = null,

+			ClaimedIdentifierServiceTypeURI = "http://openid.net/signon/1.1",

+			OPIdentifierServiceTypeURI = null, // not supported

+			ClaimedIdentifierForOPIdentifier = null, // not supported

+			HtmlDiscoveryProviderKey = "openid.server",

+			HtmlDiscoveryLocalIdKey = "openid.delegate",

+		};

 		public static readonly Protocol v20 = new Protocol {

-				Version = new Version(2, 0),

-				XmlNamespace = null, // no longer applicable

-				QueryDeclaredNamespaceVersion = "http://specs.openid.net/auth/2.0",

-				ClaimedIdentifierServiceTypeURI = "http://specs.openid.net/auth/2.0/signon",

-				OPIdentifierServiceTypeURI = "http://specs.openid.net/auth/2.0/server",

-				ClaimedIdentifierForOPIdentifier = "http://specs.openid.net/auth/2.0/identifier_select",

-				HtmlDiscoveryProviderKey = "openid2.provider",

-				HtmlDiscoveryLocalIdKey = "openid2.local_id",

-			};

+			Version = new Version(2, 0),

+			XmlNamespace = null, // no longer applicable

+			QueryDeclaredNamespaceVersion = "http://specs.openid.net/auth/2.0",

+			ClaimedIdentifierServiceTypeURI = "http://specs.openid.net/auth/2.0/signon",

+			OPIdentifierServiceTypeURI = "http://specs.openid.net/auth/2.0/server",

+			ClaimedIdentifierForOPIdentifier = "http://specs.openid.net/auth/2.0/identifier_select",

+			HtmlDiscoveryProviderKey = "openid2.provider",

+			HtmlDiscoveryLocalIdKey = "openid2.local_id",

+		};

 		/// <summary>

 		/// A list of all supported OpenID versions, in order starting from newest version.

 		/// </summary>

@@ -88,110 +88,104 @@ namespace DotNetOpenId {
 		/// as the OP Local Identifier.

 		/// </summary>

 		public string HtmlDiscoveryLocalIdKey;

-	}

 

-	internal static class QueryStringArgs {

-		/// <summary>openid. variables that don't include the "openid." prefix.</summary>

-		internal static class openidnp {

-			internal const string ns = "ns";

-			internal const string return_to = "return_to";

-			internal const string mode = "mode";

-			internal const string error = "error";

-			internal const string identity = "identity";

-			internal const string claimed_id = "claimed_id";

-			internal const string expires_in = "expires_in";

-			internal const string assoc_type = "assoc_type";

-			internal const string assoc_handle = "assoc_handle";

-			internal const string session_type = "session_type";

-			internal const string is_valid = "is_valid";

-			internal const string sig = "sig";

-			internal const string signed = "signed";

-			internal const string user_setup_url = "user_setup_url";

-			internal const string trust_root = "trust_root";

-			internal const string realm = "realm";

-			internal const string invalidate_handle = "invalidate_handle";

-			internal const string dh_modulus = "dh_modulus";

-			internal const string dh_gen = "dh_gen";

-			internal const string dh_consumer_public = "dh_consumer_public";

-			internal const string dh_server_public = "dh_server_public";

+		internal static class Constants {

+			/// <summary>openid. variables that don't include the "openid." prefix.</summary>

+			internal static class openidnp {

+				internal const string ns = "ns";

+				internal const string return_to = "return_to";

+				internal const string mode = "mode";

+				internal const string error = "error";

+				internal const string identity = "identity";

+				internal const string claimed_id = "claimed_id";

+				internal const string expires_in = "expires_in";

+				internal const string assoc_type = "assoc_type";

+				internal const string assoc_handle = "assoc_handle";

+				internal const string session_type = "session_type";

+				internal const string is_valid = "is_valid";

+				internal const string sig = "sig";

+				internal const string signed = "signed";

+				internal const string user_setup_url = "user_setup_url";

+				internal const string trust_root = "trust_root";

+				internal const string realm = "realm";

+				internal const string invalidate_handle = "invalidate_handle";

+				internal const string dh_modulus = "dh_modulus";

+				internal const string dh_gen = "dh_gen";

+				internal const string dh_consumer_public = "dh_consumer_public";

+				internal const string dh_server_public = "dh_server_public";

 

-			internal static class sregnp {

-				internal const string policy_url = "policy_url";

-				internal const string optional = "optional";

-				internal const string required = "required";

-				internal const string nickname = "nickname";

-				internal const string email = "email";

-				internal const string fullname = "fullname";

-				internal const string dob = "dob";

-				internal const string gender = "gender";

-				internal const string postcode = "postcode";

-				internal const string country = "country";

-				internal const string language = "language";

-				internal const string timezone = "timezone";

+				internal static class sregnp {

+					internal const string policy_url = "policy_url";

+					internal const string optional = "optional";

+					internal const string required = "required";

+					internal const string nickname = "nickname";

+					internal const string email = "email";

+					internal const string fullname = "fullname";

+					internal const string dob = "dob";

+					internal const string gender = "gender";

+					internal const string postcode = "postcode";

+					internal const string country = "country";

+					internal const string language = "language";

+					internal const string timezone = "timezone";

+				}

 			}

-		}

-		/// <summary>openid. variables that include the "openid." prefix.</summary>

-		internal static class openid {

-			internal const string Prefix = "openid.";

+			/// <summary>openid. variables that include the "openid." prefix.</summary>

+			internal static class openid {

+				internal const string Prefix = "openid.";

 

-			internal const string ns = Prefix + openidnp.ns;

-			internal const string return_to = Prefix + openidnp.return_to;

-			internal const string mode = Prefix + openidnp.mode;

-			internal const string error = Prefix + openidnp.error;

-			internal const string identity = Prefix + openidnp.identity;

-			internal const string claimed_id = Prefix + openidnp.claimed_id;

-			internal const string expires_in = Prefix + openidnp.expires_in;

-			internal const string assoc_type = Prefix + openidnp.assoc_type;

-			internal const string assoc_handle = Prefix + openidnp.assoc_handle;

-			internal const string session_type = Prefix + openidnp.session_type;

-			internal const string is_valid = Prefix + openidnp.is_valid;

-			internal const string sig = Prefix + openidnp.sig;

-			internal const string signed = Prefix + openidnp.signed;

-			internal const string user_setup_url = Prefix + openidnp.user_setup_url;

-			internal const string trust_root = Prefix + openidnp.trust_root;

-			internal const string realm = Prefix + openidnp.realm;

-			internal const string invalidate_handle = Prefix + openidnp.invalidate_handle;

-			internal const string dh_modulus = Prefix + openidnp.dh_modulus;

-			internal const string dh_gen = Prefix + openidnp.dh_gen;

-			internal const string dh_consumer_public = Prefix + openidnp.dh_consumer_public;

-			internal const string dh_server_public = Prefix + openidnp.dh_server_public;

-		}

-		internal const string enc_mac_key = "enc_mac_key";

-		internal const string mac_key = "mac_key";

-		internal const string sreg_ns = "http://openid.net/extensions/sreg/1.1";

-		internal const string sreg_compatibility_alias = "sreg";

-		internal static class SessionType {

-			internal const string DH_SHA1 = "DH-SHA1";

-			internal const string DH_SHA256 = "DH-SHA256";

-			internal const string NoEncryption20 = "no-encryption";

-			internal const string NoEncryption11 = "";

-		}

-		internal static class SignatureAlgorithms {

-			internal const string HMAC_SHA1 = "HMAC-SHA1";

-			internal const string HMAC_SHA256 = "HMAC-SHA256";

-		}

+				internal const string ns = Prefix + openidnp.ns;

+				internal const string return_to = Prefix + openidnp.return_to;

+				internal const string mode = Prefix + openidnp.mode;

+				internal const string error = Prefix + openidnp.error;

+				internal const string identity = Prefix + openidnp.identity;

+				internal const string claimed_id = Prefix + openidnp.claimed_id;

+				internal const string expires_in = Prefix + openidnp.expires_in;

+				internal const string assoc_type = Prefix + openidnp.assoc_type;

+				internal const string assoc_handle = Prefix + openidnp.assoc_handle;

+				internal const string session_type = Prefix + openidnp.session_type;

+				internal const string is_valid = Prefix + openidnp.is_valid;

+				internal const string sig = Prefix + openidnp.sig;

+				internal const string signed = Prefix + openidnp.signed;

+				internal const string user_setup_url = Prefix + openidnp.user_setup_url;

+				internal const string trust_root = Prefix + openidnp.trust_root;

+				internal const string realm = Prefix + openidnp.realm;

+				internal const string invalidate_handle = Prefix + openidnp.invalidate_handle;

+				internal const string dh_modulus = Prefix + openidnp.dh_modulus;

+				internal const string dh_gen = Prefix + openidnp.dh_gen;

+				internal const string dh_consumer_public = Prefix + openidnp.dh_consumer_public;

+				internal const string dh_server_public = Prefix + openidnp.dh_server_public;

+			}

+			internal const string enc_mac_key = "enc_mac_key";

+			internal const string mac_key = "mac_key";

+			internal const string sreg_ns = "http://openid.net/extensions/sreg/1.1";

+			internal const string sreg_compatibility_alias = "sreg";

+			internal static class SessionType {

+				internal const string DH_SHA1 = "DH-SHA1";

+				internal const string DH_SHA256 = "DH-SHA256";

+				internal const string NoEncryption20 = "no-encryption";

+				internal const string NoEncryption11 = "";

+			}

+			internal static class SignatureAlgorithms {

+				internal const string HMAC_SHA1 = "HMAC-SHA1";

+				internal const string HMAC_SHA256 = "HMAC-SHA256";

+			}

 

-		internal static class Modes {

-			internal const string cancel = "cancel";

-			internal const string error = "error";

-			internal const string id_res = "id_res";

-			internal const string checkid_immediate = "checkid_immediate";

-			internal const string checkid_setup = "checkid_setup";

-			internal const string check_authentication = "check_authentication";

-			internal const string associate = "associate";

-		}

-		internal static class Genders {

-			internal const string Male = "M";

-			internal const string Female = "F";

-		}

-		internal static class IsValid {

-			internal const string True = "true";

+			internal static class Modes {

+				internal const string cancel = "cancel";

+				internal const string error = "error";

+				internal const string id_res = "id_res";

+				internal const string checkid_immediate = "checkid_immediate";

+				internal const string checkid_setup = "checkid_setup";

+				internal const string check_authentication = "check_authentication";

+				internal const string associate = "associate";

+			}

+			internal static class Genders {

+				internal const string Male = "M";

+				internal const string Female = "F";

+			}

+			internal static class IsValid {

+				internal const string True = "true";

+			}

 		}

-

-		/// <summary>

-		/// Used by ASP.NET on a login page to determine where a successful

-		/// login should be redirected to.

-		/// </summary>

-		internal const string ReturnUrl = "ReturnUrl";

 	}

 }

diff --git a/src/DotNetOpenId/Provider/AssociateRequest.cs b/src/DotNetOpenId/Provider/AssociateRequest.cs
index 83ffe94..207f897 100644
--- a/src/DotNetOpenId/Provider/AssociateRequest.cs
+++ b/src/DotNetOpenId/Provider/AssociateRequest.cs
@@ -16,7 +16,7 @@ namespace DotNetOpenId.Provider {
 		public AssociateRequest(OpenIdProvider server)

 			: base(server) {

 			session = ProviderSession.CreateSession(Query);

-			associationKeyType = Util.GetRequiredArg(Query, QueryStringArgs.openidnp.assoc_type);

+			associationKeyType = Util.GetRequiredArg(Query, Protocol.Constants.openidnp.assoc_type);

 		}

 

 		public override bool IsResponseReady {

@@ -28,7 +28,7 @@ namespace DotNetOpenId.Provider {
 		/// Returns the string "associate".

 		/// </summary>

 		internal override string Mode {

-			get { return QueryStringArgs.Modes.associate; }

+			get { return Protocol.Constants.Modes.associate; }

 		}

 

 		/// <summary>

@@ -46,17 +46,17 @@ namespace DotNetOpenId.Provider {
 

 			EncodableResponse response = new EncodableResponse(this);

 

-			response.Fields[QueryStringArgs.openidnp.expires_in] = assoc.SecondsTillExpiration.ToString(CultureInfo.InvariantCulture);

-			response.Fields[QueryStringArgs.openidnp.assoc_type] = assoc.AssociationType;

-			response.Fields[QueryStringArgs.openidnp.assoc_handle] = assoc.Handle;

+			response.Fields[Protocol.Constants.openidnp.expires_in] = assoc.SecondsTillExpiration.ToString(CultureInfo.InvariantCulture);

+			response.Fields[Protocol.Constants.openidnp.assoc_type] = assoc.AssociationType;

+			response.Fields[Protocol.Constants.openidnp.assoc_handle] = assoc.Handle;

 

 			IDictionary<string, string> nvc = session.Answer(assoc.SecretKey);

 			foreach (var pair in nvc) {

 				response.Fields[pair.Key] = nvc[pair.Key];

 			}

 

-			if (session.SessionType != QueryStringArgs.SessionType.NoEncryption11) {

-				response.Fields[QueryStringArgs.openidnp.session_type] = session.SessionType;

+			if (session.SessionType != Protocol.Constants.SessionType.NoEncryption11) {

+				response.Fields[Protocol.Constants.openidnp.session_type] = session.SessionType;

 			}

 

 			if (TraceUtil.Switch.TraceInfo) {

diff --git a/src/DotNetOpenId/Provider/CheckAuthRequest.cs b/src/DotNetOpenId/Provider/CheckAuthRequest.cs
index 5d0314e..741802f 100644
--- a/src/DotNetOpenId/Provider/CheckAuthRequest.cs
+++ b/src/DotNetOpenId/Provider/CheckAuthRequest.cs
@@ -18,16 +18,16 @@ namespace DotNetOpenId.Provider {
 

 		public CheckAuthRequest(OpenIdProvider server)

 			: base(server) {

-			AssociationHandle = Util.GetRequiredArg(Query, QueryStringArgs.openid.assoc_handle);

-			signature = Util.GetRequiredArg(Query, QueryStringArgs.openid.sig);

-			signedKeyOrder = Util.GetRequiredArg(Query, QueryStringArgs.openid.signed).Split(',');

-			invalidate_handle = Util.GetOptionalArg(Query, QueryStringArgs.openid.invalidate_handle);

+			AssociationHandle = Util.GetRequiredArg(Query, Protocol.Constants.openid.assoc_handle);

+			signature = Util.GetRequiredArg(Query, Protocol.Constants.openid.sig);

+			signedKeyOrder = Util.GetRequiredArg(Query, Protocol.Constants.openid.signed).Split(',');

+			invalidate_handle = Util.GetOptionalArg(Query, Protocol.Constants.openid.invalidate_handle);

 

 			signedFields = new Dictionary<string, string>();

 

 			foreach (string key in signedKeyOrder) {

-				string value = (key == QueryStringArgs.openidnp.mode) ?

-					QueryStringArgs.Modes.id_res : Util.GetRequiredArg(Query, QueryStringArgs.openid.Prefix + key);

+				string value = (key == Protocol.Constants.openidnp.mode) ?

+					Protocol.Constants.Modes.id_res : Util.GetRequiredArg(Query, Protocol.Constants.openid.Prefix + key);

 				signedFields.Add(key, value);

 			}

 		}

@@ -41,7 +41,7 @@ namespace DotNetOpenId.Provider {
 		/// Gets the string "check_authentication".

 		/// </summary>

 		internal override string Mode {

-			get { return QueryStringArgs.Modes.check_authentication; }

+			get { return Protocol.Constants.Modes.check_authentication; }

 		}

 

 		/// <summary>

@@ -58,7 +58,7 @@ namespace DotNetOpenId.Provider {
 

 			EncodableResponse response = new EncodableResponse(this);

 

-			response.Fields[QueryStringArgs.openidnp.is_valid] = (is_valid ? "true" : "false");

+			response.Fields[Protocol.Constants.openidnp.is_valid] = (is_valid ? "true" : "false");

 

 			if (!string.IsNullOrEmpty(invalidate_handle)) {

 				Association assoc = Server.Signatory.GetAssociation(invalidate_handle, AssociationRelyingPartyType.Smart);

@@ -68,7 +68,7 @@ namespace DotNetOpenId.Provider {
 						Trace.TraceWarning("No matching association found. Returning invalidate_handle. ");

 					}

 

-					response.Fields[QueryStringArgs.openidnp.invalidate_handle] = invalidate_handle;

+					response.Fields[Protocol.Constants.openidnp.invalidate_handle] = invalidate_handle;

 				}

 			}

 

diff --git a/src/DotNetOpenId/Provider/CheckIdRequest.cs b/src/DotNetOpenId/Provider/CheckIdRequest.cs
index 715f82d..43b2154 100644
--- a/src/DotNetOpenId/Provider/CheckIdRequest.cs
+++ b/src/DotNetOpenId/Provider/CheckIdRequest.cs
@@ -63,7 +63,7 @@ namespace DotNetOpenId.Provider {
 		/// </summary>

 		internal Uri ReturnTo { get; private set; }

 		internal override string Mode {

-			get { return Immediate ? QueryStringArgs.Modes.checkid_immediate : QueryStringArgs.Modes.checkid_setup; }

+			get { return Immediate ? Protocol.Constants.Modes.checkid_immediate : Protocol.Constants.Modes.checkid_setup; }

 		}

 		/// <summary>

 		/// Indicates whether this request has all the information necessary to formulate a response.

@@ -81,7 +81,7 @@ namespace DotNetOpenId.Provider {
 

 				UriBuilder builder = new UriBuilder(ReturnTo);

 				var args = new Dictionary<string, string>();

-				args.Add(QueryStringArgs.openid.mode, QueryStringArgs.Modes.cancel);

+				args.Add(Protocol.Constants.openid.mode, Protocol.Constants.Modes.cancel);

 				UriUtil.AppendQueryArgs(builder, args);

 

 				return builder.Uri;

@@ -90,38 +90,38 @@ namespace DotNetOpenId.Provider {
 

 		internal CheckIdRequest(OpenIdProvider server) : base(server) {

 			// handle the mandatory protocol fields

-			string mode = Util.GetRequiredArg(Query, QueryStringArgs.openid.mode);

-			if (QueryStringArgs.Modes.checkid_immediate.Equals(mode, StringComparison.Ordinal)) {

+			string mode = Util.GetRequiredArg(Query, Protocol.Constants.openid.mode);

+			if (Protocol.Constants.Modes.checkid_immediate.Equals(mode, StringComparison.Ordinal)) {

 				Immediate = true;

-			} else if (QueryStringArgs.Modes.checkid_setup.Equals(mode, StringComparison.Ordinal)) {

+			} else if (Protocol.Constants.Modes.checkid_setup.Equals(mode, StringComparison.Ordinal)) {

 				Immediate = false; // implied

 			} else {

 				throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

-					Strings.InvalidOpenIdQueryParameterValue, QueryStringArgs.openid.mode, mode), Query);

+					Strings.InvalidOpenIdQueryParameterValue, Protocol.Constants.openid.mode, mode), Query);

 			}

 

 			try {

-				ClaimedIdentifier = Util.GetRequiredArg(Query, QueryStringArgs.openid.identity);

+				ClaimedIdentifier = Util.GetRequiredArg(Query, Protocol.Constants.openid.identity);

 			} catch (UriFormatException) {

-				throw new OpenIdException(QueryStringArgs.openid.identity + " not a valid url: " + Util.GetRequiredArg(Query, QueryStringArgs.openid.identity), Query);

+				throw new OpenIdException(Protocol.Constants.openid.identity + " not a valid url: " + Util.GetRequiredArg(Query, Protocol.Constants.openid.identity), Query);

 			}

 

 			try {

-				ReturnTo = new Uri(Util.GetRequiredArg(Query, QueryStringArgs.openid.return_to));

+				ReturnTo = new Uri(Util.GetRequiredArg(Query, Protocol.Constants.openid.return_to));

 			} catch (UriFormatException ex) {

 				throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture, 

-					"'{0}' is not a valid OpenID return_to URL.", Util.GetRequiredArg(Query, QueryStringArgs.openid.return_to)),

+					"'{0}' is not a valid OpenID return_to URL.", Util.GetRequiredArg(Query, Protocol.Constants.openid.return_to)),

 					ClaimedIdentifier, Query, ex);

 			}

 

 			try {

-				Realm = new Realm(Util.GetOptionalArg(Query, QueryStringArgs.openid.trust_root) ?? ReturnTo.AbsoluteUri);

+				Realm = new Realm(Util.GetOptionalArg(Query, Protocol.Constants.openid.trust_root) ?? ReturnTo.AbsoluteUri);

 			} catch (UriFormatException ex) {

 				throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

-					Strings.InvalidOpenIdQueryParameterValue, QueryStringArgs.openid.trust_root,

-					Util.GetOptionalArg(Query, QueryStringArgs.openid.trust_root)), ex);

+					Strings.InvalidOpenIdQueryParameterValue, Protocol.Constants.openid.trust_root,

+					Util.GetOptionalArg(Query, Protocol.Constants.openid.trust_root)), ex);

 			}

-			AssociationHandle = Util.GetOptionalArg(Query, QueryStringArgs.openid.assoc_handle);

+			AssociationHandle = Util.GetOptionalArg(Query, Protocol.Constants.openid.assoc_handle);

 

 			if (!Realm.Contains(ReturnTo)) {

 				throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

@@ -131,7 +131,7 @@ namespace DotNetOpenId.Provider {
 

 		internal override IEncodable CreateResponse() {

 			string mode = (IsAuthenticated.Value || Immediate) ?

-				QueryStringArgs.Modes.id_res : QueryStringArgs.Modes.cancel;

+				Protocol.Constants.Modes.id_res : Protocol.Constants.Modes.cancel;

 

 			if (TraceUtil.Switch.TraceInfo) {

 				Trace.TraceInformation("Start processing Response for CheckIdRequest");

@@ -143,17 +143,17 @@ namespace DotNetOpenId.Provider {
 			EncodableResponse response = new EncodableResponse(this);

 

 			// Always send the openid.mode, and sign it only if authentication succeeded.

-			response.AddField(null, QueryStringArgs.openidnp.mode, mode, IsAuthenticated.Value);

+			response.AddField(null, Protocol.Constants.openidnp.mode, mode, IsAuthenticated.Value);

 

 			if (IsAuthenticated.Value) {

 				// Add additional signed fields

 				var fields = new Dictionary<string, string>();

-				fields.Add(QueryStringArgs.openidnp.identity, ClaimedIdentifier.ToString());

-				fields.Add(QueryStringArgs.openidnp.return_to, ReturnTo.AbsoluteUri);

+				fields.Add(Protocol.Constants.openidnp.identity, ClaimedIdentifier.ToString());

+				fields.Add(Protocol.Constants.openidnp.return_to, ReturnTo.AbsoluteUri);

 				response.AddFields(null, fields, true);

 			}

 			if (Immediate && !IsAuthenticated.Value) {

-				response.AddField(null, QueryStringArgs.openidnp.user_setup_url, SetupUrl.AbsoluteUri, false);

+				response.AddField(null, Protocol.Constants.openidnp.user_setup_url, SetupUrl.AbsoluteUri, false);

 			}

 

 			if (TraceUtil.Switch.TraceInfo) {

@@ -185,15 +185,15 @@ namespace DotNetOpenId.Provider {
 

 				var q = new Dictionary<string, string>();

 

-				q.Add(QueryStringArgs.openid.mode, QueryStringArgs.Modes.checkid_setup);

-				q.Add(QueryStringArgs.openid.identity, ClaimedIdentifier.ToString());

-				q.Add(QueryStringArgs.openid.return_to, ReturnTo.AbsoluteUri);

+				q.Add(Protocol.Constants.openid.mode, Protocol.Constants.Modes.checkid_setup);

+				q.Add(Protocol.Constants.openid.identity, ClaimedIdentifier.ToString());

+				q.Add(Protocol.Constants.openid.return_to, ReturnTo.AbsoluteUri);

 

 				if (Realm != null)

-					q.Add(QueryStringArgs.openid.trust_root, Realm.ToString());

+					q.Add(Protocol.Constants.openid.trust_root, Realm.ToString());

 

 				if (this.AssociationHandle != null)

-					q.Add(QueryStringArgs.openid.assoc_handle, this.AssociationHandle);

+					q.Add(Protocol.Constants.openid.assoc_handle, this.AssociationHandle);

 

 				UriBuilder builder = new UriBuilder(ProviderEndpoint);

 				UriUtil.AppendQueryArgs(builder, q);

diff --git a/src/DotNetOpenId/Provider/EncodableResponse.cs b/src/DotNetOpenId/Provider/EncodableResponse.cs
index 83f3669..729c398 100644
--- a/src/DotNetOpenId/Provider/EncodableResponse.cs
+++ b/src/DotNetOpenId/Provider/EncodableResponse.cs
@@ -57,7 +57,7 @@ namespace DotNetOpenId.Provider {
 

 				foreach (var pair in Fields) {

 					if (Request is CheckIdRequest) {

-						nvc.Add(QueryStringArgs.openid.Prefix + pair.Key, pair.Value);

+						nvc.Add(Protocol.Constants.openid.Prefix + pair.Key, pair.Value);

 					} else {

 						nvc.Add(pair.Key, pair.Value);

 					}

diff --git a/src/DotNetOpenId/Provider/Encoder.cs b/src/DotNetOpenId/Provider/Encoder.cs
index c4409a6..83d1a1a 100644
--- a/src/DotNetOpenId/Provider/Encoder.cs
+++ b/src/DotNetOpenId/Provider/Encoder.cs
@@ -64,7 +64,7 @@ namespace DotNetOpenId.Provider {
 				}

 

 				if (response.NeedsSigning) {

-					Debug.Assert(!response.Fields.ContainsKey(QueryStringArgs.openidnp.sig));

+					Debug.Assert(!response.Fields.ContainsKey(Protocol.Constants.openidnp.sig));

 

 					signatory.Sign(response);

 				}

diff --git a/src/DotNetOpenId/Provider/ProviderSession.cs b/src/DotNetOpenId/Provider/ProviderSession.cs
index b8128ff..0f41d6b 100644
--- a/src/DotNetOpenId/Provider/ProviderSession.cs
+++ b/src/DotNetOpenId/Provider/ProviderSession.cs
@@ -11,19 +11,19 @@ namespace DotNetOpenId.Provider {
 		public abstract Dictionary<string, string> Answer(byte[] secret);

 		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1820:TestForEmptyStringsUsingStringLength")]

 		public static ProviderSession CreateSession(IDictionary<string, string> query) {

-			string session_type = query[QueryStringArgs.openid.session_type];

+			string session_type = query[Protocol.Constants.openid.session_type];

 

 			switch (session_type) {

 				case null:

-				case QueryStringArgs.SessionType.NoEncryption11:

-				case QueryStringArgs.SessionType.NoEncryption20:

+				case Protocol.Constants.SessionType.NoEncryption11:

+				case Protocol.Constants.SessionType.NoEncryption20:

 					return new PlainTextProviderSession();

-				case QueryStringArgs.SessionType.DH_SHA1:

+				case Protocol.Constants.SessionType.DH_SHA1:

 					return new DiffieHellmanProviderSession(query);

 				default:

 					throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 						Strings.InvalidOpenIdQueryParameterValue,

-						QueryStringArgs.openid.session_type, session_type), query);

+						Protocol.Constants.openid.session_type, session_type), query);

 			}

 		}

 	}

@@ -33,12 +33,12 @@ namespace DotNetOpenId.Provider {
 	/// </summary>

 	internal class PlainTextProviderSession : ProviderSession {

 		public override string SessionType {

-			get { return QueryStringArgs.SessionType.NoEncryption11; }

+			get { return Protocol.Constants.SessionType.NoEncryption11; }

 		}

 

 		public override Dictionary<string, string> Answer(byte[] secret) {

 			var nvc = new Dictionary<string, string>();

-			nvc.Add(QueryStringArgs.mac_key, CryptUtil.ToBase64String(secret));

+			nvc.Add(Protocol.Constants.mac_key, CryptUtil.ToBase64String(secret));

 			return nvc;

 		}

 	}

@@ -52,11 +52,11 @@ namespace DotNetOpenId.Provider {
 		string sessionType;

 

 		public DiffieHellmanProviderSession(IDictionary<string, string> query) {

-			sessionType = Util.GetRequiredArg(query, QueryStringArgs.openid.session_type);

+			sessionType = Util.GetRequiredArg(query, Protocol.Constants.openid.session_type);

 

 			string missing;

-			string dh_modulus = Util.GetOptionalArg(query, QueryStringArgs.openid.dh_modulus);

-			string dh_gen = Util.GetOptionalArg(query, QueryStringArgs.openid.dh_gen);

+			string dh_modulus = Util.GetOptionalArg(query, Protocol.Constants.openid.dh_modulus);

+			string dh_gen = Util.GetOptionalArg(query, Protocol.Constants.openid.dh_gen);

 			byte[] dh_modulus_bytes = new byte[0];

 			byte[] dh_gen_bytes = new byte[0];

 

@@ -74,7 +74,7 @@ namespace DotNetOpenId.Provider {
 				} catch (FormatException) {

 					throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 						Strings.InvalidOpenIdQueryParameterValueBadBase64,

-						QueryStringArgs.openid.dh_modulus, dh_modulus), query);

+						Protocol.Constants.openid.dh_modulus, dh_modulus), query);

 				}

 

 				try {

@@ -82,7 +82,7 @@ namespace DotNetOpenId.Provider {
 				} catch (FormatException) {

 					throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 						Strings.InvalidOpenIdQueryParameterValueBadBase64,

-						QueryStringArgs.openid.dh_gen, dh_gen), query);

+						Protocol.Constants.openid.dh_gen, dh_gen), query);

 				}

 			} else {

 				dh_modulus_bytes = CryptUtil.DEFAULT_MOD;

@@ -91,13 +91,13 @@ namespace DotNetOpenId.Provider {
 

 			_dh = new DiffieHellmanManaged(dh_modulus_bytes, dh_gen_bytes, 1024);

 

-			string consumer_pubkey = Util.GetRequiredArg(query, QueryStringArgs.openid.dh_consumer_public);

+			string consumer_pubkey = Util.GetRequiredArg(query, Protocol.Constants.openid.dh_consumer_public);

 			try {

 				_consumer_pubkey = Convert.FromBase64String(consumer_pubkey);

 			} catch (FormatException) {

 				throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 					Strings.InvalidOpenIdQueryParameterValueBadBase64,

-					QueryStringArgs.openid.dh_consumer_public, consumer_pubkey), query);

+					Protocol.Constants.openid.dh_consumer_public, consumer_pubkey), query);

 			}

 		}

 

@@ -109,8 +109,8 @@ namespace DotNetOpenId.Provider {
 			byte[] mac_key = CryptUtil.SHAHashXorSecret(CryptUtil.Sha1, _dh, _consumer_pubkey, secret);

 			var nvc = new Dictionary<string, string>();

 

-			nvc.Add(QueryStringArgs.openidnp.dh_server_public, CryptUtil.UnsignedToBase64(_dh.CreateKeyExchange()));

-			nvc.Add(QueryStringArgs.enc_mac_key, CryptUtil.ToBase64String(mac_key));

+			nvc.Add(Protocol.Constants.openidnp.dh_server_public, CryptUtil.UnsignedToBase64(_dh.CreateKeyExchange()));

+			nvc.Add(Protocol.Constants.enc_mac_key, CryptUtil.ToBase64String(mac_key));

 

 			return nvc;

 		}

diff --git a/src/DotNetOpenId/Provider/Request.cs b/src/DotNetOpenId/Provider/Request.cs
index e39fa34..1fe6243 100644
--- a/src/DotNetOpenId/Provider/Request.cs
+++ b/src/DotNetOpenId/Provider/Request.cs
@@ -39,7 +39,7 @@ namespace DotNetOpenId.Provider
 		internal static bool IsOpenIdRequest(IDictionary<string, string> query) {

 			Debug.Assert(query != null);

 			foreach (string key in query.Keys) {

-				if (key.StartsWith(QueryStringArgs.openid.Prefix, StringComparison.OrdinalIgnoreCase)) {

+				if (key.StartsWith(Protocol.Constants.openid.Prefix, StringComparison.OrdinalIgnoreCase)) {

 					return true;

 				}

 			}

@@ -56,7 +56,7 @@ namespace DotNetOpenId.Provider
 		internal static Request CreateRequest(OpenIdProvider provider, IDictionary<string, string> query) {

 			Debug.Assert(query != null);

 			

-			string mode = query[QueryStringArgs.openid.mode];

+			string mode = query[Protocol.Constants.openid.mode];

 			if (string.IsNullOrEmpty(mode)) {

 				throw new OpenIdException("No openid.mode value in query.", query);

 			}

@@ -64,16 +64,16 @@ namespace DotNetOpenId.Provider
 			Request request;

 			try {

 				switch (mode) {

-					case QueryStringArgs.Modes.checkid_setup:

+					case Protocol.Constants.Modes.checkid_setup:

 						request = new CheckIdRequest(provider);

 						break;

-					case QueryStringArgs.Modes.checkid_immediate:

+					case Protocol.Constants.Modes.checkid_immediate:

 						request = new CheckIdRequest(provider);

 						break;

-					case QueryStringArgs.Modes.check_authentication:

+					case Protocol.Constants.Modes.check_authentication:

 						request = new CheckAuthRequest(provider);

 						break;

-					case QueryStringArgs.Modes.associate:

+					case Protocol.Constants.Modes.associate:

 						request = new AssociateRequest(provider);

 						break;

 					default:

diff --git a/src/DotNetOpenId/Provider/Signatory.cs b/src/DotNetOpenId/Provider/Signatory.cs
index 5e45f3b..610f1c5 100644
--- a/src/DotNetOpenId/Provider/Signatory.cs
+++ b/src/DotNetOpenId/Provider/Signatory.cs
@@ -49,7 +49,7 @@ namespace DotNetOpenId.Provider {
 						Trace.TraceInformation("No associaton found with assoc_handle. Setting invalidate_handle and creating new Association.");

 					}

 

-					response.Fields[QueryStringArgs.openidnp.invalidate_handle] = assoc_handle;

+					response.Fields[Protocol.Constants.openidnp.invalidate_handle] = assoc_handle;

 					assoc = CreateAssociation(AssociationRelyingPartyType.Dumb);

 				}

 			} else {

@@ -59,10 +59,10 @@ namespace DotNetOpenId.Provider {
 				}

 			}

 

-			response.Fields[QueryStringArgs.openidnp.assoc_handle] = assoc.Handle;

+			response.Fields[Protocol.Constants.openidnp.assoc_handle] = assoc.Handle;

 

-			response.Fields[QueryStringArgs.openidnp.signed] = String.Join(",", response.Signed.ToArray());

-			response.Fields[QueryStringArgs.openidnp.sig] =

+			response.Fields[Protocol.Constants.openidnp.signed] = String.Join(",", response.Signed.ToArray());

+			response.Fields[Protocol.Constants.openidnp.sig] =

 				CryptUtil.ToBase64String(assoc.Sign(response.Fields, response.Signed, string.Empty));

 

 			if (TraceUtil.Switch.TraceInfo) {

@@ -153,7 +153,7 @@ namespace DotNetOpenId.Provider {
 

 

 			if (assoc_handle == null)

-				throw new ArgumentNullException(QueryStringArgs.openidnp.assoc_handle);

+				throw new ArgumentNullException(Protocol.Constants.openidnp.assoc_handle);

 

 			Association assoc = store.GetAssociation(associationType, assoc_handle);

 			if (assoc == null || assoc.IsExpired) {

diff --git a/src/DotNetOpenId/RelyingParty/AssociateRequest.cs b/src/DotNetOpenId/RelyingParty/AssociateRequest.cs
index f0e32a9..ded84cc 100644
--- a/src/DotNetOpenId/RelyingParty/AssociateRequest.cs
+++ b/src/DotNetOpenId/RelyingParty/AssociateRequest.cs
@@ -18,15 +18,15 @@ namespace DotNetOpenId.RelyingParty {
 

 			bool useSha256 = provider.ProviderVersion.Major >= 2;

 

-			args.Add(QueryStringArgs.openid.mode, QueryStringArgs.Modes.associate);

-			args.Add(QueryStringArgs.openid.assoc_type, useSha256 ?

-				QueryStringArgs.SignatureAlgorithms.HMAC_SHA256 :

-				QueryStringArgs.SignatureAlgorithms.HMAC_SHA1);

+			args.Add(Protocol.Constants.openid.mode, Protocol.Constants.Modes.associate);

+			args.Add(Protocol.Constants.openid.assoc_type, useSha256 ?

+				Protocol.Constants.SignatureAlgorithms.HMAC_SHA256 :

+				Protocol.Constants.SignatureAlgorithms.HMAC_SHA1);

 

 			DiffieHellman dh = null;

 

 			if (provider.ProviderEndpoint.Scheme == Uri.UriSchemeHttps) {

-				args.Add(QueryStringArgs.openid.session_type, QueryStringArgs.SessionType.NoEncryption20);

+				args.Add(Protocol.Constants.openid.session_type, Protocol.Constants.SessionType.NoEncryption20);

 			} else {

 				// Initiate Diffie-Hellman Exchange

 				dh = CryptUtil.CreateDiffieHellman();

@@ -34,16 +34,16 @@ namespace DotNetOpenId.RelyingParty {
 				byte[] dhPublic = dh.CreateKeyExchange();

 				string cpub = CryptUtil.UnsignedToBase64(dhPublic);

 

-				args.Add(QueryStringArgs.openid.session_type, useSha256 ?

-					QueryStringArgs.SessionType.DH_SHA256 :

-					QueryStringArgs.SessionType.DH_SHA1);

-				args.Add(QueryStringArgs.openid.dh_consumer_public, cpub);

+				args.Add(Protocol.Constants.openid.session_type, useSha256 ?

+					Protocol.Constants.SessionType.DH_SHA256 :

+					Protocol.Constants.SessionType.DH_SHA1);

+				args.Add(Protocol.Constants.openid.dh_consumer_public, cpub);

 

 				DHParameters dhps = dh.ExportParameters(true);

 

 				if (dhps.P != CryptUtil.DEFAULT_MOD || dhps.G != CryptUtil.DEFAULT_GEN) {

-					args.Add(QueryStringArgs.openid.dh_modulus, CryptUtil.UnsignedToBase64(dhps.P));

-					args.Add(QueryStringArgs.openid.dh_gen, CryptUtil.UnsignedToBase64(dhps.G));

+					args.Add(Protocol.Constants.openid.dh_modulus, CryptUtil.UnsignedToBase64(dhps.P));

+					args.Add(Protocol.Constants.openid.dh_gen, CryptUtil.UnsignedToBase64(dhps.G));

 				}

 			}

 

diff --git a/src/DotNetOpenId/RelyingParty/AssociateResponse.cs b/src/DotNetOpenId/RelyingParty/AssociateResponse.cs
index 3cf16b0..0d40325 100644
--- a/src/DotNetOpenId/RelyingParty/AssociateResponse.cs
+++ b/src/DotNetOpenId/RelyingParty/AssociateResponse.cs
@@ -34,48 +34,48 @@ namespace DotNetOpenId.RelyingParty {
 						}

 					};

 

-					string assoc_type = getParameter(QueryStringArgs.openidnp.assoc_type);

+					string assoc_type = getParameter(Protocol.Constants.openidnp.assoc_type);

 					switch (assoc_type) {

-						case QueryStringArgs.SignatureAlgorithms.HMAC_SHA256:

-						case QueryStringArgs.SignatureAlgorithms.HMAC_SHA1:

+						case Protocol.Constants.SignatureAlgorithms.HMAC_SHA256:

+						case Protocol.Constants.SignatureAlgorithms.HMAC_SHA1:

 							byte[] secret;

 

 							string session_type;

-							if (!Args.TryGetValue(QueryStringArgs.openidnp.session_type, out session_type) ||

-								session_type == QueryStringArgs.SessionType.NoEncryption11 ||

-								session_type == QueryStringArgs.SessionType.NoEncryption20) {

-								secret = getDecoded(QueryStringArgs.mac_key);

-							} else if (QueryStringArgs.SessionType.DH_SHA1.Equals(session_type, StringComparison.Ordinal)) {

-								byte[] dh_server_public = getDecoded(QueryStringArgs.openidnp.dh_server_public);

-								byte[] enc_mac_key = getDecoded(QueryStringArgs.enc_mac_key);

+							if (!Args.TryGetValue(Protocol.Constants.openidnp.session_type, out session_type) ||

+								session_type == Protocol.Constants.SessionType.NoEncryption11 ||

+								session_type == Protocol.Constants.SessionType.NoEncryption20) {

+								secret = getDecoded(Protocol.Constants.mac_key);

+							} else if (Protocol.Constants.SessionType.DH_SHA1.Equals(session_type, StringComparison.Ordinal)) {

+								byte[] dh_server_public = getDecoded(Protocol.Constants.openidnp.dh_server_public);

+								byte[] enc_mac_key = getDecoded(Protocol.Constants.enc_mac_key);

 								secret = CryptUtil.SHAHashXorSecret(CryptUtil.Sha1, DH, dh_server_public, enc_mac_key);

-							} else if (QueryStringArgs.SessionType.DH_SHA256.Equals(session_type, StringComparison.Ordinal)) {

-								byte[] dh_server_public = getDecoded(QueryStringArgs.openidnp.dh_server_public);

-								byte[] enc_mac_key = getDecoded(QueryStringArgs.enc_mac_key);

+							} else if (Protocol.Constants.SessionType.DH_SHA256.Equals(session_type, StringComparison.Ordinal)) {

+								byte[] dh_server_public = getDecoded(Protocol.Constants.openidnp.dh_server_public);

+								byte[] enc_mac_key = getDecoded(Protocol.Constants.enc_mac_key);

 								secret = CryptUtil.SHAHashXorSecret(CryptUtil.Sha256, DH, dh_server_public, enc_mac_key);

 							} else {

 								throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 									Strings.InvalidOpenIdQueryParameterValue,

-									QueryStringArgs.openid.session_type, session_type));

+									Protocol.Constants.openid.session_type, session_type));

 							}

 

-							string assocHandle = getParameter(QueryStringArgs.openidnp.assoc_handle);

-							TimeSpan expiresIn = new TimeSpan(0, 0, Convert.ToInt32(getParameter(QueryStringArgs.openidnp.expires_in), CultureInfo.CurrentUICulture));

+							string assocHandle = getParameter(Protocol.Constants.openidnp.assoc_handle);

+							TimeSpan expiresIn = new TimeSpan(0, 0, Convert.ToInt32(getParameter(Protocol.Constants.openidnp.expires_in), CultureInfo.CurrentUICulture));

 

-							if (assoc_type == QueryStringArgs.SignatureAlgorithms.HMAC_SHA1) {

+							if (assoc_type == Protocol.Constants.SignatureAlgorithms.HMAC_SHA1) {

 								association = new HmacSha1Association(assocHandle, secret, expiresIn);

-							} else if (assoc_type == QueryStringArgs.SignatureAlgorithms.HMAC_SHA256) {

+							} else if (assoc_type == Protocol.Constants.SignatureAlgorithms.HMAC_SHA256) {

 								association = new HmacSha256Association(assocHandle, secret, expiresIn);

 							} else {

 								throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 									Strings.InvalidOpenIdQueryParameterValue,

-									QueryStringArgs.openid.assoc_type, assoc_type));

+									Protocol.Constants.openid.assoc_type, assoc_type));

 							}

 							break;

 						default:

 							throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 								Strings.InvalidOpenIdQueryParameterValue,

-								QueryStringArgs.openid.assoc_type, assoc_type));

+								Protocol.Constants.openid.assoc_type, assoc_type));

 					}

 				}

 				return association;

diff --git a/src/DotNetOpenId/RelyingParty/AuthenticationRequest.cs b/src/DotNetOpenId/RelyingParty/AuthenticationRequest.cs
index dbae3fd..f18be50 100644
--- a/src/DotNetOpenId/RelyingParty/AuthenticationRequest.cs
+++ b/src/DotNetOpenId/RelyingParty/AuthenticationRequest.cs
@@ -101,20 +101,20 @@ namespace DotNetOpenId.RelyingParty {
 

 				var qsArgs = new Dictionary<string, string>();

 

-				qsArgs.Add(QueryStringArgs.openid.mode, (Mode == AuthenticationRequestMode.Immediate) ?

-					QueryStringArgs.Modes.checkid_immediate : QueryStringArgs.Modes.checkid_setup);

-				qsArgs.Add(QueryStringArgs.openid.identity, endpoint.ProviderLocalIdentifier);

+				qsArgs.Add(Protocol.Constants.openid.mode, (Mode == AuthenticationRequestMode.Immediate) ?

+					Protocol.Constants.Modes.checkid_immediate : Protocol.Constants.Modes.checkid_setup);

+				qsArgs.Add(Protocol.Constants.openid.identity, endpoint.ProviderLocalIdentifier);

 				if (endpoint.ProviderVersion.Major >= 2) {

-					qsArgs.Add(QueryStringArgs.openid.ns, Protocol.v20.QueryDeclaredNamespaceVersion);

-					qsArgs.Add(QueryStringArgs.openid.claimed_id, endpoint.ClaimedIdentifier);

-					qsArgs.Add(QueryStringArgs.openid.realm, Realm.ToString());

+					qsArgs.Add(Protocol.Constants.openid.ns, Protocol.v20.QueryDeclaredNamespaceVersion);

+					qsArgs.Add(Protocol.Constants.openid.claimed_id, endpoint.ClaimedIdentifier);

+					qsArgs.Add(Protocol.Constants.openid.realm, Realm.ToString());

 				} else {

-					qsArgs.Add(QueryStringArgs.openid.trust_root, Realm.ToString());

+					qsArgs.Add(Protocol.Constants.openid.trust_root, Realm.ToString());

 				}

-				qsArgs.Add(QueryStringArgs.openid.return_to, returnToBuilder.ToString());

+				qsArgs.Add(Protocol.Constants.openid.return_to, returnToBuilder.ToString());

 

 				if (this.assoc != null)

-					qsArgs.Add(QueryStringArgs.openid.assoc_handle, this.assoc.Handle); // !!!!

+					qsArgs.Add(Protocol.Constants.openid.assoc_handle, this.assoc.Handle); // !!!!

 

 				UriBuilder redir = new UriBuilder(this.endpoint.ProviderEndpoint);

 

diff --git a/src/DotNetOpenId/RelyingParty/AuthenticationResponse.cs b/src/DotNetOpenId/RelyingParty/AuthenticationResponse.cs
index c42d54a..33aa841 100644
--- a/src/DotNetOpenId/RelyingParty/AuthenticationResponse.cs
+++ b/src/DotNetOpenId/RelyingParty/AuthenticationResponse.cs
@@ -34,9 +34,9 @@ namespace DotNetOpenId.RelyingParty {
 			ClaimedIdentifier = claimedIdentifier;

 			signedArguments = new Dictionary<string, string>();

 			string signed;

-			if (query.TryGetValue(QueryStringArgs.openid.signed, out signed)) {

+			if (query.TryGetValue(Protocol.Constants.openid.signed, out signed)) {

 				foreach (string fieldNoPrefix in signed.Split(',')) {

-					string fieldWithPrefix = QueryStringArgs.openid.Prefix + fieldNoPrefix;

+					string fieldWithPrefix = Protocol.Constants.openid.Prefix + fieldNoPrefix;

 					string val;

 					if (!query.TryGetValue(fieldWithPrefix, out val)) val = string.Empty;

 					signedArguments[fieldWithPrefix] = val;

@@ -61,7 +61,7 @@ namespace DotNetOpenId.RelyingParty {
 		public ExtensionArgumentsManager IncomingExtensions { get; private set; }

 

 		internal Uri ReturnTo {

-			get { return new Uri(signedArguments[QueryStringArgs.openid.return_to]); }

+			get { return new Uri(signedArguments[Protocol.Constants.openid.return_to]); }

 		}

 

 		/// <summary>

@@ -78,32 +78,32 @@ namespace DotNetOpenId.RelyingParty {
 		}

 

 		internal static AuthenticationResponse Parse(IDictionary<string, string> query, IRelyingPartyApplicationStore store) {

-			string mode = Util.GetRequiredArg(query, QueryStringArgs.openid.mode);

+			string mode = Util.GetRequiredArg(query, Protocol.Constants.openid.mode);

 			string tokenString = Util.GetRequiredArg(query, Token.TokenKey);

 			Token token = Token.Deserialize(tokenString, store);

 

 			switch (mode) {

-				case QueryStringArgs.Modes.cancel:

+				case Protocol.Constants.Modes.cancel:

 					return new AuthenticationResponse(AuthenticationStatus.Canceled, token.ClaimedIdentifier, query);

-				case QueryStringArgs.Modes.error:

+				case Protocol.Constants.Modes.error:

 					throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

-						"The provider returned an error: {0}", query[QueryStringArgs.openid.error],

+						"The provider returned an error: {0}", query[Protocol.Constants.openid.error],

 						token.ClaimedIdentifier));

-				case QueryStringArgs.Modes.id_res:

+				case Protocol.Constants.Modes.id_res:

 					return parseIdResResponse(query, token, store);

 				default:

 					throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 						Strings.InvalidOpenIdQueryParameterValue,

-						QueryStringArgs.openid.mode, mode), token.ClaimedIdentifier);

+						Protocol.Constants.openid.mode, mode), token.ClaimedIdentifier);

 			}

 		}

 

 		static AuthenticationResponse parseIdResResponse(IDictionary<string, string> query, Token token, IRelyingPartyApplicationStore store) {

 			string user_setup_url;

-			if (query.TryGetValue(QueryStringArgs.openid.user_setup_url, out user_setup_url))

+			if (query.TryGetValue(Protocol.Constants.openid.user_setup_url, out user_setup_url))

 				return new AuthenticationResponse(AuthenticationStatus.SetupRequired, token.ClaimedIdentifier, query);

 

-			string assoc_handle = Util.GetRequiredArg(query, QueryStringArgs.openid.assoc_handle);

+			string assoc_handle = Util.GetRequiredArg(query, Protocol.Constants.openid.assoc_handle);

 

 			Association assoc = store.GetAssociation(token.ProviderEndpoint, assoc_handle);

 			AuthenticationResponse response;

@@ -135,11 +135,11 @@ namespace DotNetOpenId.RelyingParty {
 		/// </summary>

 		/// <exception cref="OpenIdException">Thrown when the signature is missing or the query has been tampered with.</exception>

 		static void verifyBySignature(IDictionary<string, string> query, Association assoc) {

-			string sig = Util.GetRequiredArg(query, QueryStringArgs.openid.sig);

-			string signed = Util.GetRequiredArg(query, QueryStringArgs.openid.signed);

+			string sig = Util.GetRequiredArg(query, Protocol.Constants.openid.sig);

+			string signed = Util.GetRequiredArg(query, Protocol.Constants.openid.signed);

 			string[] signed_array = signed.Split(',');

 

-			string v_sig = CryptUtil.ToBase64String(assoc.Sign(query, signed_array, QueryStringArgs.openid.Prefix));

+			string v_sig = CryptUtil.ToBase64String(assoc.Sign(query, signed_array, Protocol.Constants.openid.Prefix));

 

 			if (v_sig != sig)

 				throw new OpenIdException(Strings.InvalidSignature);

diff --git a/src/DotNetOpenId/RelyingParty/CheckAuthRequest.cs b/src/DotNetOpenId/RelyingParty/CheckAuthRequest.cs
index 4537483..8c1a47d 100644
--- a/src/DotNetOpenId/RelyingParty/CheckAuthRequest.cs
+++ b/src/DotNetOpenId/RelyingParty/CheckAuthRequest.cs
@@ -9,7 +9,7 @@ namespace DotNetOpenId.RelyingParty {
 		}

 

 		public static CheckAuthRequest Create(Uri provider, IDictionary<string, string> query) {

-			string signed = query[QueryStringArgs.openid.signed];

+			string signed = query[Protocol.Constants.openid.signed];

 

 			if (signed == null)

 				// #XXX: oidutil.log('No signature present; checkAuth aborted')

@@ -17,7 +17,7 @@ namespace DotNetOpenId.RelyingParty {
 

 			// Arguments that are always passed to the server and not

 			// included in the signature.

-			string[] whitelist = new string[] { QueryStringArgs.openidnp.assoc_handle, QueryStringArgs.openidnp.sig, QueryStringArgs.openidnp.signed, QueryStringArgs.openidnp.invalidate_handle };

+			string[] whitelist = new string[] { Protocol.Constants.openidnp.assoc_handle, Protocol.Constants.openidnp.sig, Protocol.Constants.openidnp.signed, Protocol.Constants.openidnp.invalidate_handle };

 			string[] splitted = signed.Split(',');

 

 			// combine the previous 2 arrays (whitelist + splitted) into a new array: signed_array

@@ -28,11 +28,11 @@ namespace DotNetOpenId.RelyingParty {
 			var check_args = new Dictionary<string, string>();

 

 			foreach (string key in query.Keys) {

-				if (key.StartsWith(QueryStringArgs.openid.Prefix, StringComparison.OrdinalIgnoreCase)

-					&& Array.IndexOf(signed_array, key.Substring(QueryStringArgs.openid.Prefix.Length)) > -1)

+				if (key.StartsWith(Protocol.Constants.openid.Prefix, StringComparison.OrdinalIgnoreCase)

+					&& Array.IndexOf(signed_array, key.Substring(Protocol.Constants.openid.Prefix.Length)) > -1)

 					check_args[key] = query[key];

 			}

-			check_args[QueryStringArgs.openid.mode] = QueryStringArgs.Modes.check_authentication;

+			check_args[Protocol.Constants.openid.mode] = Protocol.Constants.Modes.check_authentication;

 

 			return new CheckAuthRequest(provider, check_args);

 		}

diff --git a/src/DotNetOpenId/RelyingParty/CheckAuthResponse.cs b/src/DotNetOpenId/RelyingParty/CheckAuthResponse.cs
index cf67854..a7373a4 100644
--- a/src/DotNetOpenId/RelyingParty/CheckAuthResponse.cs
+++ b/src/DotNetOpenId/RelyingParty/CheckAuthResponse.cs
@@ -12,7 +12,7 @@ namespace DotNetOpenId.RelyingParty {
 			get {

 				string invalidateHandle = null;

 				if (IsAuthenticationValid) {

-					Args.TryGetValue(QueryStringArgs.openidnp.invalidate_handle, out invalidateHandle);

+					Args.TryGetValue(Protocol.Constants.openidnp.invalidate_handle, out invalidateHandle);

 				}

 				return invalidateHandle;

 			}

@@ -21,8 +21,8 @@ namespace DotNetOpenId.RelyingParty {
 		public bool IsAuthenticationValid {

 			get {

 				string is_valid;

-				Args.TryGetValue(QueryStringArgs.openidnp.is_valid, out is_valid);

-				return QueryStringArgs.IsValid.True.Equals(is_valid, StringComparison.OrdinalIgnoreCase);

+				Args.TryGetValue(Protocol.Constants.openidnp.is_valid, out is_valid);

+				return Protocol.Constants.IsValid.True.Equals(is_valid, StringComparison.OrdinalIgnoreCase);

 			}

 		}

 	}

diff --git a/src/DotNetOpenId/RelyingParty/DirectRequest.cs b/src/DotNetOpenId/RelyingParty/DirectRequest.cs
index 6bea9e7..554061b 100644
--- a/src/DotNetOpenId/RelyingParty/DirectRequest.cs
+++ b/src/DotNetOpenId/RelyingParty/DirectRequest.cs
@@ -12,8 +12,8 @@ namespace DotNetOpenId.RelyingParty {
 			if (args == null) throw new ArgumentNullException("args");

 			Provider = provider;

 			Args = args;

-			if (!Args.ContainsKey(QueryStringArgs.openid.ns))

-				Args.Add(QueryStringArgs.openid.ns, Protocol.v20.QueryDeclaredNamespaceVersion);

+			if (!Args.ContainsKey(Protocol.Constants.openid.ns))

+				Args.Add(Protocol.Constants.openid.ns, Protocol.v20.QueryDeclaredNamespaceVersion);

 		}

 		protected Uri Provider { get; private set; }

 		protected IDictionary<string, string> Args { get; private set; }

@@ -34,9 +34,9 @@ namespace DotNetOpenId.RelyingParty {
 			// All error codes are supposed to be returned with 400, but

 			// some (like myopenid.com) sometimes send errors as 200's.

 			if (resp.StatusCode == HttpStatusCode.BadRequest ||

-				(args.TryGetValue(QueryStringArgs.openidnp.mode, out mode) && mode == QueryStringArgs.Modes.error)) {

+				(args.TryGetValue(Protocol.Constants.openidnp.mode, out mode) && mode == Protocol.Constants.Modes.error)) {

 				string providerMessage;

-				args.TryGetValue(QueryStringArgs.openidnp.error, out providerMessage);

+				args.TryGetValue(Protocol.Constants.openidnp.error, out providerMessage);

 				throw new OpenIdException(string.Format(CultureInfo.CurrentUICulture,

 					Strings.ProviderRespondedWithError, providerMessage), args);

 			} else if (resp.StatusCode == HttpStatusCode.OK) {

diff --git a/src/DotNetOpenId/RelyingParty/DirectResponse.cs b/src/DotNetOpenId/RelyingParty/DirectResponse.cs
index 6619079..f1583ec 100644
--- a/src/DotNetOpenId/RelyingParty/DirectResponse.cs
+++ b/src/DotNetOpenId/RelyingParty/DirectResponse.cs
@@ -12,11 +12,11 @@ namespace DotNetOpenId.RelyingParty {
 			Args = args;

 

 			if (TraceUtil.Switch.TraceInfo) {

-				if (!Args.ContainsKey(QueryStringArgs.openidnp.ns)) {

-					Trace.TraceInformation("Direct response from provider lacked the {0} key.", QueryStringArgs.openid.ns);

-				} else if (Args[QueryStringArgs.openidnp.ns] != Protocol.v20.QueryDeclaredNamespaceVersion) {

+				if (!Args.ContainsKey(Protocol.Constants.openidnp.ns)) {

+					Trace.TraceInformation("Direct response from provider lacked the {0} key.", Protocol.Constants.openid.ns);

+				} else if (Args[Protocol.Constants.openidnp.ns] != Protocol.v20.QueryDeclaredNamespaceVersion) {

 					Trace.TraceInformation("Direct response from provider for key {0} was '{1}' rather than '{2}'.",

-						QueryStringArgs.openid.ns, Args[QueryStringArgs.openidnp.ns], Protocol.v20.QueryDeclaredNamespaceVersion);

+						Protocol.Constants.openid.ns, Args[Protocol.Constants.openidnp.ns], Protocol.v20.QueryDeclaredNamespaceVersion);

 				}

 			}

 

diff --git a/src/DotNetOpenId/RelyingParty/OpenIdRelyingParty.cs b/src/DotNetOpenId/RelyingParty/OpenIdRelyingParty.cs
index bce8214..0c1fea9 100644
--- a/src/DotNetOpenId/RelyingParty/OpenIdRelyingParty.cs
+++ b/src/DotNetOpenId/RelyingParty/OpenIdRelyingParty.cs
@@ -81,7 +81,7 @@ namespace DotNetOpenId.RelyingParty {
 			returnTo.Query = string.Empty;

 			var returnToParams = new Dictionary<string, string>(HttpContext.Current.Request.QueryString.Count);

 			foreach (string key in HttpContext.Current.Request.QueryString) {

-				if (!key.StartsWith(QueryStringArgs.openid.Prefix, StringComparison.OrdinalIgnoreCase) 

+				if (!key.StartsWith(Protocol.Constants.openid.Prefix, StringComparison.OrdinalIgnoreCase) 

 					&& key != Token.TokenKey) {

 					returnToParams.Add(key, HttpContext.Current.Request.QueryString[key]);

 				}

@@ -110,7 +110,7 @@ namespace DotNetOpenId.RelyingParty {
 		/// </summary>

 		bool isAuthenticationResponseReady {

 			get {

-				if (!query.ContainsKey(QueryStringArgs.openid.mode))

+				if (!query.ContainsKey(Protocol.Constants.openid.mode))

 					return false;

 

 				if (HttpContext.Current != null && !HttpContext.Current.Request.RequestType.Equals("GET", StringComparison.Ordinal))