@flashbacktech/flashbackclient 0.1.28 → 0.1.31

package/dist/api/client.d.ts

@@ -1,6 +1,6 @@
 import { CreateUnitRequest, CreateUnitResponse, CreateRepoRequest, CreateRepoResponse, StorageUnit, CreateRepoKeyRequest, CreateRepoKeyResponse, GetUnitsResponse, GetReposResponse, GetRepoKeysResponse, UpdateUnitRequest, UpdateUnitResponse, ActionResponse, UpdateRepoRequest, UpdateRepoResponse, UpdateRepoKeyRequest, UpdateRepoKeyResponse, ValidateUnitRequest, ValidateUnitResponse, ValidateRepoUnitsRequest, ValidateRepoUnitsResponse, StorageUnitStatusResponse, GetUnitNodeStatsResponse, GetUnitNodeStatsRequest, CreateBucketRequest, CreateBucketResponse, UpdateBucketRequest, UpdateBucketResponse, ValidateBucketRequest, ValidateBucketResponse, StorageBucket, GetBucketsResponse, StorageBucketStatusResponse, GetBucketNodeStatsRequest, GetBucketNodeStatsResponse, CreateRepoWithBucketsRequest, UpdateRepoWithBucketsRequest, ValidateRepoBucketsRequest, ValidateRepoBucketsResponse } from './types/storage';
 import { IApiClient, ProviderType } from './interfaces';
-import { ActivateResponse, DeactivateResponse, LoginBody, LoginResponse, LogoutResponse, OAuth2ResponseDTO, RefreshTokenErrorResponse, RefreshTokenResponse, RegisterBody, RegisterResponse, ResetPasswordBody } from './types/auth';
+import { ActivateResponse, DeactivateResponse, LoginBody, LoginResponse, LogoutResponse, OAuth2ResponseDTO, RefreshTokenErrorResponse, RefreshTokenResponse, RegisterBody, RegisterResponse, ResetPasswordBody, Web3RegisterBody } from './types/auth';
 import { StatsQueryParams, StatsResponse, NodeStatsMinuteResponse, NodeStatsDailyResponse, NodeStatsQueryParams, UnitStatsResponse, RepoStatsResponse, NodeStatsDailyQueryParams, BucketStatsResponse, StatsQueryWithBucketParams, NodeStatsQueryWithBucketParams, NodeStatsDailyQueryWithBucketParams } from './types/stats';
 import { NodeInfo } from './types/bridge';
 import { QuotaResponse } from './types/quota';
