Update v1.0.6

vendor/tymon/jwt-auth/src/Blacklist.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Tymon\JWTAuth;
+
+use Tymon\JWTAuth\Providers\Storage\StorageInterface;
+
+class Blacklist
+{
+    /**
+     * @var \Tymon\JWTAuth\Providers\Storage\StorageInterface
+     */
+    protected $storage;
+
+    /**
+     * @param \Tymon\JWTAuth\Providers\Storage\StorageInterface  $storage
+     */
+    public function __construct(StorageInterface $storage)
+    {
+        $this->storage = $storage;
+    }
+
+    /**
+     * Add the token (jti claim) to the blacklist
+     *
+     * @param  \Tymon\JWTAuth\Payload  $payload
+     * @return boolean
+     */
+    public function add(Payload $payload)
+    {
+        $exp = Utils::timestamp($payload['exp']);
+
+        // there is no need to add the token to the blacklist
+        // if the token has already expired
+        if ($exp->isPast()) {
+            return false;
+        }
+
+        // add a minute to abate potential overlap
+        $minutes = $exp->diffInMinutes(Utils::now()->subMinute());
+
+        $this->storage->add($payload['jti'], [], $minutes);
+
+        return true;
+    }
+
+    /**
+     * Determine whether the token has been blacklisted
+     *
+     * @param  \Tymon\JWTAuth\Payload  $payload
+     * @return boolean
+     */
+    public function has(Payload $payload)
+    {
+        return $this->storage->has($payload['jti']);
+    }
+
+    /**
+     * Remove the token (jti claim) from the blacklist
+     *
+     * @param  \Tymon\JWTAuth\Payload  $payload
+     * @return boolean
+     */
+    public function remove(Payload $payload)
+    {
+        return $this->storage->destroy($payload['jti']);
+    }
+
+    /**
+     * Remove all tokens from the blacklist
+     *
+     * @return boolean
+     */
+    public function clear()
+    {
+        $this->storage->flush();
+
+        return true;
+    }
+}

vendor/tymon/jwt-auth/src/Claims/Audience.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class Audience extends Claim
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name = 'aud';
+}

vendor/tymon/jwt-auth/src/Claims/Claim.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+use Tymon\JWTAuth\Exceptions\InvalidClaimException;
+
+abstract class Claim implements ClaimInterface
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * The claim value
+     *
+     * @var mixed
+     */
+    private $value;
+
+    /**
+     * @param mixed  $value
+     */
+    public function __construct($value)
+    {
+        $this->setValue($value);
+    }
+
+    /**
+     * Set the claim value, and call a validate method if available
+     *
+     * @param $value
+     * @throws \Tymon\JWTAuth\Exceptions\InvalidClaimException
+     * @return $this
+     */
+    public function setValue($value)
+    {
+        if (! $this->validate($value)) {
+            throw new InvalidClaimException('Invalid value provided for claim "' . $this->getName() . '": ' . $value);
+        }
+
+        $this->value = $value;
+
+        return $this;
+    }
+
+    /**
+     * Get the claim value
+     *
+     * @return mixed
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Set the claim name
+     *
+     * @param string $name
+     * @return $this
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    /**
+     * Get the claim name
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Validate the Claim value
+     *
+     * @param  $value
+     * @return boolean
+     */
+    protected function validate($value)
+    {
+        return true;
+    }
+
+    /**
+     * Build a key value array comprising of the claim name and value
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return [$this->getName() => $this->getValue()];
+    }
+
+    /**
+     * Get the claim as a string
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return json_encode($this->toArray(), JSON_UNESCAPED_SLASHES);
+    }
+}

vendor/tymon/jwt-auth/src/Claims/ClaimInterface.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+interface ClaimInterface
+{
+    /**
+     * Set the claim value, and call a validate method if available
+     *
+     * @param mixed
+     * @return Claim
+     */
+    public function setValue($value);
+
+    /**
+     * Get the claim value
+     *
+     * @return mixed
+     */
+    public function getValue();
+
+    /**
+     * Set the claim name
+     *
+     * @param string  $name
+     * @return Claim
+     */
+    public function setName($name);
+
+    /**
+     * Get the claim name
+     *
+     * @return string
+     */
+    public function getName();
+}

vendor/tymon/jwt-auth/src/Claims/Custom.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class Custom extends Claim
+{
+    /**
+     * @param string  $name
+     * @param mixed   $value
+     */
+    public function __construct($name, $value)
+    {
+        parent::__construct($value);
+        $this->setName($name);
+    }
+}

vendor/tymon/jwt-auth/src/Claims/Expiration.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class Expiration extends Claim
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name = 'exp';
+
+    /**
+     * Validate the expiry claim
+     *
+     * @param  mixed  $value
+     * @return boolean
+     */
+    protected function validate($value)
+    {
+        return is_numeric($value);
+    }
+}

vendor/tymon/jwt-auth/src/Claims/Factory.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class Factory
+{
+    /**
+     * @var array
+     */
+    private static $classMap = [
+        'aud' => 'Tymon\JWTAuth\Claims\Audience',
+        'exp' => 'Tymon\JWTAuth\Claims\Expiration',
+        'iat' => 'Tymon\JWTAuth\Claims\IssuedAt',
+        'iss' => 'Tymon\JWTAuth\Claims\Issuer',
+        'jti' => 'Tymon\JWTAuth\Claims\JwtId',
+        'nbf' => 'Tymon\JWTAuth\Claims\NotBefore',
+        'sub' => 'Tymon\JWTAuth\Claims\Subject'
+    ];
+
+    /**
+     * Get the instance of the claim when passing the name and value
+     *
+     * @param  string  $name
+     * @param  mixed   $value
+     * @return \Tymon\JWTAuth\Claims\Claim
+     */
+    public function get($name, $value)
+    {
+        if ($this->has($name)) {
+            return new self::$classMap[$name]($value);
+        }
+
+        return new Custom($name, $value);
+    }
+
+    /**
+     * Check whether the claim exists
+     *
+     * @param  string  $name
+     * @return boolean
+     */
+    public function has($name)
+    {
+        return array_key_exists($name, self::$classMap);
+    }
+}

vendor/tymon/jwt-auth/src/Claims/IssuedAt.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class IssuedAt extends Claim
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name = 'iat';
+
+    /**
+     * Validate the issued at claim
+     *
+     * @param  mixed  $value
+     * @return boolean
+     */
+    protected function validate($value)
+    {
+        return is_numeric($value);
+    }
+}

vendor/tymon/jwt-auth/src/Claims/Issuer.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class Issuer extends Claim
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name = 'iss';
+}

vendor/tymon/jwt-auth/src/Claims/JwtId.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class JwtId extends Claim
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name = 'jti';
+}

vendor/tymon/jwt-auth/src/Claims/NotBefore.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class NotBefore extends Claim
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name = 'nbf';
+
+    /**
+     * Validate the not before claim
+     *
+     * @param  mixed  $value
+     * @return boolean
+     */
+    protected function validate($value)
+    {
+        return is_numeric($value);
+    }
+}

vendor/tymon/jwt-auth/src/Claims/Subject.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tymon\JWTAuth\Claims;
+
+class Subject extends Claim
+{
+    /**
+     * The claim name
+     *
+     * @var string
+     */
+    protected $name = 'sub';
+}

