@flashbacktech/flashbackclient 0.1.34 → 0.1.36

package/dist/stellarv2/client/bucket.d.ts

@@ -0,0 +1,111 @@
+import { ClientContext } from '.';
+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<void>;
+    /**
+     * 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<void>;
+    /**
+     * 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<void>;
+    /**
+     * 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<void>;
+    /**
+     * 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<void>;
+    /**
+     * 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<void>;
+    /**
+     * 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/client/bucket.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketOps = void 0;
+const transaction_1 = require("../wallet/transaction");
+const decorator_1 = require("../utils/decorator");
+/**
+ * Bucket operations client for FlashOnStellar V2
+ * Implements all bucket-related contract methods
+ */
+class BucketOps {
+    constructor(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
+         */
+        this.createBucket = (0, decorator_1.withSignature)(async (provider_id, params) => {
+            const response = await (0, transaction_1.prepareTransaction)(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 (!response.isSuccess) {
+                throw new Error('Failed to create bucket');
+            }
+            const result = response.result;
+            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
+         */
+        /*
+        createFromBucket = withSignature(
+          async (bucket: Bucket): Promise<number> => {
+            const response = await prepareTransaction(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 (!response.isSuccess) {
+              throw new Error('Failed to create bucket from existing bucket');
+            }
+      
+            const result = response.result;
+            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
+         */
+        this.updateBucketBasic = (0, decorator_1.withSignature)(async (provider_id, bucket_id, params) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, provider_id, "update_bucket_basic", [
+                { 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
+         */
+        this.updateBucketPricing = (0, decorator_1.withSignature)(async (provider_id, bucket_id, params) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, provider_id, "update_bucket_pricing", [
+                { 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
+         */
+        this.updateBucketSLA = (0, decorator_1.withSignature)(async (provider_id, bucket_id, params) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, provider_id, "update_bucket_sla", [
+                { 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
+         */
+        this.lockBucket = (0, decorator_1.withSignature)(async (provider_id, bucket_id) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, provider_id, "lock_bucket", [
+                { 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
+         */
+        this.unlockBucket = (0, decorator_1.withSignature)(async (provider_id, bucket_id) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, provider_id, "unlock_bucket", [
+                { 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
+         */
+        this.deleteBucket = (0, decorator_1.withSignature)(async (provider_id, bucket_id) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, provider_id, "delete_bucket", [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' }
+            ]);
+        });
+        this.context = context;
+    }
+    /**
+     * 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 response = await (0, transaction_1.prepareTransaction)(this.context, provider_id, {
+            method: 'get_bucket',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' }
+            ]
+        });
+        if (!response.isSuccess) {
+            return null;
+        }
+        const result = response.result;
+        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 response = await (0, transaction_1.prepareTransaction)(this.context, '', {
+            method: 'get_bucket_count',
+            args: []
+        });
+        if (!response.isSuccess) {
+            return 0;
+        }
+        const result = response.result;
+        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 response = await (0, transaction_1.prepareTransaction)(this.context, '', {
+            method: 'get_buckets',
+            args: [
+                { value: skip, type: 'u32' },
+                { value: take, type: 'u32' }
+            ]
+        });
+        if (!response.isSuccess) {
+            return [];
+        }
+        const result = response.result;
+        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 response = await (0, transaction_1.prepareTransaction)(this.context, provider_id, {
+            method: 'get_buckets_by_provider',
+            args: [
+                { value: provider_id, type: 'address' }
+            ]
+        });
+        if (!response.isSuccess) {
+            return [];
+        }
+        const result = response.result;
+        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/consumer.d.ts

@@ -0,0 +1,60 @@
+import { ClientContext } from '.';
+import { Consumer } from '../models';
+/**
+ * Consumer operations client for FlashOnStellar V2
+ * Implements all consumer-related contract methods
+ */
+export declare class ConsumerOps {
+    private context;
+    constructor(context: ClientContext);
+    /**
+     * Registers a new consumer in the system
+     * @param consumer_id - Address of the consumer to register
+     * @param description - Description of the consumer
+     * @returns Promise resolving to the registration result
+     */
+    registerConsumer: (consumer_id: string, description: string) => Promise<void>;
+    /**
+     * Updates an existing consumer's information
+     * @param consumer_id - Address of the consumer to update
+     * @param description - New description for the consumer
+     * @returns Promise resolving to the update result
+     */
+    updateConsumer: (consumer_id: string, description: string) => Promise<void>;
+    /**
+     * Deletes a consumer from the system
+     * @param consumer_id - Address of the consumer to delete
+     * @returns Promise resolving to the deletion result
+     */
+    deleteConsumer: (consumer_id: string) => Promise<void>;
+    /**
+     * Retrieves consumer information
+     * @param consumer_id - Address of the consumer to retrieve
+     * @returns Promise resolving to Consumer object or null if not found
+     */
+    getConsumer(consumer_id: string): Promise<Consumer | null>;
+    /**
+     * Gets the total count of consumers in the system
+     * @returns Promise resolving to the total number of consumers
+     */
+    getConsumerCount(): Promise<number>;
+    /**
+     * Retrieves a paginated list of consumers
+     * @param skip - Number of items to skip for pagination
+     * @param take - Number of items to take per page
+     * @returns Promise resolving to a map of consumer addresses to Consumer objects
+     */
+    getConsumers(skip?: number, take?: number): Promise<Map<string, Consumer>>;
+    /**
+     * Gets all deals associated with a consumer
+     * @param consumer_id - Address of the consumer
+     * @returns Promise resolving to an array of deal IDs
+     */
+    getConsumerDeals(consumer_id: string): Promise<string[]>;
+    /**
+     * Gets all active deals associated with a consumer
+     * @param consumer_id - Address of the consumer
+     * @returns Promise resolving to an array of active deal IDs
+     */
+    getConsumerActiveDeals(consumer_id: string): Promise<string[]>;
+}

package/dist/stellarv2/client/consumer.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumerOps = void 0;
+const transaction_1 = require("../wallet/transaction");
+const decorator_1 = require("../utils/decorator");
+/**
+ * Consumer operations client for FlashOnStellar V2
+ * Implements all consumer-related contract methods
+ */
+class ConsumerOps {
+    constructor(context) {
+        /**
+         * Registers a new consumer in the system
+         * @param consumer_id - Address of the consumer to register
+         * @param description - Description of the consumer
+         * @returns Promise resolving to the registration result
+         */
+        this.registerConsumer = (0, decorator_1.withSignature)(async (consumer_id, description) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, consumer_id, "register_consumer", [
+                { value: consumer_id, type: 'address' },
+                { value: description, type: 'string' }
+            ]);
+        });
+        /**
+         * Updates an existing consumer's information
+         * @param consumer_id - Address of the consumer to update
+         * @param description - New description for the consumer
+         * @returns Promise resolving to the update result
+         */
+        this.updateConsumer = (0, decorator_1.withSignature)(async (consumer_id, description) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, consumer_id, "update_consumer", [
+                { value: consumer_id, type: 'address' },
+                { value: description, type: 'string' }
+            ]);
+        });
+        /**
+         * Deletes a consumer from the system
+         * @param consumer_id - Address of the consumer to delete
+         * @returns Promise resolving to the deletion result
+         */
+        this.deleteConsumer = (0, decorator_1.withSignature)(async (consumer_id) => {
+            await (0, transaction_1.executeWalletTransaction)(this.context, consumer_id, "delete_consumer", [
+                { value: consumer_id, type: 'address' }
+            ]);
+        });
+        this.context = context;
+    }
+    /**
+     * Retrieves consumer information
+     * @param consumer_id - Address of the consumer to retrieve
+     * @returns Promise resolving to Consumer object or null if not found
+     */
+    async getConsumer(consumer_id) {
+        const response = await (0, transaction_1.prepareTransaction)(this.context, consumer_id, {
+            method: 'get_consumer',
+            args: [
+                { value: consumer_id, type: 'address' }
+            ]
+        });
+        if (!response.isSuccess) {
+            return null;
+        }
+        const result = response.result;
+        if (result && typeof result === 'object') {
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Gets the total count of consumers in the system
+     * @returns Promise resolving to the total number of consumers
+     */
+    async getConsumerCount() {
+        const response = await (0, transaction_1.prepareTransaction)(this.context, '', {
+            method: 'get_consumer_count',
+            args: []
+        });
+        if (!response.isSuccess) {
+            return 0;
+        }
+        const result = response.result;
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
+    }
+    /**
+     * Retrieves a paginated list of consumers
+     * @param skip - Number of items to skip for pagination
+     * @param take - Number of items to take per page
+     * @returns Promise resolving to a map of consumer addresses to Consumer objects
+     */
+    async getConsumers(skip = 0, take = 10) {
+        const response = await (0, transaction_1.prepareTransaction)(this.context, '', {
+            method: 'get_consumers',
+            args: [
+                { value: skip, type: 'u32' },
+                { value: take, type: 'u32' }
+            ]
+        });
+        if (!response.isSuccess) {
+            return new Map();
+        }
+        const result = response.result;
+        if (result && typeof result === 'object') {
+            // Convert the result to a Map<string, Consumer>
+            const consumerMap = new Map();
+            // Note: The actual conversion depends on how the contract returns the data
+            // This is a placeholder implementation
+            return consumerMap;
+        }
+        return new Map();
+    }
+    /**
+     * Gets all deals associated with a consumer
+     * @param consumer_id - Address of the consumer
+     * @returns Promise resolving to an array of deal IDs
+     */
+    async getConsumerDeals(consumer_id) {
+        const consumer = await this.getConsumer(consumer_id);
+        if (!consumer) {
+            return [];
+        }
+        // Extract deal IDs from the consumer's deals map
+        const dealIds = [];
+        consumer.deals.forEach((_, dealId) => {
+            dealIds.push(dealId);
+        });
+        return dealIds;
+    }
+    /**
+     * Gets all active deals associated with a consumer
+     * @param consumer_id - Address of the consumer
+     * @returns Promise resolving to an array of active deal IDs
+     */
+    async getConsumerActiveDeals(consumer_id) {
+        const consumer = await this.getConsumer(consumer_id);
+        if (!consumer) {
+            return [];
+        }
+        // Extract active deal IDs from the consumer's active_deals map
+        const activeDealIds = [];
+        consumer.active_deals.forEach((_, dealId) => {
+            activeDealIds.push(dealId);
+        });
+        return activeDealIds;
+    }
+}
+exports.ConsumerOps = ConsumerOps;