@@ -33,10 +33,15 @@ export declare class ApiClient implements IApiClient {
      * @returns The refreshed token
      */
     refreshToken: (refreshToken: string, provider: ProviderType) => Promise<RefreshTokenResponse | RefreshTokenErrorResponse>;
-    private authenticateWeb3Stellar;
     private makeRequest;
     private authenticateGoogle;
     private authenticateGithub;
+    /**
+     * Authenticate with a web3 provider
+     * @param data - The data to authenticate with
+     * @returns The authentication response
+     */
+    web3Authenticate: (data: Web3RegisterBody) => Promise<any>;
     private refreshGoogleToken;
     private refreshGithubToken;
     private exchangeGoogleCode;

package/dist/api/client.js

@@ -33,7 +33,7 @@ class ApiClient {
                 case interfaces_1.ProviderType.GITHUB:
                     return this.authenticateGithub(token);
                 case interfaces_1.ProviderType.WEB3_STELLAR:
-                    return this.authenticateWeb3Stellar(token);
+                    throw new Error('Call web3Authenticate for web3 authentication');
                 case interfaces_1.ProviderType.LOCAL:
                     throw new Error('Call userLogin for local authentication');
                 default:
@@ -71,14 +71,12 @@ class ApiClient {
                 case interfaces_1.ProviderType.GITHUB:
                     return this.refreshGithubToken(refreshToken);
                 case interfaces_1.ProviderType.LOCAL:
+                case interfaces_1.ProviderType.WEB3_STELLAR:
                     return this.userRefresh(refreshToken);
                 default:
                     throw new Error(`Unsupported provider: ${provider}`);
             }
         };
-        this.authenticateWeb3Stellar = async (token) => {
-            throw new Error('Not implemented');
-        };
         this.makeRequest = async (path, method, data) => {
             const isFormData = data instanceof FormData;
             const options = {
@@ -136,6 +134,14 @@ class ApiClient {
             this.setAuthToken(code);
             return this.makeRequest('auth/github', 'POST', { code });
         };
+        /**
+         * Authenticate with a web3 provider
+         * @param data - The data to authenticate with
+         * @returns The authentication response
+         */
+        this.web3Authenticate = async (data) => {
+            return this.makeRequest('auth/web3', 'POST', data);
+        };
         this.refreshGoogleToken = async (refreshToken) => {
             return this.makeRequest('auth/google/refresh', 'POST', {
                 refresh_token: refreshToken,

package/dist/api/types/auth.d.ts

@@ -35,6 +35,12 @@ export interface JwtPayload {
     iat?: number;
     exp?: number;
 }
+export interface Web3RegisterBody {
+    address: string;
+    network: string;
+    signature: string;
+    nonce: string;
+}
 export interface RegisterBody {
     email: string;
     password: string;

package/dist/stellarv2/bucket.d.ts

@@ -0,0 +1,111 @@
+import { ClientContext } from './client';
+import { Bucket, BucketCreateParams, BucketUpdateBasicParams, BucketUpdatePricingParams, BucketUpdateSLAParams } from './models';
+/**
+ * Bucket operations client for FlashOnStellar V2
+ * Implements all bucket-related contract methods
+ */
+export declare class BucketOps {
+    private context;
+    constructor(context: ClientContext);
+    /**
+     * Creates a new bucket for a provider
+     * @param provider_id - Address of the provider creating the bucket
+     * @param params - Bucket creation parameters
+     * @returns Promise resolving to the created bucket ID
+     */
+    createBucket(provider_id: string, params: BucketCreateParams): Promise<number>;
+    /**
+     * Creates a bucket from an existing bucket object
+     * @param bucket - Existing bucket object to clone
+     * @returns Promise resolving to the created bucket ID
+     */
+    /**
+     * Updates basic bucket information (name, region, country)
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to update
+     * @param params - Basic update parameters
+     * @returns Promise resolving to the update result
+     */
+    updateBucketBasic(provider_id: string, bucket_id: number, params: BucketUpdateBasicParams): Promise<boolean>;
+    /**
+     * Updates bucket pricing and capacity information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to update
+     * @param params - Pricing update parameters
+     * @returns Promise resolving to the update result
+     */
+    updateBucketPricing(provider_id: string, bucket_id: number, params: BucketUpdatePricingParams): Promise<boolean>;
+    /**
+     * Updates bucket SLA information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to update
+     * @param params - SLA update parameters
+     * @returns Promise resolving to the update result
+     */
+    updateBucketSLA(provider_id: string, bucket_id: number, params: BucketUpdateSLAParams): Promise<boolean>;
+    /**
+     * Locks a bucket to prevent modifications during active deals
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to lock
+     * @returns Promise resolving to the lock result
+     */
+    lockBucket(provider_id: string, bucket_id: number): Promise<boolean>;
+    /**
+     * Unlocks a bucket to allow modifications
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to unlock
+     * @returns Promise resolving to the unlock result
+     */
+    unlockBucket(provider_id: string, bucket_id: number): Promise<boolean>;
+    /**
+     * Deletes a bucket from the system
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to delete
+     * @returns Promise resolving to the deletion result
+     */
+    deleteBucket(provider_id: string, bucket_id: number): Promise<boolean>;
+    /**
+     * Retrieves bucket information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to retrieve
+     * @returns Promise resolving to Bucket object or null if not found
+     */
+    getBucket(provider_id: string, bucket_id: number): Promise<Bucket | null>;
+    /**
+     * Gets the total count of buckets in the system
+     * @returns Promise resolving to the total number of buckets
+     */
+    getBucketCount(): Promise<number>;
+    /**
+     * Retrieves a paginated list of all buckets
+     * @param skip - Number of items to skip for pagination
+     * @param take - Number of items to take per page
+     * @returns Promise resolving to an array of Bucket objects
+     */
+    getBuckets(skip?: number, take?: number): Promise<Bucket[]>;
+    /**
+     * Retrieves all buckets owned by a specific provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of Bucket objects
+     */
+    getBucketsByProvider(provider_id: string): Promise<Bucket[]>;
+    /**
+     * Checks if a bucket is locked
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to check
+     * @returns Promise resolving to true if the bucket is locked, false otherwise
+     */
+    isBucketLocked(provider_id: string, bucket_id: number): Promise<boolean>;
+    /**
+     * Gets bucket pricing information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket
+     * @returns Promise resolving to pricing information or null if bucket not found
+     */
+    getBucketPricing(provider_id: string, bucket_id: number): Promise<{
+        price_per_gb_storage: bigint;
+        price_per_gb_egress: bigint;
+        max_storage_gb: number;
+        max_egress_gb: number;
+    } | null>;
+}

package/dist/stellarv2/bucket.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketOps = void 0;
+const transaction_1 = require("./transaction");
+/**
+ * Bucket operations client for FlashOnStellar V2
+ * Implements all bucket-related contract methods
+ */
+class BucketOps {
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Creates a new bucket for a provider
+     * @param provider_id - Address of the provider creating the bucket
+     * @param params - Bucket creation parameters
+     * @returns Promise resolving to the created bucket ID
+     */
+    async createBucket(provider_id, params) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'create_bucket',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: params.name, type: 'string' },
+                { value: params.region, type: 'string' },
+                { value: params.country, type: 'string' },
+                { value: params.versioning_enabled, type: 'bool' },
+                { value: params.fb_bucket_id, type: 'string' },
+                { value: params.api_compatibility, type: 'string' },
+                { value: params.price_per_gb_storage, type: 'u128' },
+                { value: params.price_per_gb_egress, type: 'u128' }
+            ]
+        });
+        if (typeof result === 'number') {
+            return result;
+        }
+        throw new Error('Failed to create bucket');
+    }
+    /**
+     * Creates a bucket from an existing bucket object
+     * @param bucket - Existing bucket object to clone
+     * @returns Promise resolving to the created bucket ID
+     */
+    /*
+    async createFromBucket(bucket: Bucket): Promise<number> {
+      const result = await callContractMethod(this.context, bucket.provider_id, {
+        method: 'create_from_bucket',
+        args: [
+          { value: bucket, type: 'string' } // Note: This might need adjustment based on how the contract expects the bucket parameter
+        ]
+      });
+  
+      if (typeof result === 'number') {
+        return result;
+      }
+      throw new Error('Failed to create bucket from existing bucket');
+    }
+    */
+    /**
+     * Updates basic bucket information (name, region, country)
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to update
+     * @param params - Basic update parameters
+     * @returns Promise resolving to the update result
+     */
+    async updateBucketBasic(provider_id, bucket_id, params) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'update_bucket_basic',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' },
+                { value: params.name || null, type: 'string' },
+                { value: params.region || null, type: 'string' },
+                { value: params.country || null, type: 'string' }
+            ]
+        });
+    }
+    /**
+     * Updates bucket pricing and capacity information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to update
+     * @param params - Pricing update parameters
+     * @returns Promise resolving to the update result
+     */
+    async updateBucketPricing(provider_id, bucket_id, params) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'update_bucket_pricing',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' },
+                { value: params.price_per_gb_storage || null, type: 'u128' },
+                { value: params.price_per_gb_egress || null, type: 'u128' },
+                { value: params.max_storage_gb || null, type: 'u32' },
+                { value: params.max_egress_gb || null, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Updates bucket SLA information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to update
+     * @param params - SLA update parameters
+     * @returns Promise resolving to the update result
+     */
+    async updateBucketSLA(provider_id, bucket_id, params) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'update_bucket_sla',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' },
+                { value: params.sla_avg_latency_ms || null, type: 'u32' },
+                { value: params.sla_avg_uptime_pct || null, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Locks a bucket to prevent modifications during active deals
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to lock
+     * @returns Promise resolving to the lock result
+     */
+    async lockBucket(provider_id, bucket_id) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'lock_bucket',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Unlocks a bucket to allow modifications
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to unlock
+     * @returns Promise resolving to the unlock result
+     */
+    async unlockBucket(provider_id, bucket_id) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'unlock_bucket',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Deletes a bucket from the system
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to delete
+     * @returns Promise resolving to the deletion result
+     */
+    async deleteBucket(provider_id, bucket_id) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'delete_bucket',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Retrieves bucket information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to retrieve
+     * @returns Promise resolving to Bucket object or null if not found
+     */
+    async getBucket(provider_id, bucket_id) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'get_bucket',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' }
+            ]
+        });
+        if (result && typeof result === 'object') {
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Gets the total count of buckets in the system
+     * @returns Promise resolving to the total number of buckets
+     */
+    async getBucketCount() {
+        const result = await (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'get_bucket_count',
+            args: []
+        });
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
+    }
+    /**
+     * Retrieves a paginated list of all buckets
+     * @param skip - Number of items to skip for pagination
+     * @param take - Number of items to take per page
+     * @returns Promise resolving to an array of Bucket objects
+     */
+    async getBuckets(skip = 0, take = 10) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'get_buckets',
+            args: [
+                { value: skip, type: 'u32' },
+                { value: take, type: 'u32' }
+            ]
+        });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        return [];
+    }
+    /**
+     * Retrieves all buckets owned by a specific provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of Bucket objects
+     */
+    async getBucketsByProvider(provider_id) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'get_buckets_by_provider',
+            args: [
+                { value: provider_id, type: 'address' }
+            ]
+        });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        return [];
+    }
+    /**
+     * Checks if a bucket is locked
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket to check
+     * @returns Promise resolving to true if the bucket is locked, false otherwise
+     */
+    async isBucketLocked(provider_id, bucket_id) {
+        const bucket = await this.getBucket(provider_id, bucket_id);
+        if (!bucket) {
+            return false;
+        }
+        return bucket.locked;
+    }
+    /**
+     * Gets bucket pricing information
+     * @param provider_id - Address of the provider owning the bucket
+     * @param bucket_id - ID of the bucket
+     * @returns Promise resolving to pricing information or null if bucket not found
+     */
+    async getBucketPricing(provider_id, bucket_id) {
+        const bucket = await this.getBucket(provider_id, bucket_id);
+        if (!bucket) {
+            return null;
+        }
+        return {
+            price_per_gb_storage: bucket.price_per_gb_storage,
+            price_per_gb_egress: bucket.price_per_gb_egress,
+            max_storage_gb: bucket.max_storage_gb,
+            max_egress_gb: bucket.max_egress_gb
+        };
+    }
+}
+exports.BucketOps = BucketOps;