vendor/tymon/jwt-auth/src/Commands/JWTGenerateCommand.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Tymon\JWTAuth\Commands;
+
+use Illuminate\Support\Str;
+use Illuminate\Console\Command;
+use Symfony\Component\Console\Input\InputOption;
+
+class JWTGenerateCommand extends Command
+{
+    /**
+     * The console command name.
+     *
+     * @var string
+     */
+    protected $name = 'jwt:generate';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Set the JWTAuth secret key used to sign the tokens';
+
+    /**
+     * Execute the console command.
+     *
+     * @return void
+     */
+    public function fire()
+    {
+        $key = $this->getRandomKey();
+
+        if ($this->option('show')) {
+            return $this->line('<comment>'.$key.'</comment>');
+        }
+
+        $path = config_path('jwt.php');
+
+        if (file_exists($path)) {
+            file_put_contents($path, str_replace(
+                $this->laravel['config']['jwt.secret'], $key, file_get_contents($path)
+            ));
+        }
+
+        $this->laravel['config']['jwt.secret'] = $key;
+
+        $this->info("jwt-auth secret [$key] set successfully.");
+    }
+
+    /**
+     * Generate a random key for the JWT Auth secret.
+     *
+     * @return string
+     */
+    protected function getRandomKey()
+    {
+        return Str::random(32);
+    }
+
+    /**
+     * Get the console command options.
+     *
+     * @return array
+     */
+    protected function getOptions()
+    {
+        return [
+            ['show', null, InputOption::VALUE_NONE, 'Simply display the key instead of modifying files.'],
+        ];
+    }
+}

vendor/tymon/jwt-auth/src/Exceptions/InvalidClaimException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Tymon\JWTAuth\Exceptions;
+
+class InvalidClaimException extends JWTException
+{
+    /**
+     * @var integer
+     */
+    protected $statusCode = 400;
+}

vendor/tymon/jwt-auth/src/Exceptions/JWTException.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Tymon\JWTAuth\Exceptions;
+
+class JWTException extends \Exception
+{
+    /**
+     * @var integer
+     */
+    protected $statusCode = 500;
+
+    /**
+     * @param string  $message
+     * @param integer $statusCode
+     */
+    public function __construct($message = 'An error occurred', $statusCode = null)
+    {
+        parent::__construct($message);
+
+        if (! is_null($statusCode)) {
+            $this->setStatusCode($statusCode);
+        }
+    }
+
+    /**
+     * @param integer $statusCode
+     */
+    public function setStatusCode($statusCode)
+    {
+        $this->statusCode = $statusCode;
+    }
+
+    /**
+     * @return integer the status code
+     */
+    public function getStatusCode()
+    {
+        return $this->statusCode;
+    }
+}

vendor/tymon/jwt-auth/src/Exceptions/PayloadException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Tymon\JWTAuth\Exceptions;
+
+class PayloadException extends JWTException
+{
+    /**
+     * @var integer
+     */
+    protected $statusCode = 500;
+}

vendor/tymon/jwt-auth/src/Exceptions/TokenBlacklistedException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Tymon\JWTAuth\Exceptions;
+
+class TokenBlacklistedException extends TokenInvalidException
+{
+    /**
+     * @var integer
+     */
+    protected $statusCode = 401;
+}

vendor/tymon/jwt-auth/src/Exceptions/TokenExpiredException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Tymon\JWTAuth\Exceptions;
+
+class TokenExpiredException extends JWTException
+{
+    /**
+     * @var integer
+     */
+    protected $statusCode = 401;
+}

vendor/tymon/jwt-auth/src/Exceptions/TokenInvalidException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Tymon\JWTAuth\Exceptions;
+
+class TokenInvalidException extends JWTException
+{
+    /**
+     * @var integer
+     */
+    protected $statusCode = 400;
+}

vendor/tymon/jwt-auth/src/Facades/JWTAuth.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Tymon\JWTAuth\Facades;
+
+use Illuminate\Support\Facades\Facade;
+
+class JWTAuth extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'tymon.jwt.auth';
+    }
+}

vendor/tymon/jwt-auth/src/Facades/JWTFactory.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Tymon\JWTAuth\Facades;
+
+use Illuminate\Support\Facades\Facade;
+
+class JWTFactory extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'tymon.jwt.payload.factory';
+    }
+}

vendor/tymon/jwt-auth/src/JWTAuth.php

