@super-protocol/sp-cli 0.0.2 → 0.0.3

package/dist/commands/workflows/extend-lease.js

@@ -0,0 +1,94 @@
+import { select } from '@clack/prompts';
+import { Args, Flags } from '@oclif/core';
+import { Orders } from '@super-protocol/sdk-js';
+import { formatEther, parseEther } from 'viem/utils';
+import { BaseCommand } from '../base.js';
+export default class WorkflowsExtendLease extends BaseCommand {
+    static args = {
+        orderId: Args.string({ description: 'Order ID', required: true }),
+    };
+    static description = 'Replenish deposit for a workflow to extend its lease time';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <orderId> --sppi 1.5',
+        '<%= config.bin %> <%= command.id %> <orderId> --minutes 120',
+        '<%= config.bin %> <%= command.id %> <orderId> --sppi 2 --yes',
+    ];
+    static flags = {
+        minutes: Flags.integer({ description: 'Time to extend order in minutes (automatically calculates tokens)' }),
+        sppi: Flags.string({ description: 'SPPI token amount to add to the order' }),
+        yes: Flags.boolean({ char: 'y', default: false, description: 'Skip confirmation prompt' }),
+    };
+    async init() {
+        await super.init();
+        await this.container
+            .initConfigManager()
+            .initAccountManager()
+            .initBlockchainConnector()
+            .initProviderClient({ enableAuth: true })
+            .build();
+    }
+    async run() {
+        const { args, flags } = await this.parse(WorkflowsExtendLease);
+        const { providerClient } = this.container;
+        try {
+            this.logger.info(`Checking order ${args.orderId}`);
+            // Get actual per-hour price from blockchain
+            const amountPerHour = await Orders.calculateWorkflowPerHourPrice(args.orderId);
+            let tokenAmount;
+            let minutes;
+            if (flags.minutes) {
+                // Calculate token amount from minutes
+                tokenAmount = (BigInt(amountPerHour) * BigInt(flags.minutes)) / 60n;
+                minutes = flags.minutes;
+            }
+            else if (flags.sppi) {
+                // Use provided SPPI amount
+                tokenAmount = parseEther(flags.sppi);
+                minutes = Number((tokenAmount * 60n) / BigInt(amountPerHour));
+            }
+            else {
+                this.error('Please provide either --sppi or --minutes flag to specify the replenishment amount');
+                return;
+            }
+            // Confirmation prompt
+            const confirmed = this.flags.yes || await this.selectPrompt({
+                message: `Deposit will be replenished by ${formatEther(tokenAmount)} SPPI. Order time is extended by ${minutes} minutes. Confirm?`,
+                options: [
+                    { label: 'Yes', value: true },
+                    { label: 'No', value: false },
+                ],
+            });
+            if (!confirmed) {
+                this.logger.info('Operation cancelled by user');
+                return;
+            }
+            // Call API to replenish deposit
+            const { data, error } = await providerClient.POST('/api/workflows/{orderId}/replenish', {
+                body: {
+                    amount: tokenAmount.toString(),
+                },
+                params: {
+                    path: {
+                        orderId: args.orderId,
+                    },
+                },
+            });
+            if (error) {
+                this.logger.error({ error }, `Order ${args.orderId} was not replenished`);
+                this.error(`Failed to replenish deposit: ${error.message || 'Unknown error'}`);
+                return;
+            }
+            this.logger.info({ data }, 'Deposit replenished successfully');
+            this.log('Deposit replenished successfully');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error({ error }, `Order ${args.orderId} was not replenished`);
+            this.error(`Order ${args.orderId} was not replenished: ${errorMessage}`);
+        }
+    }
+    async selectPrompt(options) {
+        const result = await select(options);
+        return this.ensurePromptValue(result);
+    }
+}

package/dist/config/config-file.schema.d.ts