package/dist/stellarv2/client.d.ts

@@ -0,0 +1,134 @@
+import { StellarNetwork } from './transaction';
+import { ConsumerOps } from './consumer';
+import { ProviderOps } from './provider';
+import { BucketOps } from './bucket';
+import { DealOps } from './deal';
+import { FundingOps } from './funding';
+/**
+ * Configuration interface for the FlashOnStellar V2 client
+ */
+export interface FlashOnStellarClientConfigV2 {
+    /** Stellar contract address for the FlashOnStellar V2 system */
+    contractAddress: string;
+    /**
+     * Optional callback function to sign non-read Stellar transactions
+     * @param xdrToSign - The XDR-encoded transaction to sign
+     * @returns Promise resolving to the signed XDR string
+     */
+    signTransaction?: (xdrToSign: string) => Promise<string>;
+    /** Network configuration for Stellar (testnet/public) */
+    network: StellarNetwork;
+}
+export type ClientContext = FlashOnStellarClientConfigV2;
+/**
+ * Main client class for interacting with the FlashOnStellar V2 system
+ * This client provides methods for managing providers, consumers, buckets, and deals
+ * on the Stellar blockchain through organized operation classes.
+ */
+export declare class FlashOnStellarClientV2 {
+    private readonly signTransaction?;
+    private readonly contractAddress;
+    private readonly network;
+    readonly consumers: ConsumerOps;
+    readonly providers: ProviderOps;
+    readonly buckets: BucketOps;
+    readonly deals: DealOps;
+    readonly funding: FundingOps;
+    protected getContext(): ClientContext;
+    /**
+     * Creates a new instance of the FlashOnStellarClient
+     * @param config - Configuration options for the client
+     */
+    constructor(config: FlashOnStellarClientConfigV2);
+    /**
+     * Gets the contract address
+     * @returns The contract address
+     */
+    getContractAddress(): string;
+    /**
+     * Gets the network configuration
+     * @returns The network configuration
+     */
+    getNetwork(): StellarNetwork;
+    /**
+     * Gets the version of the contract
+     * @returns Promise resolving to the contract version
+     */
+    getVersion(): Promise<number>;
+    /**
+     * Gets the owner address of the contract
+     * @returns Promise resolving to the owner address
+     */
+    getOwnerAddress(): Promise<string>;
+    /**
+     * Gets the stable asset address from the contract
+     * @returns Promise resolving to the stable asset address
+     */
+    getStableAssetAddress(): Promise<string>;
+    /**
+     * Gets the current ledger sequence
+     * @returns Promise resolving to the ledger sequence number
+     */
+    getLedgerSequence(): Promise<number>;
+    /**
+     * Updates the owner address (owner only)
+     * @param new_owner - New owner address
+     * @returns Promise resolving to the update result
+     */
+    updateOwner(new_owner: string): Promise<boolean>;
+    /**
+     * Sets the stable asset address (owner only)
+     * @param stable_asset_address - New stable asset address
+     * @returns Promise resolving to the update result
+     */
+    setStableAssetAddress(stable_asset_address: string): Promise<boolean>;
+    /**
+     * Upgrades the contract (owner only)
+     * @param new_wasm_hash - Hash of the new WASM bytecode
+     * @returns Promise resolving to the upgrade result
+     */
+    upgrade(new_wasm_hash: string): Promise<boolean>;
+    /**
+     * Gets system statistics
+     * @returns Promise resolving to system statistics
+     */
+    getSystemStats(): Promise<{
+        consumerCount: number;
+        providerCount: number;
+        bucketCount: number;
+        dealCount: number;
+        activeDealCount: number;
+    }>;
+    /**
+     * Gets comprehensive information about a provider including their buckets and deals
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to comprehensive provider information
+     */
+    getProviderInfo(provider_id: string): Promise<{
+        provider: any;
+        buckets: any[];
+        deals: any[];
+        activeDeals: any[];
+    } | null>;
+    /**
+     * Gets comprehensive information about a consumer including their deals
+     * @param consumer_id - Address of the consumer
+     * @returns Promise resolving to comprehensive consumer information
+     */
+    getConsumerInfo(consumer_id: string): Promise<{
+        consumer: any;
+        deals: any[];
+        activeDeals: any[];
+    } | null>;
+    /**
+     * Gets comprehensive information about a bucket including its provider and any active deals
+     * @param provider_id - Address of the provider
+     * @param bucket_id - ID of the bucket
+     * @returns Promise resolving to comprehensive bucket information
+     */
+    getBucketInfo(provider_id: string, bucket_id: number): Promise<{
+        bucket: any;
+        provider: any;
+        activeDeals: any[];
+    } | null>;
+}