@@ -0,0 +1,332 @@
+<?php
+
+namespace Tymon\JWTAuth;
+
+use Illuminate\Http\Request;
+use Tymon\JWTAuth\Exceptions\JWTException;
+use Tymon\JWTAuth\Providers\Auth\AuthInterface;
+use Tymon\JWTAuth\Providers\User\UserInterface;
+
+class JWTAuth
+{
+    /**
+     * @var \Tymon\JWTAuth\JWTManager
+     */
+    protected $manager;
+
+    /**
+     * @var \Tymon\JWTAuth\Providers\User\UserInterface
+     */
+    protected $user;
+
+    /**
+     * @var \Tymon\JWTAuth\Providers\Auth\AuthInterface
+     */
+    protected $auth;
+
+    /**
+     * @var \Illuminate\Http\Request
+     */
+    protected $request;
+
+    /**
+     * @var string
+     */
+    protected $identifier = 'id';
+
+    /**
+     * @var \Tymon\JWTAuth\Token
+     */
+    protected $token;
+
+    /**
+     * @param \Tymon\JWTAuth\JWTManager                   $manager
+     * @param \Tymon\JWTAuth\Providers\User\UserInterface $user
+     * @param \Tymon\JWTAuth\Providers\Auth\AuthInterface $auth
+     * @param \Illuminate\Http\Request                    $request
+     */
+    public function __construct(JWTManager $manager, UserInterface $user, AuthInterface $auth, Request $request)
+    {
+        $this->manager = $manager;
+        $this->user = $user;
+        $this->auth = $auth;
+        $this->request = $request;
+    }
+
+    /**
+     * Find a user using the user identifier in the subject claim.
+     *
+     * @param bool|string $token
+     *
+     * @return mixed
+     */
+    public function toUser($token = false)
+    {
+        $payload = $this->getPayload($token);
+
+        if (! $user = $this->user->getBy($this->identifier, $payload['sub'])) {
+            return false;
+        }
+
+        return $user;
+    }
+
+    /**
+     * Generate a token using the user identifier as the subject claim.
+     *
+     * @param mixed $user
+     * @param array $customClaims
+     *
+     * @return string
+     */
+    public function fromUser($user, array $customClaims = [])
+    {
+        $payload = $this->makePayload($user->{$this->identifier}, $customClaims);
+
+        return $this->manager->encode($payload)->get();
+    }
+
+    /**
+     * Attempt to authenticate the user and return the token.
+     *
+     * @param array $credentials
+     * @param array $customClaims
+     *
+     * @return false|string
+     */
+    public function attempt(array $credentials = [], array $customClaims = [])
+    {
+        if (! $this->auth->byCredentials($credentials)) {
+            return false;
+        }
+
+        return $this->fromUser($this->auth->user(), $customClaims);
+    }
+
+    /**
+     * Authenticate a user via a token.
+     *
+     * @param mixed $token
+     *
+     * @return mixed
+     */
+    public function authenticate($token = false)
+    {
+        $id = $this->getPayload($token)->get('sub');
+
+        if (! $this->auth->byId($id)) {
+            return false;
+        }
+
+        return $this->auth->user();
+    }
+
+    /**
+     * Refresh an expired token.
+     *
+     * @param mixed $token
+     *
+     * @return string
+     */
+    public function refresh($token = false)
+    {
+        $this->requireToken($token);
+
+        return $this->manager->refresh($this->token)->get();
+    }
+
+    /**
+     * Invalidate a token (add it to the blacklist).
+     *
+     * @param mixed $token
+     *
+     * @return boolean
+     */
+    public function invalidate($token = false)
+    {
+        $this->requireToken($token);
+
+        return $this->manager->invalidate($this->token);
+    }
+
+    /**
+     * Get the token.
+     *
+     * @return boolean|string
+     */
+    public function getToken()
+    {
+        if (! $this->token) {
+            try {
+                $this->parseToken();
+            } catch (JWTException $e) {
+                return false;
+            }
+        }
+
+        return $this->token;
+    }
+
+    /**
+     * Get the raw Payload instance.
+     *
+     * @param mixed $token
+     *
+     * @return \Tymon\JWTAuth\Payload
+     */
+    public function getPayload($token = false)
+    {
+        $this->requireToken($token);
+
+        return $this->manager->decode($this->token);
+    }
+
+    /**
+     * Parse the token from the request.
+     *
+     * @param string $query
+     *
+     * @return JWTAuth
+     */
+    public function parseToken($method = 'bearer', $header = 'authorization', $query = 'token')
+    {
+        if (! $token = $this->parseAuthHeader($header, $method)) {
+            if (! $token = $this->request->query($query, false)) {
+                throw new JWTException('The token could not be parsed from the request', 400);
+            }
+        }
+
+        return $this->setToken($token);
+    }
+
+    /**
+     * Parse token from the authorization header.
+     *
+     * @param string $header
+     * @param string $method
+     *
+     * @return false|string
+     */
+    protected function parseAuthHeader($header = 'authorization', $method = 'bearer')
+    {
+        $header = $this->request->headers->get($header);
+
+        if (! starts_with(strtolower($header), $method)) {
+            return false;
+        }
+
+        return trim(str_ireplace($method, '', $header));
+    }
+
+    /**
+     * Create a Payload instance.
+     *
+     * @param mixed $subject
+     * @param array $customClaims
+     *
+     * @return \Tymon\JWTAuth\Payload
+     */
+    protected function makePayload($subject, array $customClaims = [])
+    {
+        return $this->manager->getPayloadFactory()->make(
+            array_merge($customClaims, ['sub' => $subject])
+        );
+    }
+
+    /**
+     * Set the identifier.
+     *
+     * @param string $identifier
+     *
+     * @return $this
+     */
+    public function setIdentifier($identifier)
+    {
+        $this->identifier = $identifier;
+
+        return $this;
+    }
+
+    /**
+     * Get the identifier.
+     *
+     * @return string
+     */
+    public function getIdentifier()
+    {
+        return $this->identifier;
+    }
+
+    /**
+     * Set the token.
+     *
+     * @param string $token
+     *
+     * @return $this
+     */
+    public function setToken($token)
+    {
+        $this->token = new Token($token);
+
+        return $this;
+    }
+
+    /**
+     * Ensure that a token is available.
+     *
+     * @param mixed $token
+     *
+     * @return JWTAuth
+     *
+     * @throws \Tymon\JWTAuth\Exceptions\JWTException
+     */
+    protected function requireToken($token)
+    {
+        if (! $token = $token ?: $this->token) {
+            throw new JWTException('A token is required', 400);
+        }
+
+        return $this->setToken($token);
+    }
+
+    /**
+     * Set the request instance.
+     *
+     * @param Request $request
+     */
+    public function setRequest(Request $request)
+    {
+        $this->request = $request;
+
+        return $this;
+    }
+
+    /**
+     * Get the JWTManager instance.
+     *
+     * @return \Tymon\JWTAuth\JWTManager
+     */
+    public function manager()
+    {
+        return $this->manager;
+    }
+
+    /**
+     * Magically call the JWT Manager.
+     *
+     * @param string $method
+     * @param array  $parameters
+     *
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    public function __call($method, $parameters)
+    {
+        if (method_exists($this->manager, $method)) {
+            return call_user_func_array([$this->manager, $method], $parameters);
+        }
+
+        throw new \BadMethodCallException("Method [$method] does not exist.");
+    }
+}

vendor/tymon/jwt-auth/src/JWTManager.php

@@ -0,0 +1,174 @@
+<?php
+
+namespace Tymon\JWTAuth;
+
+use Tymon\JWTAuth\Exceptions\JWTException;
+use Tymon\JWTAuth\Providers\JWT\JWTInterface;
+use Tymon\JWTAuth\Exceptions\TokenBlacklistedException;
+
+class JWTManager
+{
+    /**
+     * @var \Tymon\JWTAuth\Providers\JWT\JWTInterface
+     */
+    protected $jwt;
+
+    /**
+     * @var \Tymon\JWTAuth\Blacklist
+     */
+    protected $blacklist;
+
+    /**
+     * @var \Tymon\JWTAuth\PayloadFactory
+     */
+    protected $payloadFactory;
+
+    /**
+     * @var boolean
+     */
+    protected $blacklistEnabled = true;
+
+    /**
+     * @var boolean
+     */
+    protected $refreshFlow = false;
+
+    /**
+     *  @param \Tymon\JWTAuth\Providers\JWT\JWTInterface  $jwt
+     *  @param \Tymon\JWTAuth\Blacklist  $blacklist
+     *  @param \Tymon\JWTAuth\PayloadFactory  $payloadFactory
+     */
+    public function __construct(JWTInterface $jwt, Blacklist $blacklist, PayloadFactory $payloadFactory)
+    {
+        $this->jwt = $jwt;
+        $this->blacklist = $blacklist;
+        $this->payloadFactory = $payloadFactory;
+    }
+
+    /**
+     * Encode a Payload and return the Token
+     *
+     * @param  \Tymon\JWTAuth\Payload  $payload
+     * @return \Tymon\JWTAuth\Token
+     */
+    public function encode(Payload $payload)
+    {
+        $token = $this->jwt->encode($payload->get());
+
+        return new Token($token);
+    }
+
+    /**
+     * Decode a Token and return the Payload
+     *
+     * @param  \Tymon\JWTAuth\Token $token
+     * @return Payload
+     * @throws TokenBlacklistedException
+     */
+    public function decode(Token $token)
+    {
+        $payloadArray = $this->jwt->decode($token->get());
+
+        $payload = $this->payloadFactory->setRefreshFlow($this->refreshFlow)->make($payloadArray);
+
+        if ($this->blacklistEnabled && $this->blacklist->has($payload)) {
+            throw new TokenBlacklistedException('The token has been blacklisted');
+        }
+
+        return $payload;
+    }
+
+    /**
+     * Refresh a Token and return a new Token
+     *
+     * @param  \Tymon\JWTAuth\Token  $token
+     * @return \Tymon\JWTAuth\Token
+     */
+    public function refresh(Token $token)
+    {
+        $payload = $this->setRefreshFlow()->decode($token);
+
+        if ($this->blacklistEnabled) {
+            // invalidate old token
+            $this->blacklist->add($payload);
+        }
+
+        // return the new token
+        return $this->encode(
+            $this->payloadFactory->make([
+                'sub' => $payload['sub'],
+                'iat' => $payload['iat']
+            ])
+        );
+    }
+
+    /**
+     * Invalidate a Token by adding it to the blacklist
+     *
+     * @param  Token  $token
+     * @return boolean
+     */
+    public function invalidate(Token $token)
+    {
+        if (! $this->blacklistEnabled) {
+            throw new JWTException('You must have the blacklist enabled to invalidate a token.');
+        }
+
+        return $this->blacklist->add($this->decode($token));
+    }
+
+    /**
+     * Get the PayloadFactory instance
+     *
+     * @return \Tymon\JWTAuth\PayloadFactory
+     */
+    public function getPayloadFactory()
+    {
+        return $this->payloadFactory;
+    }
+
+    /**
+     * Get the JWTProvider instance
+     *
+     * @return \Tymon\JWTAuth\Providers\JWT\JWTInterface
+     */
+    public function getJWTProvider()
+    {
+        return $this->jwt;
+    }
+
+    /**
+     * Get the Blacklist instance
+     *
+     * @return \Tymon\JWTAuth\Blacklist
+     */
+    public function getBlacklist()
+    {
+        return $this->blacklist;
+    }
+
+    /**
+     * Set whether the blacklist is enabled
+     *
+     * @param bool  $enabled
+     */
+    public function setBlacklistEnabled($enabled)
+    {
+        $this->blacklistEnabled = $enabled;
+
+        return $this;
+    }
+
+    /**
+     * Set the refresh flow
+     *
+     * @param boolean $refreshFlow
+     * @return $this
+     */
+    public function setRefreshFlow($refreshFlow = true)
+    {
+        $this->refreshFlow = $refreshFlow;
+
+        return $this;
+    }
+}

