@redzone/taunt-logins 0.0.3 → 0.0.5

package/dist/es/index.js

@@ -0,0 +1,760 @@
+import { OAuthExtension } from '@magic-ext/oauth2';
+import { Magic } from 'magic-sdk';
+import axios from 'axios';
+
+// From RFC 2616
+// 1xx: Informational - Request received, continuing process
+// 2xx: Success - The action was successfully received, understood, and accepted
+// 3xx: Redirection - Further action must be taken in order to complete the request
+// 4xx: Client Error - The request contains bad syntax or cannot be fulfilled
+// 5xx: Server Error - The server failed to fulfill an apparently valid request
+// HTTP status codes are extensible. HTTP applications are not required to understand the meaning of all registered status codes,
+// though such understanding is obviously desirable. However, applications MUST understand the class of any status code,
+// as indicated by the first digit, and treat any unrecognized response as being equivalent to the x00 status code of that class,
+// with the exception that an unrecognized response MUST NOT be cached. For example, if an unrecognized status code of 431 is received
+// by the client, it can safely assume that there was something wrong with its request and treat the response as if it had
+// received a 400 status code.
+// 400 Bad Request - The request could not be understood by the server due to malformed syntax. The client SHOULD NOT repeat the request without modifications.
+// 401 Unauthorized - The request requires user authentication. The response MUST include a WWW-Authenticate header field (section 14.47) containing a challenge applicable to the requested resource. The client MAY repeat the request with a suitable Authorization header field (section 14.8). If the request already included Authorization credentials, then the 401 response indicates that authorization has been refused for those credentials. If the401 response contains the same challenge as the prior response, it SHOULD be resent again. HTTP access authentication is explained in "HTTP Authentication: Basic and Digest Access Authentication" (http://www.ietf.org/rfc/rfc2617.txt).
+// 402 Payment Required - Payment required.
+// 403 Forbidden - The server understood the request, but is refusing to fulfill it. Authorization will not help and the request SHOULD NOT be repeated.
+// 404 Not Found - The server has not found anything matching the Request-URI. No indication is given of whether the condition is temporary or permanent. The 410 (Gone) status code SHOULD be used if the server knows, through some internally configurable mechanism, that an old resource is permanently unavailable and has no forwarding address. This status code is commonly used when the server does not wish to reveal exactly why the request has been refused, or when the server is unwilling to return a 401 Unauthorized response for Authentication reasons.
+// 405 Method Not Allowed - The method specified in the Request-Line is not allowed for the resource identified by the Request-URI. The response MUST include an Allow header containing a list of valid methods for the requested resource.
+// 406 Not Acceptable - The resource identified by the request is only capable of generating response entities which have content characteristics not acceptable according to the accept headers sent in the request.
+// 407 Proxy Authentication Required - The client must first authenticate itself with the proxy.
+// 408 Request Timeout - The server timed out waiting for the request. According to W3 HTTP specifications: "The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time."
+// 409 Conflict - The request could not be completed due to a conflict with the current state of the resource.
+// 410 Gone - The requested resource is no longer available at the server and no forwarding address is known. This condition is expected to be considered permanent. Clients with link editing capabilities SHOULD delete references to the Request-URI after user approval. If the server does not know, or has no facility to determine, whether or not the condition is permanent, the status code 404 (Not Found) SHOULD be used instead. This response is cacheable unless indicated otherwise.
+// 411 Length Required - The server refuses to accept the request without a defined Content-Length. The client MAY repeat the request if it adds a valid Content-Length header field containing the length of the message-body in the request message.
+// 412 Precondition Failed - The precondition given in one or more of the request-header fields evaluated to false when it was tested on the server.
+// 413 Request Entity Too Large - The server is refusing to process a request because the request entity is larger than the server is willing or able to process.
+// 414 Request-URI Too Long - The server is refusing to service the request because the Request-URI is longer than the server is willing to interpret.
+// 415 Unsupported Media Type - The server is refusing to service the request because the entity of the request is in a format not supported by the requested resource for the requested method.
+// 416 Requested Range Not Satisfiable - The server cannot meet the requirements of the Range header field in the request.
+// 417 Expectation Failed - The server could not meet the requirements of the Expect header field in the request.
+// 418 I'm a teapot - This code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324, Hyper Text Coffee Pot Control Protocol, and is not expected to be implemented by actual HTTP servers. The RFC specifies this code should be returned by teapots requested to brew coffee.
+// 419 Authentication Timeout - The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time.
+// 420 Method Failure - The method specified in the Request-Line is not allowed for the resource identified by the Request-URI. The response MUST include an Allow header containing a list of valid methods for the requested resource.
+// 421 Misdirected Request - The request was directed at a server that is not able to produce a response. This can be sent by a server that is not configured to produce responses for the combination of scheme and authority that are included in the request URI.
+// 422 Unprocessable Entity - The request was well-formed but was unable to be followed due to semantic errors.
+// 423 Locked - The resource that is being accessed is locked.
+// 424 Failed Dependency - The request failed due to failure of a previous request (e.g., a PROPPATCH).
+// 425 Unordered Collection - The server is unwilling to process the request because either an individual header field, or all the header fields collectively, are too large.
+// 426 Upgrade Required - The server refuses to perform the request using the current protocol but might be willing to do so after the client upgrades to a different protocol. The server MUST specify an Upgrade header field in a 426 response containing a list of the required upgrade methods.
+// 428 Precondition Required - The origin server requires the request to be conditional. Intended to prevent the 'lost update' problem, where a client GETs a resource's state, modifies it, and PUTs it back to the server, when meanwhile a third party has modified the state on the server, leading to a conflict.
+// 429 Too Many Requests - The user has sent too many requests in a given amount of time. Intended for use with rate-limiting schemes.
+// 432-450 Unassigned
+// 450 Blocked by Windows Parental Controls - Microsoft's Internet Explorer 4.0 does not support the HTTP protocol, and therefore cannot understand the requests for the Windows Parental Controls page.
+// 451 Unavailable For Legal Reasons - The server is denying access to the resource as a consequence of a legal demand.
+// 452-499 Unassigned
+// 500 Internal Server Error - The server encountered an unexpected condition that prevented it from fulfilling the request.
+// 501 Not Implemented - The server does not support the functionality required to fulfill the request. This is the appropriate response when the server does not recognize the request method and is not capable of supporting it for any resource.
+// 502 Bad Gateway - The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request.
+// 503 Service Unavailable - The server is currently unable to handle the request due to a temporary overloading or maintenance of the server. The implication is that this is a temporary condition which will be alleviated after some delay. If known, the length of the delay MAY be indicated in a Retry-After header. If no Retry-After is given, the client SHOULD handle the response as it would for a 500 response.
+// 504 Gateway Timeout - The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URI (e.g. HTTP, FTP, LDAP) or some other auxiliary server (e.g. DNS) it needed to access in attempting to complete the request.
+// 505 HTTP Version Not Supported - The server does not support, or refuses to support, the HTTP protocol version that was used in the request message. The server is indicating that it is unable or unwilling to complete the request using the same major version as the client, as described in section 3.1, other than with this error message. The response SHOULD contain an entity describing why that version is not supported and what other protocols are supported by that server.
+// 506 Variant Also Negotiates - The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process.
+// 507 Insufficient Storage - The server is unable to store the representation needed to complete the request.
+// 508 Loop Detected - The server detected an infinite loop while processing the request.
+// 509 Bandwidth Limit Exceeded - This status code, while used by the HTTP transport, is not specified in any RFCs.
+// 510 Not Extended - Further extensions to the request are required for the server to fulfill it.
+// 511 Network Authentication Required - The client needs to authenticate to gain network access.
+class ErrorResponse {
+    constructor(message, summary = "", explanation = "", status = 0){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class BadRequestError {
+    constructor(message, summary = "Bad Request", explanation = "The request could not be understood by the server due to malformed syntax. The client SHOULD NOT repeat the request without modifications.", status = 400){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class UnauthorizedError {
+    constructor(message, summary = "Unauthorized", explanation = "The request requires user authentication.", status = 401){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class PaymentRequiredError {
+    constructor(message, summary = "Payment Required", explanation = "Payment required.", status = 402){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class ForbiddenError {
+    constructor(message, summary = "Forbidden", explanation = "The server understood the request, but is refusing to fulfill it.", status = 403){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class NotFoundError {
+    constructor(message, summary = "Not Found", explanation = "The server has not found anything matching the Request-URI.", status = 404){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class MethodNotAllowedError {
+    constructor(message, summary = "Method Not Allowed", explanation = "The method specified in the Request-Line is not allowed for the resource identified by the Request-URI.", status = 405){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class NotAcceptableError {
+    constructor(message, summary = "Not Acceptable", explanation = "The server can only generate a response that is not accepted by the client.", status = 406){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class ProxyAuthenticationRequiredError {
+    constructor(message, summary = "Proxy Authentication Required", explanation = "The client must first authenticate itself with the proxy.", status = 407){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class RequestTimeoutError {
+    constructor(message, summary = "Request Timeout", explanation = "The server did not receive a complete request message within the time that it was prepared to wait.", status = 408){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class ConflictError {
+    constructor(message, summary = "Conflict", explanation = "The request could not be completed due to a conflict with the current state of the resource.", status = 409){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class GoneError {
+    constructor(message, summary = "Gone", explanation = "The requested resource is no longer available at the server and no forwarding address is known.", status = 410){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class LengthRequiredError {
+    constructor(message, summary = "Length Required", explanation = "The server refuses to accept the request without a defined Content-Length.", status = 411){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class PreconditionFailedError {
+    constructor(message, summary = "Precondition Failed", explanation = "The precondition given in one or more of the request-header fields evaluated to false when it was tested on the server.", status = 412){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class RequestEntityTooLargeError {
+    constructor(message, summary = "Request Entity Too Large", explanation = "The server is refusing to process a request because the request entity is larger than the server is willing or able to process.", status = 413){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class RequestUriTooLongError {
+    constructor(message, summary = "Request-URI Too Long", explanation = "The server is refusing to service the request because the request-URI is longer than the server is willing to interpret.", status = 414){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class UnsupportedMediaTypeError {
+    constructor(message, summary = "Unsupported Media Type", explanation = "The server is refusing to service the request because the entity of the request is in a format not supported by the requested resource for the requested method.", status = 415){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class RequestedRangeNotSatisfiableError {
+    constructor(message, summary = "Requested Range Not Satisfiable", explanation = "The server cannot supply the requested range.", status = 416){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class ExpectationFailedError {
+    constructor(message, summary = "Expectation Failed", explanation = "The server cannot meet the requirements of the Expect request-header field.", status = 417){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class ImATeapotError {
+    constructor(message, summary = "I'm a teapot", explanation = "The server should return this if it is a teapot.", status = 418){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class UnprocessableEntityError {
+    constructor(message, summary = "Unprocessable Entity", explanation = "The request was well-formed but was unable to be followed due to semantic errors.", status = 422){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class LockedError {
+    constructor(message, summary = "Locked", explanation = "The resource that is being accessed is locked.", status = 423){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class FailedDependencyError {
+    constructor(message, summary = "Failed Dependency", explanation = "The request failed due to failure of a previous request.", status = 424){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class UpgradeRequiredError {
+    constructor(message, summary = "Upgrade Required", explanation = "The client should switch to a different protocol.", status = 426){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class PreconditionRequiredError {
+    constructor(message, summary = "Precondition Required", explanation = "The origin server requires the request to be conditional.", status = 428){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class TooManyRequestsError {
+    constructor(message, summary = "Too Many Requests", explanation = "The user has sent too many requests in a given amount of time.", status = 429){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class RequestHeaderFieldsTooLargeError {
+    constructor(message, summary = "Request Header Fields Too Large", explanation = "The server is unwilling to process the request because either an individual header field, or all the header fields collectively, are too large.", status = 431){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class InternalServerError {
+    constructor(message, summary = "Internal Server Error", explanation = "The server encountered an unexpected condition which prevented it from fulfilling the request.", status = 500){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class NotImplementedError {
+    constructor(message, summary = "Not Implemented", explanation = "The server does not support the functionality required to fulfill the request.", status = 501){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class BadGatewayError {
+    constructor(message, summary = "Bad Gateway", explanation = "The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request.", status = 502){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class ServiceUnavailableError {
+    constructor(message, summary = "Service Unavailable", explanation = "The server is currently unable to handle the request due to a temporary overloading or maintenance of the server.", status = 503){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class GatewayTimeoutError {
+    constructor(message, summary = "Gateway Timeout", explanation = "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URI (e.g. HTTP, FTP, LDAP) or some other auxiliary server (e.g. DNS) it needed to access in attempting to complete the request.", status = 504){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class HTTPVersionNotSupportedError {
+    constructor(message, summary = "HTTP Version Not Supported", explanation = "The server does not support, or refuses to support, the HTTP protocol version that was used in the request message.", status = 505){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class VariantAlsoNegotiatesError {
+    constructor(message, summary = "Variant Also Negotiates", explanation = "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process.", status = 506){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class InsufficientStorageError {
+    constructor(message, summary = "Insufficient Storage", explanation = "The server is unable to store the representation needed to complete the request.", status = 507){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class LoopDetectedError {
+    constructor(message, summary = "Loop Detected", explanation = "The server detected an infinite loop while processing the request.", status = 508){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class BandwidthLimitExceededError {
+    constructor(message, summary = "Bandwidth Limit Exceeded", explanation = "The server has exceeded the bandwidth specified by the server administrator; this is often used by shared hosting providers to limit the bandwidth of customers.", status = 509){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class NotExtendedError {
+    constructor(message, summary = "Not Extended", explanation = "Further extensions to the request are required for the server to fulfill it.", status = 510){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class NetworkAuthenticationRequiredError {
+    constructor(message, summary = "Network Authentication Required", explanation = "The client needs to authenticate to gain network access.", status = 511){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+class UnknownError {
+    constructor(message, summary = "Unknown Error", explanation = "", status = 0){
+        this.message = message;
+        this.summary = summary;
+        this.explanation = explanation;
+        this.status = status;
+    }
+}
+function ErrorFromResponse(response) {
+    const message = response.data.message ?? "";
+    switch(response.status){
+        case 400:
+            return new BadRequestError(message);
+        case 401:
+            return new UnauthorizedError(message);
+        case 402:
+            return new PaymentRequiredError(message);
+        case 403:
+            return new ForbiddenError(message);
+        case 404:
+            return new NotFoundError(message);
+        case 405:
+            return new MethodNotAllowedError(message);
+        case 406:
+            return new NotAcceptableError(message);
+        case 407:
+            return new ProxyAuthenticationRequiredError(message);
+        case 408:
+            return new RequestTimeoutError(message);
+        case 409:
+            return new ConflictError(message);
+        case 410:
+            return new GoneError(message);
+        case 411:
+            return new LengthRequiredError(message);
+        case 412:
+            return new PreconditionFailedError(message);
+        case 413:
+            return new RequestEntityTooLargeError(message);
+        case 414:
+            return new RequestUriTooLongError(message);
+        case 415:
+            return new UnsupportedMediaTypeError(message);
+        case 417:
+            return new ExpectationFailedError(message);
+        case 418:
+            return new ImATeapotError(message);
+        case 422:
+            return new UnprocessableEntityError(message);
+        case 423:
+            return new LockedError(message);
+        case 424:
+            return new FailedDependencyError(message);
+        case 426:
+            return new UpgradeRequiredError(message);
+        case 428:
+            return new PreconditionRequiredError(message);
+        case 429:
+            return new TooManyRequestsError(message);
+        case 431:
+            return new RequestHeaderFieldsTooLargeError(message);
+        case 500:
+            return new InternalServerError(message);
+        case 501:
+            return new NotImplementedError(message);
+        case 502:
+            return new BadGatewayError(message);
+        case 503:
+            return new ServiceUnavailableError(message);
+        case 504:
+            return new GatewayTimeoutError(message);
+        case 505:
+            return new HTTPVersionNotSupportedError(message);
+        case 506:
+            return new VariantAlsoNegotiatesError(message);
+        case 507:
+            return new InsufficientStorageError(message);
+        case 508:
+            return new LoopDetectedError(message);
+        case 509:
+            return new BandwidthLimitExceededError(message);
+        case 510:
+            return new NotExtendedError(message);
+        case 511:
+            return new NetworkAuthenticationRequiredError(message);
+        default:
+            return new UnknownError(message, "Unknown Error", "An unknown error has occurred.");
+    }
+}
+
+class TauntApi {
+    async stdPGET(method, url, body, headers = {}) {
+        const response = await this.api.request({
+            url,
+            method,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                ...headers
+            },
+            data: body ? JSON.stringify(body) : null
+        });
+        const data = response.data;
+        if (data.refreshToken) {
+            this.refreshToken = data.refreshToken;
+        }
+        return data;
+    }
+    async post(url, body = {}, headers = {}) {
+        return this.stdPGET("POST", url, body, headers);
+    }
+    async get(url, headers = {}) {
+        return this.stdPGET("GET", url, undefined, headers);
+    }
+    // this.user = data
+    // localStorage.setItem("user", JSON.stringify(data))
+    // localStorage.setItem(
+    //   "name",
+    //   this.user.email ? this.user.email.split("@")[0] : this.user.ethAddress
+    // )
+    // await this.getCToken()
+    // this.setRefId(this.router.currentRoute.value.query['ref_id'])
+    // const nftStore = useNftStore()
+    // nftStore.fetchAll()
+    //   return data as TauntUser
+    // }
+    // async loginPlayFabPlayer() {}
+    /*async loginPlayFabPlayer() {
+      try {
+        // Get the user's playfab id from taunt api
+        let id = null;
+        if (!this.user && !this.user?.id) {
+          id = this.getPlayfabAnonId()
+          if (!id) {
+            const { data: playFabResponse } = await this.api.get('/v1/auth/playfab', {})
+            id = playFabResponse.playFabId
+            this.setAnonPlayfabUserId(playFabResponse.playFabId);
+          }
+        } else {
+          const { data: playFabResponse } = await this.api.get('/v1/auth/playfab', {})
+          id = playFabResponse.playFabId
+        }
+        // Login with playfab via the unique id from taunt api
+        const { data: playFabLoginResults } = await Axios.post(loginEndpoint, {
+          CustomId: id,
+          CreateAccount: true,
+          titleId: playFabTitleId,
+        })
+        const playFabSession = JSON.stringify(playFabLoginResults.data)
+        this.setPlayFabSession(playFabSession)
+      }
+      catch (error) {
+        const err = error as AxiosError
+        if (err?.response) {
+          console.log(err.response.status, err.response.data)
+        }
+        else {
+          console.log(error)
+        }
+      }
+    }*/ //   async getCToken() {
+    //     try {
+    //       const url = "v1/claimr/token"
+    //       const { data } = await this.api.get<{ data: { token: string } }>(`${url}`)
+    //       this.claimrToken = data.data.token
+    //       this.setClaimrToken(this.claimrToken)
+    //     } catch (e) {
+    //       console.error(e)
+    //     }
+    //   }
+    //   setLastWalletConnection(lastWalletConnection: string) {
+    //     localStorage.setItem("lastWalletConnection", lastWalletConnection)
+    //   }
+    //   setRefId(ref = "") {
+    //     this.refId = ref
+    //   }
+    //   clearLocalAuthStorage() {
+    //     localStorage.removeItem("user")
+    //     localStorage.removeItem("refreshToken")
+    //     localStorage.removeItem("playFabSession")
+    //     this.user = null
+    //   }
+    //   setAccessToken(accessToken: string) {
+    //     localStorage.setItem("accessToken", accessToken)
+    //   }
+    //   setRefreshToken(refreshToken: string) {
+    //     localStorage.setItem("refreshToken", refreshToken)
+    //   }
+    //   setIsFirsTimeLogin(isFirstTimeLogin: string) {
+    //     localStorage.setItem("isFirstTimeLogin", isFirstTimeLogin)
+    //   }
+    //   setPlayFabSession(playFabSession: string) {
+    //     localStorage.setItem("playFabSession", playFabSession)
+    //   }
+    //   setAnonPlayfabUserId(id: string) {
+    //     localStorage.setItem("playfabAnonId", id)
+    //   }
+    //   setClaimrToken(token: string) {
+    //     localStorage.setItem("ctoken", token)
+    //   }
+    //   getAccessToken() {
+    //     return localStorage.getItem("accessToken")
+    //   }
+    //   getRefreshToken() {
+    //     return localStorage.getItem("refreshToken")
+    //   }
+    //   getPlayfabAnonId() {
+    //     return localStorage.getItem("playfabAnonId")
+    //   }
+    // Write a playfab event. retryfIfLoginNeeded should not be set by caller. It's used for stopping recursive calls when login is needed.
+    // If login is needed, for example, if the web browser has been open longer than playfab session timeout, we'll try to login again at most
+    // one time. Then we'll retry the event.
+    async writePlayerEvent(eventName, eventData = null, retryIfLoginNeeded = true) {
+        console.log("writePlayerEvent", {
+            eventName,
+            eventData,
+            retryIfLoginNeeded
+        });
+        return Promise.resolve();
+    }
+    constructor(endpoint){
+        this.refreshToken = null;
+        this.claimrToken = null;
+        this.onError = async (error)=>{
+            const originalRequest = error.config;
+            if (error.response.status === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                console.log("401 - refreshing token");
+                try {
+                    const data = await this.refresh();
+                    return this.api(originalRequest);
+                } catch (error) {
+                    console.log("Unable to refresh access token, please log in");
+                    this.refreshToken = null;
+                    window.location.href = "/";
+                    return Promise.reject(error);
+                }
+            }
+            return Promise.reject(ErrorFromResponse(error.response));
+        };
+        this.nonceLogin = (walletAddress, clientNonce)=>this.post("/v1/auth/nonce/login", {
+                walletAddress,
+                clientNonce
+            });
+        this.loginWithMagicDid = (did)=>this.post("/v1/auth/login/did", {
+                did
+            });
+        this.loginWithWeb3WalletSignature = (props)=>this.post("/v1/auth/login/signature", props);
+        this.loginExtWithWeb3WalletSignature = (props)=>this.post("/v1/auth/login/ext-signature", props);
+        this.refresh = (refreshToken)=>this.post(`/v1/auth/token/refresh`, {
+                token: refreshToken || this.refreshToken
+            });
+        // Logout of the backend with access token. Assumes user is currently logged in and has a cookie with the access token
+        this.logout = async ()=>{
+            // If logging out fails on the backend we'll still remove the user info
+            await this.api.post("/v1/auth/logout");
+            await this.writePlayerEvent("player_logged_out");
+        };
+        this.getClaimrToken = async ()=>{
+            if (!this.claimrToken) {
+                const url = "v1/claimr/token";
+                const { data } = await this.api.get(`${url}`);
+                this.claimrToken = data.data.token;
+            }
+            return this.claimrToken;
+        };
+        // Use the cookie stored in the browser to get the user and save user model in state and local storage
+        // This assumes that the user is logged to backend in and has a cookie jwt
+        this.getLoggedInUser = ()=>this.api.get("/v1/auth/me");
+        this.api = axios.create({
+            baseURL: `${endpoint}`,
+            withCredentials: true
+        });
+        // Response interceptor for API calls
+        this.api.interceptors.response.use((response)=>response, (error)=>this.onError(error));
+    }
+}
+
+const customNodeOptions = {
+    rpcUrl: "https://polygon-rpc.com",
+    chainId: 137
+};
+const getMagic = (magicKey)=>new Magic(magicKey, {
+        network: customNodeOptions,
+        extensions: [
+            new OAuthExtension()
+        ]
+    });
+function emailOTPWithMagic(magicKey, email) {
+    const magic = getMagic(magicKey);
+    return magic.auth.loginWithEmailOTP({
+        email
+    });
+}
+function telegramWithMagic(magicKey) {
+    const magic = getMagic(magicKey);
+    return magic.oauth2.loginWithPopup({
+        provider: "telegram"
+    });
+}
+async function tauntMagicTelegramLogin(tauntServiceEndpoint, magicKey, tauntApi) {
+    const taunt = tauntApi || new TauntApi(tauntServiceEndpoint);
+    try {
+        let result = await telegramWithMagic(magicKey);
+        const errResult = result;
+        if (errResult.error) {
+            throw new Error(`No ID token returned ${errResult.error}`);
+        }
+        result = result;
+        console.log("Magic telegram login", {
+            result
+        });
+        return taunt.loginWithMagicDid(result.magic.idToken);
+    } catch (err) {
+        console.error("Magic login error:", err);
+        throw err;
+    }
+}
+async function tauntMagicEmailOTPLogin(tauntServiceEndpoint, magicKey, email, tauntApi) {
+    const taunt = tauntApi || new TauntApi(tauntServiceEndpoint);
+    try {
+        const did = await emailOTPWithMagic(magicKey, email);
+        if (!did) throw new Error("No DID returned");
+        console.log("Magic email OTP login", {
+            did
+        });
+        return taunt.loginWithMagicDid(did);
+    } catch (err) {
+        console.error("Magic login error:", err);
+        throw err;
+    }
+}
+async function tauntMagicDidLogin(tauntServiceEndpoint, did, tauntApi) {
+    const taunt = tauntApi || new TauntApi(tauntServiceEndpoint);
+    return taunt.loginWithMagicDid(did);
+}
+
+async function tauntSignWithMetamask(tauntServiceEndpoint, provider, tauntApi) {
+    provider = provider || window.ethereum;
+    if (!provider) throw new Error("MetaMask provider not found");
+    const accounts = await provider.request({
+        method: "eth_requestAccounts"
+    });
+    if (!accounts.length) throw new Error("No accounts returned");
+    console.log("MetaMask", {
+        accounts
+    });
+    const walletAddress = accounts[0];
+    const cryptoValuesArray = new Uint32Array(3);
+    const clientNonce = crypto.getRandomValues(cryptoValuesArray).toString();
+    const taunt = tauntApi || new TauntApi(tauntServiceEndpoint);
+    const serverNonce = await taunt.nonceLogin(walletAddress, clientNonce);
+    const payload = JSON.stringify({
+        clientNonce,
+        serverNonce
+    });
+    const message = `Sign this message with your wallet to connect to Taunt Battleworld ::: ${payload}`;
+    let signature;
+    try {
+        signature = await provider.request({
+            method: "personal_sign",
+            params: [
+                message,
+                walletAddress
+            ]
+        });
+    } catch (err) {
+        throw new Error("User denied message signature");
+    }
+    if (!signature) throw new Error("No signature returned");
+    return {
+        walletAddress,
+        message,
+        signature
+    };
+}
+async function tauntMetamaskLogin(tauntServiceEndpoint, providerParam, tauntApi) {
+    const taunt = tauntApi || new TauntApi(tauntServiceEndpoint);
+    const { walletAddress, message, signature } = await tauntSignWithMetamask(tauntServiceEndpoint, providerParam, tauntApi);
+    return taunt.loginWithWeb3WalletSignature({
+        walletAddress,
+        message,
+        signature
+    });
+}
+
+export { BadGatewayError, BadRequestError, BandwidthLimitExceededError, ConflictError, ErrorFromResponse, ErrorResponse, ExpectationFailedError, FailedDependencyError, ForbiddenError, GatewayTimeoutError, GoneError, HTTPVersionNotSupportedError, ImATeapotError, InsufficientStorageError, InternalServerError, LengthRequiredError, LockedError, LoopDetectedError, MethodNotAllowedError, NetworkAuthenticationRequiredError, NotAcceptableError, NotExtendedError, NotFoundError, NotImplementedError, PaymentRequiredError, PreconditionFailedError, PreconditionRequiredError, ProxyAuthenticationRequiredError, RequestEntityTooLargeError, RequestHeaderFieldsTooLargeError, RequestTimeoutError, RequestUriTooLongError, RequestedRangeNotSatisfiableError, ServiceUnavailableError, TauntApi, TooManyRequestsError, UnauthorizedError, UnknownError, UnprocessableEntityError, UnsupportedMediaTypeError, UpgradeRequiredError, VariantAlsoNegotiatesError, emailOTPWithMagic, tauntMagicDidLogin, tauntMagicEmailOTPLogin, tauntMagicTelegramLogin, tauntMetamaskLogin, tauntSignWithMetamask, telegramWithMagic };