@@ -1,6 +1,6 @@
-import { Static } from '@sinclair/typebox';
-export declare const configFileManagerSchema: import("@sinclair/typebox").TObject<{
-    configs: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-    currentConfig: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+import { Static, Type } from 'typebox';
+export declare const configFileManagerSchema: Type.TObject<{
+    configs: Type.TArray<Type.TString>;
+    currentConfig: Type.TOptional<Type.TString>;
 }>;
 export type ConfigFileManagerData = Static<typeof configFileManagerSchema>;

package/dist/config/config-file.schema.js

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 export const configFileManagerSchema = Type.Object({
     configs: Type.Array(Type.String()),
     currentConfig: Type.Optional(Type.String()),

package/dist/config/config.schema.d.ts

@@ -1,23 +1,33 @@
-import { Static } from '@sinclair/typebox';
-export declare const accountSchema: import("@sinclair/typebox").TObject<{
-    address: import("@sinclair/typebox").TString;
-    privateKey: import("@sinclair/typebox").TString;
+import { Static, Type } from 'typebox';
+export declare const accountSchema: Type.TObject<{
+    address: Type.TString;
+    privateKey: Type.TString;
 }>;
-export declare const authSchema: import("@sinclair/typebox").TObject<{
-    accessKey: import("@sinclair/typebox").TString;
+export declare const authSchema: Type.TObject<{
+    accessKey: Type.TString;
 }>;
-export declare const cliConfigSchema: import("@sinclair/typebox").TObject<{
-    account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        address: import("@sinclair/typebox").TString;
-        privateKey: import("@sinclair/typebox").TString;
+export declare const blockchainSchema: Type.TObject<{
+    blockchainUrl: Type.TOptional<Type.TString>;
+    contractAddress: Type.TString;
+}>;
+export declare const cliConfigSchema: Type.TObject<{
+    account: Type.TOptional<Type.TObject<{
+        address: Type.TString;
+        privateKey: Type.TString;
+    }>>;
+    auth: Type.TOptional<Type.TObject<{
+        accessKey: Type.TString;
     }>>;
-    auth: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        accessKey: import("@sinclair/typebox").TString;
+    blockchain: Type.TOptional<Type.TObject<{
+        blockchainUrl: Type.TOptional<Type.TString>;
+        contractAddress: Type.TString;
     }>>;
-    cookies: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
-    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    providerUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    cookies: Type.TOptional<Type.TUnknown>;
+    name: Type.TOptional<Type.TString>;
+    providerUrl: Type.TOptional<Type.TString>;
+    selectedStorage: Type.TOptional<Type.TString>;
 }>;
 export type CliConfig = Static<typeof cliConfigSchema>;
 export type Account = Static<typeof accountSchema>;
 export type Auth = Static<typeof authSchema>;
+export type Blockchain = Static<typeof blockchainSchema>;

package/dist/config/config.schema.js

@@ -1,13 +1,4 @@
-import { FormatRegistry, Type } from '@sinclair/typebox';
-FormatRegistry.Set('url', (value) => {
-    try {
-        const u = new URL(value);
-        return u.protocol === 'http:' || u.protocol === 'https:';
-    }
-    catch {
-        return false;
-    }
-});
+import { Type } from 'typebox';
 export const accountSchema = Type.Object({
     address: Type.String({ pattern: '^0x[a-fA-F0-9]{40}$' }),
     privateKey: Type.String({ pattern: '^0x[a-fA-F0-9]{64}$' }),
@@ -15,10 +6,16 @@ export const accountSchema = Type.Object({
 export const authSchema = Type.Object({
     accessKey: Type.String(),
 });
+export const blockchainSchema = Type.Object({
+    blockchainUrl: Type.Optional(Type.String({ format: 'url' })),
+    contractAddress: Type.String({ pattern: '^0x[a-fA-F0-9]{40}$' }),
+});
 export const cliConfigSchema = Type.Object({
     account: Type.Optional(accountSchema),
     auth: Type.Optional(authSchema),
+    blockchain: Type.Optional(blockchainSchema),
     cookies: Type.Optional(Type.Unknown()),
     name: Type.Optional(Type.String()),
     providerUrl: Type.Optional(Type.String({ format: 'url' })),
+    selectedStorage: Type.Optional(Type.String({ maxLength: 36, minLength: 36 })),
 });

package/dist/constants.d.ts

@@ -1,3 +1,8 @@
 export declare const FILE_ACCESS_PERMS = 384;
 export declare const DIR_ACCESS_PERMS = 448;
 export declare const PROVIDER_URL = "https://api.dp.superprotocol.com";
+export declare const REFRESH_TOKEN_URI = "/api/auth/refresh-access";
+export declare const S3_ENDPOINT = "https://gateway.storjshare.io";
+export declare const S3_REGION = "us-east-1";
+export declare const DEFAULT_USER_CONFIG_FILE = "default.config.json";
+export declare const DEFAULT_USER_CONFIG_NAME = "Default";

package/dist/constants.js

@@ -3,3 +3,8 @@ export const FILE_ACCESS_PERMS = 0o600;
 //  Directory permissions.     'drwx------'
 export const DIR_ACCESS_PERMS = 0o700;
 export const PROVIDER_URL = 'https://api.dp.superprotocol.com';
+export const REFRESH_TOKEN_URI = '/api/auth/refresh-access';
+export const S3_ENDPOINT = 'https://gateway.storjshare.io';
+export const S3_REGION = 'us-east-1';
+export const DEFAULT_USER_CONFIG_FILE = 'default.config.json';
+export const DEFAULT_USER_CONFIG_NAME = 'Default';

package/dist/errors.d.ts

@@ -6,3 +6,5 @@ export declare class InvalidPrivateKeyError extends Error {
 }
 export declare class AuthorizationRequiredError extends Error {
 }
+export declare class ProviderClientError extends Error {
+}

package/dist/errors.js

@@ -6,3 +6,5 @@ export class InvalidPrivateKeyError extends Error {
 }
 export class AuthorizationRequiredError extends Error {
 }
+export class ProviderClientError extends Error {
+}

package/dist/hooks/finally/shutdown-blockchain.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'finally'>;
+export default hook;

package/dist/hooks/finally/shutdown-blockchain.js

@@ -0,0 +1,8 @@
+import { BlockchainConnector } from '@super-protocol/sdk-js';
+const hook = async function () {
+    const connector = BlockchainConnector.getInstance();
+    if (connector.isInitialized()) {
+        connector.shutdown();
+    }
+};
+export default hook;

package/dist/lib/container.d.ts

@@ -3,7 +3,6 @@ import { ProviderClient } from '@super-protocol/provider-client';
 import { AccountManager, ConfigFileManager, ConfigManager } from '../managers/index.js';
 interface RuntimeConfig {
     configFile?: string;
-    url?: string;
 }
 export declare class AppContainer {
     readonly cwdDir: string;
@@ -17,7 +16,6 @@ export declare class AppContainer {
     private readonly initQueue;
     private logger;
     private runtimeConfigFile?;
-    private runtimeProviderUrl?;
     private constructor();
     static initialize(currentDir: string, config: Config): AppContainer;
     get accountManager(): AccountManager;
@@ -25,13 +23,15 @@ export declare class AppContainer {
     get configManager(): ConfigManager;
     static get container(): AppContainer;
     get providerClient(): ProviderClient;
-    build(): Promise<void>;
-    initAccountManager(): this;
-    initConfigFileManager(): this;
-    initConfigManager(): this;
-    initProviderClient({ enableAuth, enableCookies }?: {
+    build(): Promise<this>;
+    initAccountManager(rebuild?: boolean): this;
+    initBlockchainConnector(): this;
+    initConfigFileManager(rebuild?: boolean): this;
+    initConfigManager(rebuild?: boolean): this;
+    initProviderClient({ enableAuth, enableCookies, rebuild }?: {
         enableAuth?: boolean;
         enableCookies?: boolean;
+        rebuild?: boolean;
     }): this;
     setupRuntimeConfig(config: RuntimeConfig): this;
     private queueInit;

package/dist/lib/container.js

@@ -1,4 +1,5 @@
 import { createProviderClient, loggerMiddleware, requestIdMiddleware, } from '@super-protocol/provider-client';
+import { BlockchainConnector } from '@super-protocol/sdk-js';
 import path from 'node:path';
 import { PROVIDER_URL } from '../constants.js';
 import logger from '../logger.js';
@@ -17,7 +18,6 @@ export class AppContainer {
     initQueue = new Map();
     logger;
     runtimeConfigFile;
-    runtimeProviderUrl;
     constructor(cwdDir, oclifConfig) {
         this.cwdDir = cwdDir;
         this.oclifConfig = oclifConfig;
@@ -61,9 +61,10 @@ export class AppContainer {
     }
     async build() {
         await Promise.all(this.initPromises);
+        return this;
     }
-    initAccountManager() {
-        this.initConfigManager();
+    initAccountManager(rebuild = true) {
+        this.initConfigManager(rebuild);
         return this.queueInit('accountManager', async () => {
             await this.waitFor('configManager');
             if (this._accountManager) {
@@ -73,9 +74,30 @@ export class AppContainer {
             const accountManager = new AccountManager(this.configManager, this.logger);
             await accountManager.init();
             this._accountManager = accountManager;
+        }, rebuild);
+    }
+    initBlockchainConnector() {
+        this.initConfigManager();
+        return this.queueInit('blockchainConnector', async () => {
+            await this.waitFor('configManager');
+            let blockchainConfig = await this.configManager.get('blockchain');
+            if (!blockchainConfig) {
+                await this.waitFor('providerClient');
+                const { data, error } = await this.providerClient.GET('/api/config');
+                if (error || !data) {
+                    throw new Error('Could not get configuration from provider');
+                }
+                blockchainConfig = {
+                    blockchainUrl: data.blockchainUrl,
+                    contractAddress: data.contractAddress,
+                };
+                await this.configManager.set('blockchain', blockchainConfig);
+            }
+            this.logger.info('Initializing blockchain connector');
+            await BlockchainConnector.getInstance().initialize(blockchainConfig);
         });
     }
-    initConfigFileManager() {
+    initConfigFileManager(rebuild = false) {
         return this.queueInit('configFileManager', async () => {
             if (this._configFileManager) {
                 return;
@@ -85,16 +107,16 @@ export class AppContainer {
             });
             await configFileManager.init();
             this._configFileManager = configFileManager;
-        });
+        }, rebuild);
     }
-    initConfigManager() {
-        this.initConfigFileManager();
+    initConfigManager(rebuild = false) {
+        this.initConfigFileManager(rebuild);
         return this.queueInit('configManager', async () => {
             await this.waitFor('configFileManager');
             if (this._configManager) {
                 return;
             }
-            const configFilePath = this.configFileManager.getCurrentConfigPath();
+            const configFilePath = await this.configFileManager.getCurrentConfigPath();
             if (!configFilePath) {
                 throw new Error('Config file not found');
             }
@@ -102,22 +124,32 @@ export class AppContainer {
             const configManager = new ConfigManager(configFilePath, this.logger);
             await configManager.init();
             this._configManager = configManager;
-        });
+        }, rebuild);
     }
-    initProviderClient({ enableAuth = true, enableCookies = true } = {}) {
+    initProviderClient({ enableAuth = true, enableCookies = true, rebuild = false } = {}) {
         this.initConfigManager();
         return this.queueInit('providerClient', async () => {
-            if (this._providerClient) {
+            if (this._providerClient && !rebuild) {
                 return;
             }
             await this.waitFor('configManager');
-            const providerUrl = this.runtimeProviderUrl || await this.configManager.get('providerUrl') || PROVIDER_URL;
+            const providerUrl = await this.configManager.get('providerUrl') || PROVIDER_URL;
             this.logger.info('Initializing provider client');
             const providerClient = createProviderClient({
                 baseUrl: providerUrl,
                 logger: this.logger,
                 middlewares: [requestIdMiddleware, loggerMiddleware],
             });
+            if (enableCookies) {
+                this.logger.info('Initializing cookie middleware');
+                const cookiesMiddleware = await createCookieMiddleware(this.configManager, this.logger, providerUrl);
+                providerClient.use(cookiesMiddleware);
+            }
+            if (enableAuth) {
+                this.logger.info('Initializing auth middleware');
+                const authMiddleware = await createAuthMiddleware(this.configManager, providerClient, this.logger);
+                providerClient.use(authMiddleware);
+            }
             providerClient.use({
                 onRequest: async ({ request }) => {
                     const req = request.clone();
@@ -128,28 +160,18 @@ export class AppContainer {
                     }
                     this.logger.debug({
                         body,
+                        token: req.headers.get('Authorization'),
                         url: req.url,
                     }, 'Requesting');
                 },
             });
-            if (enableCookies) {
-                this.logger.info('Initializing cookie middleware');
-                const cookiesMiddleware = await createCookieMiddleware(this.configManager, this.logger, providerUrl);
-                providerClient.use(cookiesMiddleware);
-            }
-            if (enableAuth) {
-                this.logger.info('Initializing auth middleware');
-                const authMiddleware = await createAuthMiddleware(this.configManager, providerClient, this.logger);
-                providerClient.use(authMiddleware);
-            }
             this._providerClient = providerClient;
-        });
+        }, rebuild);
     }
     setupRuntimeConfig(config) {
         if (this.initQueue.size > 0) {
             throw new Error('Cannot change runtime config after initialization has started');
         }
-        this.runtimeProviderUrl = config.url;
         if (config.configFile) {
             this.runtimeConfigFile = path.isAbsolute(config.configFile)
                 ? config.configFile
@@ -160,8 +182,8 @@ export class AppContainer {
         }
         return this;
     }
-    queueInit(name, task) {
-        if (!this.initQueue.has(name)) {
+    queueInit(name, task, force = false) {
+        if (!this.initQueue.has(name) || force) {
             const promise = task();
             this.initQueue.set(name, promise);
             this.initPromises.push(promise);

package/dist/managers/account-manager.d.ts

@@ -13,5 +13,6 @@ export declare class AccountManager implements IAccountManager {
     createSign(nonce: string): Promise<string>;
     getAddress(): string;
     init(): Promise<void>;
+    interactWithUser(): Promise<void>;
     promptAccount(): Promise<Account>;
 }

package/dist/managers/account-manager.js

@@ -4,9 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { confirm, password } from '@inquirer/prompts';
+import { confirm, isCancel, password } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import { Value } from '@sinclair/typebox/value';
+import { Value } from 'typebox/value';
 import { Retryable } from 'typescript-retry-decorator';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { accountSchema } from '../config/config.schema.js';
@@ -65,24 +65,38 @@ export class AccountManager {
         }
         catch (error) {
             this.logger.warn({ err: error }, 'Incorrect config file');
-            ux.warn('Config not found or have errors');
-            const ask = await confirm({
-                message: 'Do you want to create new one?',
-            });
-            if (ask) {
-                await this.promptAccount();
-            }
-            else {
-                ux.error('Credentials not generated please check config file and rerun command again', { exit: 1 });
-            }
+            await this.interactWithUser();
+        }
+    }
+    async interactWithUser() {
+        ux.warn("Account doesn't exist in current configuration");
+        const ask = await confirm({
+            message: 'Do you want to create a new account?',
+        });
+        if (isCancel(ask)) {
+            ux.error('Operation cancelled.', { exit: 1 });
+        }
+        if (ask) {
+            await this.promptAccount();
+        }
+        else {
+            ux.error('Credentials not generated please check config file and rerun command again', { exit: 1 });
         }
     }
     async promptAccount() {
         const askPrivateKey = await confirm({
+            initialValue: false,
             message: 'Do you want to input privateKey?',
         });
+        if (isCancel(askPrivateKey)) {
+            ux.error('Operation cancelled.', { exit: 1 });
+        }
         if (askPrivateKey) {
-            const privateKey = await password({ message: 'Please input your privateKey for using in account' });
+            const privateKeyInput = await password({ message: 'Please input your privateKey for using in account' });
+            if (isCancel(privateKeyInput)) {
+                ux.error('Operation cancelled.', { exit: 1 });
+            }
+            const privateKey = privateKeyInput.trim();
             try {
                 const account = await this.createFromKey(privateKey);
                 ux.stdout('Your privateKey will be used in config. Keypair created');

package/dist/managers/config-file-manager.d.ts

@@ -1,4 +1,4 @@
-import { confirm, select } from '@inquirer/prompts';
+import { confirm, select } from '@clack/prompts';
 import { ux } from '@oclif/core';
 import pino from 'pino';
 import { CliConfig } from '../config/config.schema.js';
@@ -37,7 +37,7 @@ export declare class ConfigFileManager implements IManager {
         name: string;
     }>;
     getCurrentConfigFile(): string | undefined;
-    getCurrentConfigPath(): string | undefined;
+    getCurrentConfigPath(): Promise<string>;
     importConfig(sourcePath: string, targetName?: string): Promise<string>;
     init(): Promise<void>;
     removeConfig(configName: string): Promise<void>;

package/dist/managers/config-file-manager.js

@@ -1,10 +1,10 @@
-import { confirm, select } from '@inquirer/prompts';
+import { confirm, isCancel, select } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import { Value } from '@sinclair/typebox/value';
 import * as fs from 'node:fs';
 import path from 'node:path';
+import { Value } from 'typebox/value';
 import { cliConfigSchema } from '../config/config.schema.js';
-import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
+import { DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME, DIR_ACCESS_PERMS, FILE_ACCESS_PERMS, } from '../constants.js';
 import { getConfigName } from '../utils/helper.js';
 export class ConfigFileManager {
     logger;
@@ -78,22 +78,27 @@ export class ConfigFileManager {
             configToDelete = config.file;
         }
         else {
-            configToDelete = await this.selectPrompt({
-                choices: configs.map(config => ({
-                    name: config.name,
+            const selection = await this.selectPrompt({
+                message: 'Select configuration to delete:',
+                options: configs.map(config => ({
+                    label: config.name,
                     value: config.file,
                 })),
-                message: 'Select configuration to delete:',
             });
+            if (isCancel(selection)) {
+                this.ux.stdout('Deletion cancelled');
+                return;
+            }
+            configToDelete = selection;
         }
         const configToDeleteData = configs.find(c => c.file === configToDelete);
         const displayName = configToDeleteData?.name || configToDelete;
         if (!force) {
             const confirmed = await this.confirmPrompt({
-                default: false,
+                initialValue: false,
                 message: `Are you sure you want to delete configuration "${displayName}"?`,
             });
-            if (!confirmed) {
+            if (isCancel(confirmed) || !confirmed) {
                 this.ux.stdout('Deletion cancelled');
                 return;
             }
@@ -160,14 +165,26 @@ export class ConfigFileManager {
         }
         return this.configs.currentConfig;
     }
-    getCurrentConfigPath() {
+    async getCurrentConfigPath() {
         if (this.runtimeConfigFile) {
             return this.runtimeConfigFile;
         }
         if (!this.configs.currentConfig) {
-            return undefined;
+            try {
+                await this.createConfig(DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME);
+            }
+            catch {
+                //
+            }
+            try {
+                await this.setCurrentConfig(DEFAULT_USER_CONFIG_FILE);
+            }
+            catch (error) {
+                this.logger.error({ err: error }, 'Failed to set default config');
+                throw error;
+            }
         }
-        return path.join(this.configsDir, this.configs.currentConfig);
+        return path.join(this.configsDir, this.configs.currentConfig || DEFAULT_USER_CONFIG_FILE);
     }
     async importConfig(sourcePath, targetName) {
         if (!fs.existsSync(sourcePath)) {

package/dist/middlewares/auth-middleware.js

@@ -1,4 +1,5 @@
 import { decode } from 'jsonwebtoken';
+import { REFRESH_TOKEN_URI } from '../constants.js';
 import { AuthorizationRequiredError } from '../errors.js';
 function isAccessKeyExpired(accessKey) {
     try {
@@ -23,7 +24,7 @@ export async function createAuthMiddleware(configManager, providerClient, logger
         logger.info('Performed refresh token');
         let refreshResult;
         try {
-            refreshResult = await providerClient.POST('/api/auth/refresh-access');
+            refreshResult = await providerClient.POST(REFRESH_TOKEN_URI);
         }
         catch (error) {
             logger.error({ err: error }, 'failure refresh token');
@@ -76,6 +77,9 @@ export async function createAuthMiddleware(configManager, providerClient, logger
     }
     const middleware = {
         async onRequest({ request }) {
+            if (request.url.endsWith(REFRESH_TOKEN_URI)) {
+                return request;
+            }
             const accessToken = await ensureAccessKey();
             if (accessToken) {
                 request.headers.set('Authorization', `Bearer ${accessToken}`);

package/dist/services/auth.service.d.ts

@@ -0,0 +1,24 @@
+import { ProviderClient } from '@super-protocol/provider-client';
+import pino from 'pino';
+import { AccountManager } from '../managers/account-manager.js';
+import { ConfigManager } from '../managers/config-manager.js';
+export declare class AuthError extends Error {
+}
+export declare class AuthService {
+    private readonly accountManager;
+    private readonly configManager;
+    private readonly providerClient;
+    private readonly logger;
+    constructor(accountManager: AccountManager, configManager: ConfigManager, providerClient: ProviderClient, logger: pino.BaseLogger);
+    auth(): Promise<void>;
+    getTokens(nonce: string): Promise<void>;
+    getUserNonce(address: string): Promise<{
+        error: {
+            message: string;
+            statusCode: number;
+        } | undefined;
+        user: {
+            nonce?: string;
+        } | undefined;
+    }>;
+}