vendor/tymon/jwt-auth/src/Middleware/BaseMiddleware.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Tymon\JWTAuth\Middleware;
+
+use Tymon\JWTAuth\JWTAuth;
+use Illuminate\Events\Dispatcher;
+use Illuminate\Routing\ResponseFactory;
+
+abstract class BaseMiddleware
+{
+    /**
+     * @var \Illuminate\Routing\ResponseFactory
+     */
+    protected $response;
+
+    /**
+     * @var \Illuminate\Events\Dispatcher
+     */
+    protected $events;
+
+    /**
+     * @var \Tymon\JWTAuth\JWTAuth
+     */
+    protected $auth;
+
+    /**
+     * Create a new BaseMiddleware instance
+     *
+     * @param \Illuminate\Routing\ResponseFactory  $response
+     * @param \Illuminate\Events\Dispatcher  $events
+     * @param \Tymon\JWTAuth\JWTAuth  $auth
+     */
+    public function __construct(ResponseFactory $response, Dispatcher $events, JWTAuth $auth)
+    {
+        $this->response = $response;
+        $this->events = $events;
+        $this->auth = $auth;
+    }
+
+    /**
+     * Fire event and return the response
+     *
+     * @param  string   $event
+     * @param  string   $error
+     * @param  integer  $status
+     * @param  array    $payload
+     * @return mixed
+     */
+    protected function respond($event, $error, $status, $payload = [])
+    {
+        $response = $this->events->fire($event, $payload, true);
+
+        return $response ?: $this->response->json(['error' => $error], $status);
+    }
+}

vendor/tymon/jwt-auth/src/Middleware/GetUserFromToken.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Tymon\JWTAuth\Middleware;
+
+use Tymon\JWTAuth\Exceptions\JWTException;
+use Tymon\JWTAuth\Exceptions\TokenExpiredException;
+
+class GetUserFromToken extends BaseMiddleware
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle($request, \Closure $next)
+    {
+        if (! $token = $this->auth->setRequest($request)->getToken()) {
+            return $this->respond('tymon.jwt.absent', 'token_not_provided', 400);
+        }
+
+        try {
+            $user = $this->auth->authenticate($token);
+        } catch (TokenExpiredException $e) {
+            return $this->respond('tymon.jwt.expired', 'token_expired', $e->getStatusCode(), [$e]);
+        } catch (JWTException $e) {
+            return $this->respond('tymon.jwt.invalid', 'token_invalid', $e->getStatusCode(), [$e]);
+        }
+
+        if (! $user) {
+            return $this->respond('tymon.jwt.user_not_found', 'user_not_found', 404);
+        }
+
+        $this->events->fire('tymon.jwt.valid', $user);
+
+        return $next($request);
+    }
+}

vendor/tymon/jwt-auth/src/Middleware/RefreshToken.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Tymon\JWTAuth\Middleware;
+
+use Tymon\JWTAuth\Exceptions\JWTException;
+use Tymon\JWTAuth\Exceptions\TokenExpiredException;
+
+class RefreshToken extends BaseMiddleware
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle($request, \Closure $next)
+    {
+        $response = $next($request);
+
+        try {
+            $newToken = $this->auth->setRequest($request)->parseToken()->refresh();
+        } catch (TokenExpiredException $e) {
+            return $this->respond('tymon.jwt.expired', 'token_expired', $e->getStatusCode(), [$e]);
+        } catch (JWTException $e) {
+            return $this->respond('tymon.jwt.invalid', 'token_invalid', $e->getStatusCode(), [$e]);
+        }
+
+        // send the refreshed token back to the client
+        $response->headers->set('Authorization', 'Bearer ' . $newToken);
+
+        return $response;
+    }
+}

vendor/tymon/jwt-auth/src/Payload.php

@@ -0,0 +1,166 @@
+<?php
+
+namespace Tymon\JWTAuth;
+
+use Tymon\JWTAuth\Claims\Claim;
+use Tymon\JWTAuth\Exceptions\PayloadException;
+use Tymon\JWTAuth\Validators\PayloadValidator;
+
+class Payload implements \ArrayAccess
+{
+    /**
+     * The array of claims
+     *
+     * @var \Tymon\JWTAuth\Claims\Claim[]
+     */
+    private $claims = [];
+
+    /**
+     * Build the Payload
+     *
+     * @param array  $claims
+     * @param \Tymon\JWTAuth\Validators\PayloadValidator  $validator
+     * @param bool   $refreshFlow
+     */
+    public function __construct(array $claims, PayloadValidator $validator, $refreshFlow = false)
+    {
+        $this->claims = $claims;
+
+        $validator->setRefreshFlow($refreshFlow)->check($this->toArray());
+    }
+
+    /**
+     * Get the array of claim instances
+     *
+     * @return \Tymon\JWTAuth\Claims\Claim[]
+     */
+    public function getClaims()
+    {
+        return $this->claims;
+    }
+
+    /**
+     * Get the array of claims
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        $results = [];
+        foreach ($this->claims as $claim) {
+            $results[$claim->getName()] = $claim->getValue();
+        }
+
+        return $results;
+    }
+
+    /**
+     * Get the payload
+     *
+     * @param  string  $claim
+     * @return mixed
+     */
+    public function get($claim = null)
+    {
+        if (! is_null($claim)) {
+            if (is_array($claim)) {
+                return array_map([$this, 'get'], $claim);
+            }
+
+            return array_get($this->toArray(), $claim, false);
+        }
+
+        return $this->toArray();
+    }
+
+    /**
+     * Determine whether the payload has the claim
+     *
+     * @param  \Tymon\JWTAuth\Claims\Claim  $claim
+     * @return boolean
+     */
+    public function has(Claim $claim)
+    {
+        return in_array($claim, $this->claims);
+    }
+
+    /**
+     * Get the payload as a string
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return json_encode($this->toArray());
+    }
+
+    /**
+     * Determine if an item exists at an offset.
+     *
+     * @param  mixed  $key
+     * @return bool
+     */
+    public function offsetExists($key)
+    {
+        return array_key_exists($key, $this->toArray());
+    }
+
+    /**
+     * Get an item at a given offset.
+     *
+     * @param  mixed  $key
+     * @return mixed
+     */
+    public function offsetGet($key)
+    {
+        return array_get($this->toArray(), $key, []);
+    }
+
+    /**
+     * Don't allow changing the payload as it should be immutable
+     *
+     * @param  mixed $key
+     * @param  mixed $value
+     * @throws Exceptions\PayloadException
+     * @return void
+     */
+    public function offsetSet($key, $value)
+    {
+        throw new PayloadException('The payload is immutable');
+    }
+
+    /**
+     * Don't allow changing the payload as it should be immutable
+     *
+     * @param  string $key
+     * @throws Exceptions\PayloadException
+     * @return void
+     */
+    public function offsetUnset($key)
+    {
+        throw new PayloadException('The payload is immutable');
+    }
+
+    /**
+     * Magically get a claim value
+     *
+     * @param  string  $method
+     * @param  array   $parameters
+     * @return mixed
+     * @throws \BadMethodCallException
+     */
+    public function __call($method, $parameters)
+    {
+        if (! method_exists($this, $method) && starts_with($method, 'get')) {
+            $class = sprintf('Tymon\\JWTAuth\\Claims\\%s', substr($method, 3));
+
+            foreach ($this->claims as $claim) {
+                if (get_class($claim) === $class) {
+                    return $claim->getValue();
+                }
+            }
+        }
+
+        throw new \BadMethodCallException(sprintf('The claim [%s] does not exist on the payload.', $method));
+    }
+}

vendor/tymon/jwt-auth/src/PayloadFactory.php

@@ -0,0 +1,238 @@
+<?php
+
+namespace Tymon\JWTAuth;
+
+use Illuminate\Http\Request;
+use Tymon\JWTAuth\Claims\Factory;
+use Tymon\JWTAuth\Validators\PayloadValidator;
+
+class PayloadFactory
+{
+    /**
+     * @var \Tymon\JWTAuth\Claims\Factory
+     */
+    protected $claimFactory;
+
+    /**
+     * @var \Illuminate\Http\Request
+     */
+    protected $request;
+
+    /**
+     * @var \Tymon\JWTAuth\Validators\PayloadValidator
+     */
+    protected $validator;
+
+    /**
+     * @var int
+     */
+    protected $ttl = 60;
+
+    /**
+     * @var boolean
+     */
+    protected $refreshFlow = false;
+
+    /**
+     * @var array
+     */
+    protected $defaultClaims = ['iss', 'iat', 'exp', 'nbf', 'jti'];
+
+    /**
+     * @var array
+     */
+    protected $claims = [];
+
+    /**
+     * @param \Tymon\JWTAuth\Claims\Factory  $claimFactory
+     * @param \Illuminate\Http\Request  $request
+     * @param \Tymon\JWTAuth\Validators\PayloadValidator  $validator
+     */
+    public function __construct(Factory $claimFactory, Request $request, PayloadValidator $validator)
+    {
+        $this->claimFactory = $claimFactory;
+        $this->request = $request;
+        $this->validator = $validator;
+    }
+
+    /**
+     * Create the Payload instance
+     *
+     * @param  array  $customClaims
+     * @return \Tymon\JWTAuth\Payload
+     */
+    public function make(array $customClaims = [])
+    {
+        $claims = $this->buildClaims($customClaims)->resolveClaims();
+
+        return new Payload($claims, $this->validator, $this->refreshFlow);
+    }
+
+    /**
+     * Add an array of claims to the Payload
+     *
+     * @param  array  $claims
+     * @return $this
+     */
+    public function addClaims(array $claims)
+    {
+        foreach ($claims as $name => $value) {
+            $this->addClaim($name, $value);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add a claim to the Payload
+     *
+     * @param  string  $name
+     * @param  mixed   $value
+     * @return $this
+     */
+    public function addClaim($name, $value)
+    {
+        $this->claims[$name] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Build the default claims
+     *
+     * @param  array  $customClaims
+     * @return $this
+     */
+    protected function buildClaims(array $customClaims)
+    {
+        // add any custom claims first
+        $this->addClaims(array_diff_key($customClaims, $this->defaultClaims));
+
+        foreach ($this->defaultClaims as $claim) {
+            if (! array_key_exists($claim, $customClaims)) {
+                $this->addClaim($claim, $this->$claim());
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Build out the Claim DTO's
+     *
+     * @return array
+     */
+    public function resolveClaims()
+    {
+        $resolved = [];
+        foreach ($this->claims as $name => $value) {
+            $resolved[] = $this->claimFactory->get($name, $value);
+        }
+
+        return $resolved;
+    }
+
+    /**
+     * Set the Issuer (iss) claim
+     *
+     * @return string
+     */
+    public function iss()
+    {
+        return $this->request->url();
+    }
+
+    /**
+     * Set the Issued At (iat) claim
+     *
+     * @return int
+     */
+    public function iat()
+    {
+        return (int) Utils::now()->format('U');
+    }
+
+    /**
+     * Set the Expiration (exp) claim
+     *
+     * @return int
+     */
+    public function exp()
+    {
+        return (int) Utils::now()->addMinutes($this->ttl)->format('U');
+    }
+
+    /**
+     * Set the Not Before (nbf) claim
+     *
+     * @return int
+     */
+    public function nbf()
+    {
+        return (int) Utils::now()->format('U');
+    }
+
+    /**
+     * Set a unique id (jti) for the token
+     *
+     * @return string
+     */
+    protected function jti()
+    {
+        $sub = array_get($this->claims, 'sub', '');
+        $nbf = array_get($this->claims, 'nbf', '');
+
+        return md5(sprintf('jti.%s.%s', $sub, $nbf));
+    }
+
+    /**
+     * Set the token ttl (in minutes)
+     *
+     * @param  int  $ttl
+     * @return $this
+     */
+    public function setTTL($ttl)
+    {
+        $this->ttl = $ttl;
+
+        return $this;
+    }
+
+    /**
+     * Get the token ttl
+     *
+     * @return int
+     */
+    public function getTTL()
+    {
+        return $this->ttl;
+    }
+
+    /**
+     * Set the refresh flow
+     *
+     * @param boolean $refreshFlow
+     * @return $this
+     */
+    public function setRefreshFlow($refreshFlow = true)
+    {
+        $this->refreshFlow = $refreshFlow;
+
+        return $this;
+    }
+
+    /**
+     * Magically add a claim
+     *
+     * @param  string  $method
+     * @param  array   $parameters
+     * @return PayloadFactory
+     * @throws \BadMethodCallException
+     */
+    public function __call($method, $parameters)
+    {
+        $this->addClaim($method, $parameters[0]);
+
+        return $this;
+    }
+}

vendor/tymon/jwt-auth/src/Providers/Auth/AuthInterface.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\Auth;
+
+interface AuthInterface
+{
+    /**
+     * Check a user's credentials
+     *
+     * @param  array  $credentials
+     * @return bool
+     */
+    public function byCredentials(array $credentials = []);
+
+    /**
+     * Authenticate a user via the id
+     *
+     * @param  mixed  $id
+     * @return bool
+     */
+    public function byId($id);
+
+    /**
+     * Get the currently authenticated user
+     *
+     * @return mixed
+     */
+    public function user();
+}

vendor/tymon/jwt-auth/src/Providers/Auth/IlluminateAuthAdapter.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\Auth;
+
+use Exception;
+use Illuminate\Auth\AuthManager;
+
+class IlluminateAuthAdapter implements AuthInterface
+{
+    /**
+     * @var \Illuminate\Auth\AuthManager
+     */
+    protected $auth;
+
+    /**
+     * @param \Illuminate\Auth\AuthManager  $auth
+     */
+    public function __construct(AuthManager $auth)
+    {
+        $this->auth = $auth;
+    }
+
+    /**
+     * Check a user's credentials
+     *
+     * @param  array  $credentials
+     * @return bool
+     */
+    public function byCredentials(array $credentials = [])
+    {
+        return $this->auth->once($credentials);
+    }
+
+    /**
+     * Authenticate a user via the id
+     *
+     * @param  mixed  $id
+     * @return bool
+     */
+    public function byId($id)
+    {
+        try {
+            return $this->auth->onceUsingId($id);
+        } catch (Exception $e) {
+            return false;
+        }
+    }
+
+    /**
+     * Get the currently authenticated user
+     *
+     * @return mixed
+     */
+    public function user()
+    {
+        return $this->auth->user();
+    }
+}

vendor/tymon/jwt-auth/src/Providers/JWT/JWTInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\JWT;
+
+interface JWTInterface
+{
+    /**
+     * @param  array  $payload
+     * @return string
+     */
+    public function encode(array $payload);
+
+    /**
+     * @param  string  $token
+     * @return array
+     */
+    public function decode($token);
+}

vendor/tymon/jwt-auth/src/Providers/JWT/JWTProvider.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\JWT;
+
+abstract class JWTProvider
+{
+    /**
+     * @var string
+     */
+    protected $secret;
+
+    /**
+     * @var string
+     */
+    protected $algo;
+
+    /**
+     * @param string  $secret
+     * @param string  $algo
+     */
+    public function __construct($secret, $algo = 'HS256')
+    {
+        $this->secret = $secret;
+        $this->algo = $algo;
+    }
+
+    /**
+     * Set the algorithm used to sign the token
+     *
+     * @param  string  $algo
+     * @return self
+     */
+    public function setAlgo($algo)
+    {
+        $this->algo = $algo;
+
+        return $this;
+    }
+
+    /**
+     * Get the algorithm used to sign the token
+     *
+     * @return string
+     */
+    public function getAlgo()
+    {
+        return $this->algo;
+    }
+}

vendor/tymon/jwt-auth/src/Providers/JWT/NamshiAdapter.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\JWT;
+
+use Exception;
+use Namshi\JOSE\JWS;
+use Tymon\JWTAuth\Exceptions\JWTException;
+use Tymon\JWTAuth\Exceptions\TokenInvalidException;
+
+class NamshiAdapter extends JWTProvider implements JWTInterface
+{
+    /**
+     * @var \Namshi\JOSE\JWS
+     */
+    protected $jws;
+
+    /**
+     * @param string  $secret
+     * @param string  $algo
+     * @param null    $driver
+     */
+    public function __construct($secret, $algo, $driver = null)
+    {
+        parent::__construct($secret, $algo);
+
+        $this->jws = $driver ?: new JWS(['typ' => 'JWT', 'alg' => $algo]);
+    }
+
+    /**
+     * Create a JSON Web Token
+     *
+     * @return string
+     * @throws \Tymon\JWTAuth\Exceptions\JWTException
+     */
+    public function encode(array $payload)
+    {
+        try {
+            $this->jws->setPayload($payload)->sign($this->secret);
+
+            return $this->jws->getTokenString();
+        } catch (Exception $e) {
+            throw new JWTException('Could not create token: ' . $e->getMessage());
+        }
+    }
+
+    /**
+     * Decode a JSON Web Token
+     *
+     * @param  string  $token
+     * @return array
+     * @throws \Tymon\JWTAuth\Exceptions\JWTException
+     */
+    public function decode($token)
+    {
+        try {
+            $jws = JWS::load($token);
+        } catch (Exception $e) {
+            throw new TokenInvalidException('Could not decode token: ' . $e->getMessage());
+        }
+
+        if (! $jws->verify($this->secret, $this->algo)) {
+            throw new TokenInvalidException('Token Signature could not be verified.');
+        }
+
+        return $jws->getPayload();
+    }
+}

vendor/tymon/jwt-auth/src/Providers/JWTAuthServiceProvider.php

@@ -0,0 +1,267 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers;
+
+use Tymon\JWTAuth\JWTAuth;
+use Tymon\JWTAuth\Blacklist;
+use Tymon\JWTAuth\JWTManager;
+use Tymon\JWTAuth\PayloadFactory;
+use Tymon\JWTAuth\Claims\Factory;
+use Illuminate\Support\ServiceProvider;
+use Tymon\JWTAuth\Commands\JWTGenerateCommand;
+use Tymon\JWTAuth\Validators\PayloadValidator;
+
+class JWTAuthServiceProvider extends ServiceProvider
+{
+    /**
+     * Indicates if loading of the provider is deferred.
+     *
+     * @var bool
+     */
+    protected $defer = false;
+
+    /**
+     * Boot the service provider.
+     */
+    public function boot()
+    {
+        $this->publishes([
+            __DIR__.'/../config/config.php' => config_path('jwt.php')
+        ], 'config');
+
+        $this->bootBindings();
+
+        $this->commands('tymon.jwt.generate');
+    }
+
+    /**
+     * Bind some Interfaces and implementations
+     */
+    protected function bootBindings()
+    {
+        $this->app['Tymon\JWTAuth\JWTAuth'] = function ($app) {
+            return $app['tymon.jwt.auth'];
+        };
+
+        $this->app['Tymon\JWTAuth\Providers\User\UserInterface'] = function ($app) {
+            return $app['tymon.jwt.provider.user'];
+        };
+
+        $this->app['Tymon\JWTAuth\Providers\JWT\JWTInterface'] = function ($app) {
+            return $app['tymon.jwt.provider.jwt'];
+        };
+
+        $this->app['Tymon\JWTAuth\Providers\Auth\AuthInterface'] = function ($app) {
+            return $app['tymon.jwt.provider.auth'];
+        };
+
+        $this->app['Tymon\JWTAuth\Providers\Storage\StorageInterface'] = function ($app) {
+            return $app['tymon.jwt.provider.storage'];
+        };
+
+        $this->app['Tymon\JWTAuth\JWTManager'] = function ($app) {
+            return $app['tymon.jwt.manager'];
+        };
+
+        $this->app['Tymon\JWTAuth\Blacklist'] = function ($app) {
+            return $app['tymon.jwt.blacklist'];
+        };
+
+        $this->app['Tymon\JWTAuth\PayloadFactory'] = function ($app) {
+            return $app['tymon.jwt.payload.factory'];
+        };
+
+        $this->app['Tymon\JWTAuth\Claims\Factory'] = function ($app) {
+            return $app['tymon.jwt.claim.factory'];
+        };
+
+        $this->app['Tymon\JWTAuth\Validators\PayloadValidator'] = function ($app) {
+            return $app['tymon.jwt.validators.payload'];
+        };
+    }
+
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        // register providers
+        $this->registerUserProvider();
+        $this->registerJWTProvider();
+        $this->registerAuthProvider();
+        $this->registerStorageProvider();
+        $this->registerJWTBlacklist();
+
+        $this->registerClaimFactory();
+        $this->registerJWTManager();
+
+        $this->registerJWTAuth();
+        $this->registerPayloadValidator();
+        $this->registerPayloadFactory();
+        $this->registerJWTCommand();
+
+        $this->mergeConfigFrom(__DIR__ . '/../config/config.php', 'jwt');
+    }
+
+    /**
+     * Register the bindings for the User provider
+     */
+    protected function registerUserProvider()
+    {
+        $this->app['tymon.jwt.provider.user'] = $this->app->share(function ($app) {
+            return $app->make($this->config('providers.user'), [$app->make($this->config('user'))]);
+        });
+    }
+
+    /**
+     * Register the bindings for the JSON Web Token provider
+     */
+    protected function registerJWTProvider()
+    {
+        $this->app['tymon.jwt.provider.jwt'] = $this->app->share(function ($app) {
+
+            $secret = $this->config('secret');
+            $algo = $this->config('algo');
+            $provider = $this->config('providers.jwt');
+
+            return $app->make($provider, [$secret, $algo]);
+        });
+    }
+
+    /**
+     * Register the bindings for the Auth provider
+     */
+    protected function registerAuthProvider()
+    {
+        $this->app['tymon.jwt.provider.auth'] = $this->app->share(function ($app) {
+            return $this->getConfigInstance($this->config('providers.auth'));
+        });
+    }
+
+    /**
+     * Register the bindings for the Storage provider
+     */
+    protected function registerStorageProvider()
+    {
+        $this->app['tymon.jwt.provider.storage'] = $this->app->share(function ($app) {
+            return $this->getConfigInstance($this->config('providers.storage'));
+        });
+    }
+
+    /**
+     * Register the bindings for the Payload Factory
+     */
+    protected function registerClaimFactory()
+    {
+        $this->app->singleton('tymon.jwt.claim.factory', function () {
+            return new Factory();
+        });
+    }
+
+    /**
+     * Register the bindings for the JWT Manager
+     */
+    protected function registerJWTManager()
+    {
+        $this->app['tymon.jwt.manager'] = $this->app->share(function ($app) {
+
+            $instance = new JWTManager(
+                $app['tymon.jwt.provider.jwt'],
+                $app['tymon.jwt.blacklist'],
+                $app['tymon.jwt.payload.factory']
+            );
+
+            return $instance->setBlacklistEnabled((bool) $this->config('blacklist_enabled'));
+        });
+    }
+
+    /**
+     * Register the bindings for the main JWTAuth class
+     */
+    protected function registerJWTAuth()
+    {
+        $this->app['tymon.jwt.auth'] = $this->app->share(function ($app) {
+
+            $auth = new JWTAuth(
+                $app['tymon.jwt.manager'],
+                $app['tymon.jwt.provider.user'],
+                $app['tymon.jwt.provider.auth'],
+                $app['request']
+            );
+
+            return $auth->setIdentifier($this->config('identifier'));
+        });
+    }
+
+    /**
+     * Register the bindings for the main JWTAuth class
+     */
+    protected function registerJWTBlacklist()
+    {
+        $this->app['tymon.jwt.blacklist'] = $this->app->share(function ($app) {
+            return new Blacklist($app['tymon.jwt.provider.storage']);
+        });
+    }
+
+    /**
+     * Register the bindings for the payload validator
+     */
+    protected function registerPayloadValidator()
+    {
+        $this->app['tymon.jwt.validators.payload'] = $this->app->share(function () {
+            return with(new PayloadValidator())->setRefreshTTL($this->config('refresh_ttl'))->setRequiredClaims($this->config('required_claims'));
+        });
+    }
+
+    /**
+     * Register the bindings for the Payload Factory
+     */
+    protected function registerPayloadFactory()
+    {
+        $this->app['tymon.jwt.payload.factory'] = $this->app->share(function ($app) {
+            $factory = new PayloadFactory($app['tymon.jwt.claim.factory'], $app['request'], $app['tymon.jwt.validators.payload']);
+
+            return $factory->setTTL($this->config('ttl'));
+        });
+    }
+
+    /**
+     * Register the Artisan command
+     */
+    protected function registerJWTCommand()
+    {
+        $this->app['tymon.jwt.generate'] = $this->app->share(function () {
+            return new JWTGenerateCommand();
+        });
+    }
+
+    /**
+     * Helper to get the config values
+     *
+     * @param  string $key
+     * @return string
+     */
+    protected function config($key, $default = null)
+    {
+        return config("jwt.$key", $default);
+    }
+
+    /**
+     * Get an instantiable configuration instance. Pinched from dingo/api :)
+     *
+     * @param  mixed  $instance
+     * @return object
+     */
+    protected function getConfigInstance($instance)
+    {
+        if (is_callable($instance)) {
+            return call_user_func($instance, $this->app);
+        } elseif (is_string($instance)) {
+            return $this->app->make($instance);
+        }
+
+        return $instance;
+    }
+}

vendor/tymon/jwt-auth/src/Providers/Storage/IlluminateCacheAdapter.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\Storage;
+
+use Illuminate\Cache\CacheManager;
+use Tymon\JWTAuth\Providers\Storage\StorageInterface;
+
+class IlluminateCacheAdapter implements StorageInterface
+{
+    /**
+     * @var \Illuminate\Cache\CacheManager
+     */
+    protected $cache;
+
+    /**
+     * @var string
+     */
+    protected $tag = 'tymon.jwt';
+
+    /**
+     * @param \Illuminate\Cache\CacheManager  $cache
+     */
+    public function __construct(CacheManager $cache)
+    {
+        $this->cache = $cache;
+    }
+
+    /**
+     * Add a new item into storage
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  int  $minutes
+     * @return void
+     */
+    public function add($key, $value, $minutes)
+    {
+        $this->cache()->put($key, $value, $minutes);
+    }
+
+    /**
+     * Check whether a key exists in storage
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function has($key)
+    {
+        return $this->cache()->has($key);
+    }
+
+    /**
+     * Remove an item from storage
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function destroy($key)
+    {
+        return $this->cache()->forget($key);
+    }
+
+    /**
+     * Remove all items associated with the tag
+     *
+     * @return void
+     */
+    public function flush()
+    {
+        $this->cache()->flush();
+    }
+
+    /**
+     * Return the cache instance with tags attached
+     *
+     * @return \Illuminate\Cache\CacheManager
+     */
+    protected function cache()
+    {
+        if (! method_exists($this->cache, 'tags')) {
+            return $this->cache;
+        }
+
+        return $this->cache->tags($this->tag);
+    }
+}

vendor/tymon/jwt-auth/src/Providers/Storage/StorageInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\Storage;
+
+interface StorageInterface
+{
+    /**
+     * @param string $key
+     * @param integer $minutes
+     * @return void
+     */
+    public function add($key, $value, $minutes);
+
+    /**
+     * @param string $key
+     * @return boolean
+     */
+    public function has($key);
+
+    /**
+     * @param string $key
+     * @return boolean
+     */
+    public function destroy($key);
+
+    /**
+     * @return void
+     */
+    public function flush();
+}

vendor/tymon/jwt-auth/src/Providers/User/EloquentUserAdapter.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\User;
+
+use Illuminate\Database\Eloquent\Model;
+
+class EloquentUserAdapter implements UserInterface
+{
+    /**
+     * @var \Illuminate\Database\Eloquent\Model
+     */
+    protected $user;
+
+    /**
+     * Create a new User instance
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $user
+     */
+    public function __construct(Model $user)
+    {
+        $this->user = $user;
+    }
+
+    /**
+     * Get the user by the given key, value
+     *
+     * @param  mixed  $key
+     * @param  mixed  $value
+     * @return Illuminate\Database\Eloquent\Model
+     */
+    public function getBy($key, $value)
+    {
+        return $this->user->where($key, $value)->first();
+    }
+}

vendor/tymon/jwt-auth/src/Providers/User/UserInterface.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Tymon\JWTAuth\Providers\User;
+
+interface UserInterface
+{
+    /**
+     * Get the user by the given key, value
+     *
+     * @param string $key
+     * @param mixed $value
+     * @return Illuminate\Database\Eloquent\Model|null
+     */
+    public function getBy($key, $value);
+}

vendor/tymon/jwt-auth/src/Token.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Tymon\JWTAuth;
+
+use Tymon\JWTAuth\Validators\TokenValidator;
+
+class Token
+{
+    /**
+     * @var string
+     */
+    private $value;
+
+    /**
+     * Create a new JSON Web Token
+     *
+     * @param string  $value
+     */
+    public function __construct($value)
+    {
+        with(new TokenValidator)->check($value);
+
+        $this->value = $value;
+    }
+
+    /**
+     * Get the token
+     *
+     * @return string
+     */
+    public function get()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Get the token when casting to string
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return (string) $this->value;
+    }
+}

vendor/tymon/jwt-auth/src/Utils.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Tymon\JWTAuth;
+
+use Carbon\Carbon;
+
+class Utils
+{
+    /**
+     * Get the Carbon instance for the current time
+     *
+     * @return \Carbon\Carbon
+     */
+    public static function now()
+    {
+        return Carbon::now();
+    }
+
+    /**
+     * Get the Carbon instance for the timestamp
+     *
+     * @param  int  $timestamp
+     * @return \Carbon\Carbon
+     */
+    public static function timestamp($timestamp)
+    {
+        return Carbon::createFromTimeStampUTC($timestamp);
+    }
+}

vendor/tymon/jwt-auth/src/Validators/AbstractValidator.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Tymon\JWTAuth\Validators;
+
+use Tymon\JWTAuth\Exceptions\JWTException;
+
+abstract class AbstractValidator implements ValidatorInterface
+{
+    /**
+     * @var bool
+     */
+    protected $refreshFlow = false;
+
+    /**
+     * Helper function to return a boolean
+     *
+     * @param  array  $value
+     * @return bool
+     */
+    public function isValid($value)
+    {
+        try {
+            $this->check($value);
+        } catch (JWTException $e) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Set the refresh flow flag
+     *
+     * @param  bool  $refreshFlow
+     * @return $this
+     */
+    public function setRefreshFlow($refreshFlow = true)
+    {
+        $this->refreshFlow = $refreshFlow;
+
+        return $this;
+    }
+}

vendor/tymon/jwt-auth/src/Validators/PayloadValidator.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Tymon\JWTAuth\Validators;
+
+use Tymon\JWTAuth\Utils;
+use Tymon\JWTAuth\Exceptions\TokenExpiredException;
+use Tymon\JWTAuth\Exceptions\TokenInvalidException;
+
+class PayloadValidator extends AbstractValidator
+{
+    /**
+     * @var array
+     */
+    protected $requiredClaims = ['iss', 'iat', 'exp', 'nbf', 'sub', 'jti'];
+
+    /**
+     * @var integer
+     */
+    protected $refreshTTL = 20160;
+
+    /**
+     * Run the validations on the payload array
+     *
+     * @param  array  $value
+     * @return void
+     */
+    public function check($value)
+    {
+        $this->validateStructure($value);
+
+        if (! $this->refreshFlow) {
+            $this->validateTimestamps($value);
+        } else {
+            $this->validateRefresh($value);
+        }
+    }
+
+    /**
+     * Ensure the payload contains the required claims and
+     * the claims have the relevant type
+     *
+     * @param array  $payload
+     * @throws \Tymon\JWTAuth\Exceptions\TokenInvalidException
+     * @return bool
+     */
+    protected function validateStructure(array $payload)
+    {
+        if (count(array_diff_key($this->requiredClaims, array_keys($payload))) !== 0) {
+            throw new TokenInvalidException('JWT payload does not contain the required claims');
+        }
+
+        return true;
+    }
+
+    /**
+     * Validate the payload timestamps
+     *
+     * @param  array  $payload
+     * @throws \Tymon\JWTAuth\Exceptions\TokenExpiredException
+     * @throws \Tymon\JWTAuth\Exceptions\TokenInvalidException
+     * @return boolean
+     */
+    protected function validateTimestamps(array $payload)
+    {
+        if (isset($payload['nbf']) && Utils::timestamp($payload['nbf'])->isFuture()) {
+            throw new TokenInvalidException('Not Before (nbf) timestamp cannot be in the future', 400);
+        }
+
+        if (isset($payload['iat']) && Utils::timestamp($payload['iat'])->isFuture()) {
+            throw new TokenInvalidException('Issued At (iat) timestamp cannot be in the future', 400);
+        }
+
+        if (Utils::timestamp($payload['exp'])->isPast()) {
+            throw new TokenExpiredException('Token has expired');
+        }
+
+        return true;
+    }
+
+    /**
+     * Check the token in the refresh flow context
+     *
+     * @param  $payload
+     * @return bool
+     */
+    protected function validateRefresh(array $payload)
+    {
+        if (isset($payload['iat']) && Utils::timestamp($payload['iat'])->diffInMinutes(Utils::now()) >= $this->refreshTTL) {
+            throw new TokenExpiredException('Token has expired and can no longer be refreshed', 400);
+        }
+
+        return true;
+    }
+
+    /**
+     * Set the required claims
+     *
+     * @param array  $claims
+     */
+    public function setRequiredClaims(array $claims)
+    {
+        $this->requiredClaims = $claims;
+
+        return $this;
+    }
+
+    /**
+     * Set the refresh ttl
+     *
+     * @param integer  $ttl
+     */
+    public function setRefreshTTL($ttl)
+    {
+        $this->refreshTTL = $ttl;
+
+        return $this;
+    }
+}

vendor/tymon/jwt-auth/src/Validators/TokenValidator.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Tymon\JWTAuth\Validators;
+
+use Tymon\JWTAuth\Exceptions\TokenInvalidException;
+
+class TokenValidator extends AbstractValidator
+{
+    /**
+     * Check the structure of the token
+     *
+     * @param string  $value
+     * @return void
+     */
+    public function check($value)
+    {
+        $this->validateStructure($value);
+    }
+
+    /**
+     * @param  string  $token
+     * @throws \Tymon\JWTAuth\Exceptions\TokenInvalidException
+     * @return boolean
+     */
+    protected function validateStructure($token)
+    {
+        if (count(explode('.', $token)) !== 3) {
+            throw new TokenInvalidException('Wrong number of segments');
+        }
+
+        return true;
+    }
+}

vendor/tymon/jwt-auth/src/Validators/ValidatorInterface.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Tymon\JWTAuth\Validators;
+
+interface ValidatorInterface
+{
+    /**
+     * Perform some checks on the value
+     *
+     * @param  mixed  $value
+     * @return void
+     */
+    public function check($value);
+
+    /**
+     * Helper function to return a boolean
+     *
+     * @param  array  $value
+     * @return bool
+     */
+    public function isValid($value);
+}

vendor/tymon/jwt-auth/src/config/config.php

@@ -0,0 +1,168 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | JWT Authentication Secret
+    |--------------------------------------------------------------------------
+    |
+    | Don't forget to set this, as it will be used to sign your tokens.
+    | A helper command is provided for this: `php artisan jwt:generate`
+    |
+    */
+
+    'secret' => env('JWT_SECRET', 'changeme'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | JWT time to live
+    |--------------------------------------------------------------------------
+    |
+    | Specify the length of time (in minutes) that the token will be valid for.
+    | Defaults to 1 hour
+    |
+    */
+
+    'ttl' => 60,
+
+    /*
+    |--------------------------------------------------------------------------
+    | Refresh time to live
+    |--------------------------------------------------------------------------
+    |
+    | Specify the length of time (in minutes) that the token can be refreshed
+    | within. I.E. The user can refresh their token within a 2 week window of
+    | the original token being created until they must re-authenticate.
+    | Defaults to 2 weeks
+    |
+    */
+
+    'refresh_ttl' => 20160,
+
+    /*
+    |--------------------------------------------------------------------------
+    | JWT hashing algorithm
+    |--------------------------------------------------------------------------
+    |
+    | Specify the hashing algorithm that will be used to sign the token.
+    |
+    | See here: https://github.com/namshi/jose/tree/2.2.0/src/Namshi/JOSE/Signer
+    | for possible values
+    |
+    */
+
+    'algo' => 'HS256',
+
+    /*
+    |--------------------------------------------------------------------------
+    | User Model namespace
+    |--------------------------------------------------------------------------
+    |
+    | Specify the full namespace to your User model.
+    | e.g. 'Acme\Entities\User'
+    |
+    */
+
+    'user' => 'App\User',
+
+    /*
+    |--------------------------------------------------------------------------
+    | User identifier
+    |--------------------------------------------------------------------------
+    |
+    | Specify a unique property of the user that will be added as the 'sub'
+    | claim of the token payload.
+    |
+    */
+
+    'identifier' => 'id',
+
+    /*
+    |--------------------------------------------------------------------------
+    | Required Claims
+    |--------------------------------------------------------------------------
+    |
+    | Specify the required claims that must exist in any token.
+    | A TokenInvalidException will be thrown if any of these claims are not
+    | present in the payload.
+    |
+    */
+
+    'required_claims' => ['iss', 'iat', 'exp', 'nbf', 'sub', 'jti'],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Blacklist Enabled
+    |--------------------------------------------------------------------------
+    |
+    | In order to invalidate tokens, you must have the the blacklist enabled.
+    | If you do not want or need this functionality, then set this to false.
+    |
+    */
+
+    'blacklist_enabled' => env('JWT_BLACKLIST_ENABLED', true),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Providers
+    |--------------------------------------------------------------------------
+    |
+    | Specify the various providers used throughout the package.
+    |
+    */
+
+    'providers' => [
+
+        /*
+        |--------------------------------------------------------------------------
+        | User Provider
+        |--------------------------------------------------------------------------
+        |
+        | Specify the provider that is used to find the user based
+        | on the subject claim
+        |
+        */
+
+        'user' => 'Tymon\JWTAuth\Providers\User\EloquentUserAdapter',
+
+        /*
+        |--------------------------------------------------------------------------
+        | JWT Provider
+        |--------------------------------------------------------------------------
+        |
+        | Specify the provider that is used to create and decode the tokens.
+        |
+        */
+
+        'jwt' => 'Tymon\JWTAuth\Providers\JWT\NamshiAdapter',
+
+        /*
+        |--------------------------------------------------------------------------
+        | Authentication Provider
+        |--------------------------------------------------------------------------
+        |
+        | Specify the provider that is used to authenticate users.
+        |
+        */
+
+        'auth' => function ($app) {
+            return new Tymon\JWTAuth\Providers\Auth\IlluminateAuthAdapter($app['auth']);
+        },
+
+        /*
+        |--------------------------------------------------------------------------
+        | Storage Provider
+        |--------------------------------------------------------------------------
+        |
+        | Specify the provider that is used to store tokens in the blacklist
+        |
+        */
+
+        'storage' => function ($app) {
+            return new Tymon\JWTAuth\Providers\Storage\IlluminateCacheAdapter($app['cache']);
+        }
+
+    ]
+
+];