@flashbacktech/flashbackclient 0.1.28 → 0.1.31

package/dist/stellarv2/deal.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DealOps = void 0;
+const transaction_1 = require("./transaction");
+/**
+ * Deal operations client for FlashOnStellar V2
+ * Implements all deal-related contract methods
+ */
+class DealOps {
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Creates a new deal between a consumer and provider
+     * @param consumer_id - Address of the consumer creating the deal
+     * @param provider_id - Address of the provider
+     * @param bucket_id - ID of the bucket for the deal
+     * @param params - Deal creation parameters
+     * @returns Promise resolving to the created deal ID
+     */
+    async createDeal(consumer_id, provider_id, bucket_id, params) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, consumer_id, {
+            method: 'create_deal',
+            args: [
+                { value: consumer_id, type: 'address' },
+                { value: provider_id, type: 'address' },
+                { value: bucket_id, type: 'u32' },
+                { value: params.duration_secs, type: 'u64' },
+                { value: params.agreed_storage_gb, type: 'u32' },
+                { value: params.agreed_egress_gb, type: 'u32' },
+                { value: params.fb_repo_id, type: 'string' },
+                { value: params.api_compatibility, type: 'string' }
+            ]
+        });
+        if (typeof result === 'number') {
+            return result;
+        }
+        throw new Error('Failed to create deal');
+    }
+    /**
+     * Sets a deal as accepted by the provider
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider accepting the deal
+     * @param deal_id - ID of the deal to accept
+     * @returns Promise resolving to the acceptance result
+     */
+    async setDealAccepted(consumer_id, provider_id, deal_id) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'set_deal_accepted',
+            args: [
+                { value: consumer_id, type: 'address' },
+                { value: provider_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Sets a deal as funded by the consumer
+     * @param consumer_id - Address of the consumer funding the deal
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal to fund
+     * @param amount_usd - Amount to fund in USD (scaled by 10^7)
+     * @returns Promise resolving to the funding result
+     */
+    async setDealFunded(consumer_id, provider_id, deal_id, amount_usd) {
+        return (0, transaction_1.callContractMethod)(this.context, consumer_id, {
+            method: 'set_deal_funded',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: consumer_id, type: 'address' },
+                { value: deal_id, type: 'u32' },
+                { value: amount_usd, type: 'u128' }
+            ]
+        });
+    }
+    /**
+     * Sets a deal as completed
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal to complete
+     * @returns Promise resolving to the completion result
+     */
+    async setDealCompleted(consumer_id, provider_id, deal_id) {
+        return (0, transaction_1.callContractMethod)(this.context, consumer_id, {
+            method: 'set_deal_completed',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: consumer_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Sets a deal as cancelled
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal to cancel
+     * @returns Promise resolving to the cancellation result
+     */
+    async setDealCancelled(consumer_id, provider_id, deal_id) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'set_deal_cancelled',
+            args: [
+                { value: consumer_id, type: 'address' },
+                { value: provider_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Marks a deal as breached by the consumer
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal
+     * @returns Promise resolving to the breach marking result
+     */
+    async setDealBreachedConsumer(consumer_id, provider_id, deal_id) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'set_deal_breached_consumer',
+            args: [
+                { value: consumer_id, type: 'address' },
+                { value: provider_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Marks a deal as breached by the provider
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal
+     * @returns Promise resolving to the breach marking result
+     */
+    async setDealBreachedProvider(consumer_id, provider_id, deal_id) {
+        return (0, transaction_1.callContractMethod)(this.context, consumer_id, {
+            method: 'set_deal_breached_provider',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: consumer_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Deletes a deal from the system (owner only)
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal to delete
+     * @returns Promise resolving to the deletion result
+     */
+    async deleteDeal(consumer_id, provider_id, deal_id) {
+        return (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'delete_deal',
+            args: [
+                { value: consumer_id, type: 'address' },
+                { value: provider_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Retrieves deal information
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal to retrieve
+     * @returns Promise resolving to Deal object or null if not found
+     */
+    async getDeal(consumer_id, provider_id, deal_id) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, consumer_id, {
+            method: 'get_deal',
+            args: [
+                { value: consumer_id, type: 'address' },
+                { value: provider_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+        if (result && typeof result === 'object') {
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Gets the total count of deals in the system
+     * @returns Promise resolving to the total number of deals
+     */
+    async getDealCount() {
+        const result = await (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'get_deal_count',
+            args: []
+        });
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
+    }
+    /**
+     * Retrieves a paginated list of all deals
+     * @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 Deal objects
+     */
+    async getDeals(skip = 0, take = 10) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'get_deals',
+            args: [
+                { value: skip, type: 'u32' },
+                { value: take, type: 'u32' }
+            ]
+        });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        return [];
+    }
+    /**
+     * Retrieves all deals for a specific consumer
+     * @param consumer_id - Address of the consumer
+     * @returns Promise resolving to an array of Deal objects
+     */
+    async getDealsByConsumer(consumer_id) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, consumer_id, {
+            method: 'get_deals_by_consumer',
+            args: [
+                { value: consumer_id, type: 'address' }
+            ]
+        });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        return [];
+    }
+    /**
+     * Retrieves all deals for a specific provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of Deal objects
+     */
+    async getDealsByProvider(provider_id) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'get_deals_by_provider',
+            args: [
+                { value: provider_id, type: 'address' }
+            ]
+        });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        return [];
+    }
+    /**
+     * Retrieves all active deals
+     * @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 active Deal objects
+     */
+    async getActiveDeals(skip = 0, take = 10) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'get_active_deals',
+            args: [
+                { value: skip, type: 'u32' },
+                { value: take, type: 'u32' }
+            ]
+        });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        return [];
+    }
+    /**
+     * Pays for pending consumption in a deal (owner only)
+     * @param provider_id - Address of the provider
+     * @param consumer_id - Address of the consumer
+     * @param deal_id - ID of the deal
+     * @returns Promise resolving to the payment result
+     */
+    async payPendingConsumption(provider_id, consumer_id, deal_id) {
+        return (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'pay_pending_consumption',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: consumer_id, type: 'address' },
+                { value: deal_id, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Updates deal consumption metrics (owner only)
+     * @param provider_id - Address of the provider
+     * @param consumer_id - Address of the consumer
+     * @param deal_id - ID of the deal
+     * @param params - Consumption update parameters
+     * @returns Promise resolving to the update result
+     */
+    async updateDealConsumption(provider_id, consumer_id, deal_id, params) {
+        return (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'update_deal_consumption',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: consumer_id, type: 'address' },
+                { value: deal_id, type: 'u32' },
+                { value: params.storage_gb, type: 'u32' },
+                { value: params.egress_gb, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Updates deal SLA metrics (owner only)
+     * @param provider_id - Address of the provider
+     * @param consumer_id - Address of the consumer
+     * @param deal_id - ID of the deal
+     * @param params - SLA update parameters
+     * @returns Promise resolving to the update result
+     */
+    async updateDealSLA(provider_id, consumer_id, deal_id, params) {
+        return (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'update_deal_sla',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: consumer_id, type: 'address' },
+                { value: deal_id, type: 'u32' },
+                { value: params.sla_avg_latency_ms, type: 'u32' },
+                { value: params.sla_avg_uptime_pct, type: 'u32' }
+            ]
+        });
+    }
+    /**
+     * Gets deal status information
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal
+     * @returns Promise resolving to deal status or null if deal not found
+     */
+    async getDealStatus(consumer_id, provider_id, deal_id) {
+        const deal = await this.getDeal(consumer_id, provider_id, deal_id);
+        if (!deal) {
+            return null;
+        }
+        return deal.status;
+    }
+    /**
+     * Gets deal balance information
+     * @param consumer_id - Address of the consumer
+     * @param provider_id - Address of the provider
+     * @param deal_id - ID of the deal
+     * @returns Promise resolving to deal balances or null if deal not found
+     */
+    async getDealBalances(consumer_id, provider_id, deal_id) {
+        const deal = await this.getDeal(consumer_id, provider_id, deal_id);
+        if (!deal) {
+            return null;
+        }
+        return {
+            balance_consumer: deal.balance_consumer,
+            balance_provider: deal.balance_provider
+        };
+    }
+}
+exports.DealOps = DealOps;

package/dist/stellarv2/funding.d.ts

@@ -0,0 +1,46 @@
+import { ClientContext } from './client';
+/**
+ * Funding operations client for FlashOnStellar V2
+ * Implements all funding-related contract methods (owner only)
+ */
+export declare class FundingOps {
+    private context;
+    constructor(context: ClientContext);
+    /**
+     * Sends funds from the contract to a receiver (owner only)
+     * @param receiver - Address of the receiver
+     * @param amount - Amount to send in the stable asset's smallest unit
+     * @returns Promise resolving to the transfer result
+     */
+    sendFundsOwner(receiver: string, amount: bigint): Promise<boolean>;
+    /**
+     * Test faucet function for minting tokens to a receiver (owner only)
+     * @param receiver - Address of the receiver
+     * @param amount - Amount to mint in the stable asset's smallest unit
+     * @returns Promise resolving to the minting result
+     */
+    testFaucetOwner(receiver: string, amount: bigint): Promise<boolean>;
+    /**
+     * Changes the admin of the stable asset contract (owner only)
+     * @param new_admin - Address of the new admin
+     * @returns Promise resolving to the admin change result
+     */
+    changeAssetAdmin(new_admin: string): Promise<boolean>;
+    /**
+     * Gets the stable asset address from the contract
+     * @returns Promise resolving to the stable asset contract address
+     */
+    getStableAssetAddress(): Promise<string>;
+    /**
+     * Checks if an address is authorized for the stable asset
+     * @param address - Address to check
+     * @returns Promise resolving to true if authorized, false otherwise
+     */
+    isAuthorizedForAsset(address: string): Promise<boolean>;
+    /**
+     * Gets the balance of an address for the stable asset
+     * @param address - Address to check balance for
+     * @returns Promise resolving to the balance amount
+     */
+    getAssetBalance(address: string): Promise<bigint>;
+}

package/dist/stellarv2/funding.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FundingOps = void 0;
+const transaction_1 = require("./transaction");
+/**
+ * Funding operations client for FlashOnStellar V2
+ * Implements all funding-related contract methods (owner only)
+ */
+class FundingOps {
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Sends funds from the contract to a receiver (owner only)
+     * @param receiver - Address of the receiver
+     * @param amount - Amount to send in the stable asset's smallest unit
+     * @returns Promise resolving to the transfer result
+     */
+    async sendFundsOwner(receiver, amount) {
+        return (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'send_funds_owner',
+            args: [
+                { value: receiver, type: 'address' },
+                { value: amount, type: 'i128' }
+            ]
+        });
+    }
+    /**
+     * Test faucet function for minting tokens to a receiver (owner only)
+     * @param receiver - Address of the receiver
+     * @param amount - Amount to mint in the stable asset's smallest unit
+     * @returns Promise resolving to the minting result
+     */
+    async testFaucetOwner(receiver, amount) {
+        return (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'test_faucet_owner',
+            args: [
+                { value: receiver, type: 'address' },
+                { value: amount, type: 'i128' }
+            ]
+        });
+    }
+    /**
+     * Changes the admin of the stable asset contract (owner only)
+     * @param new_admin - Address of the new admin
+     * @returns Promise resolving to the admin change result
+     */
+    async changeAssetAdmin(new_admin) {
+        return (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'change_asset_admin',
+            args: [
+                { value: new_admin, type: 'address' }
+            ]
+        });
+    }
+    /**
+     * Gets the stable asset address from the contract
+     * @returns Promise resolving to the stable asset contract address
+     */
+    async getStableAssetAddress() {
+        // This would typically be a getter method, but since it's not in the FundingOps trait,
+        // we'll need to implement it separately or access it through the main contract
+        throw new Error('getStableAssetAddress not implemented in FundingOps - use main contract methods');
+    }
+    /**
+     * Checks if an address is authorized for the stable asset
+     * @param address - Address to check
+     * @returns Promise resolving to true if authorized, false otherwise
+     */
+    async isAuthorizedForAsset(address) {
+        // This would typically be a getter method on the stable asset contract
+        // Implementation depends on the specific stable asset contract interface
+        throw new Error('isAuthorizedForAsset not implemented - requires stable asset contract interaction');
+    }
+    /**
+     * Gets the balance of an address for the stable asset
+     * @param address - Address to check balance for
+     * @returns Promise resolving to the balance amount
+     */
+    async getAssetBalance(address) {
+        // This would typically be a getter method on the stable asset contract
+        // Implementation depends on the specific stable asset contract interface
+        throw new Error('getAssetBalance not implemented - requires stable asset contract interaction');
+    }
+}
+exports.FundingOps = FundingOps;

package/dist/stellarv2/index.d.ts

@@ -0,0 +1,9 @@
+import { StellarNetwork } from './transaction';
+import { FlashOnStellarClientV2, FlashOnStellarClientConfigV2 } from './client';
+export { ConsumerOps } from './consumer';
+export { ProviderOps } from './provider';
+export { BucketOps } from './bucket';
+export { DealOps } from './deal';
+export { FundingOps } from './funding';
+export * from './models';
+export { StellarNetwork, FlashOnStellarClientV2, FlashOnStellarClientConfigV2 };

package/dist/stellarv2/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashOnStellarClientV2 = exports.FundingOps = exports.DealOps = exports.BucketOps = exports.ProviderOps = exports.ConsumerOps = void 0;
+const client_1 = require("./client");
+Object.defineProperty(exports, "FlashOnStellarClientV2", { enumerable: true, get: function () { return client_1.FlashOnStellarClientV2; } });
+// Export operation classes
+var consumer_1 = require("./consumer");
+Object.defineProperty(exports, "ConsumerOps", { enumerable: true, get: function () { return consumer_1.ConsumerOps; } });
+var provider_1 = require("./provider");
+Object.defineProperty(exports, "ProviderOps", { enumerable: true, get: function () { return provider_1.ProviderOps; } });
+var bucket_1 = require("./bucket");
+Object.defineProperty(exports, "BucketOps", { enumerable: true, get: function () { return bucket_1.BucketOps; } });
+var deal_1 = require("./deal");
+Object.defineProperty(exports, "DealOps", { enumerable: true, get: function () { return deal_1.DealOps; } });
+var funding_1 = require("./funding");
+Object.defineProperty(exports, "FundingOps", { enumerable: true, get: function () { return funding_1.FundingOps; } });
+// Export models and types
+__exportStar(require("./models"), exports);

package/dist/stellarv2/models.d.ts

@@ -0,0 +1,149 @@
+/**
+ * TypeScript models for FlashOnStellar V2 contract
+ * These models correspond to the Rust contract types
+ */
+export interface Consumer {
+    consumer_id: string;
+    description: string;
+    reputation: number;
+    registered_ts: bigint;
+    last_update_ts: bigint;
+    deals: Map<string, bigint>;
+    active_deals: Map<string, bigint>;
+}
+export interface Provider {
+    provider_id: string;
+    buckets: Map<string, bigint>;
+    deals: Map<string, bigint>;
+    active_deals: Map<string, bigint>;
+    description: string;
+    reputation: number;
+    registered_ts: bigint;
+    last_update_ts: bigint;
+    units_count: number;
+}
+export interface Bucket {
+    bucket_id: number;
+    name: string;
+    region: string;
+    country: string;
+    provider_id: string;
+    fb_bucket_id: string;
+    price_per_gb_storage: bigint;
+    price_per_gb_egress: bigint;
+    max_storage_gb: number;
+    max_egress_gb: number;
+    versioning_enabled: boolean;
+    encryption_at_rest: boolean;
+    encryption_in_transit: boolean;
+    object_locking: boolean;
+    api_compatibility: string;
+    sla_avg_latency_ms: number;
+    sla_avg_uptime_pct: number;
+    access_scope: string;
+    tags: string[];
+    created_ts: bigint;
+    status: BucketStatus;
+    locked: boolean;
+}
+export declare enum BucketStatus {
+    Active = "Active",
+    Inactive = "Inactive",
+    Deleted = "Deleted"
+}
+export interface Deal {
+    deal_id: number;
+    consumer_id: string;
+    provider_id: string;
+    bucket_id: number;
+    fb_repo_id: string;
+    api_compatibility: string;
+    start_ts: bigint;
+    duration_secs: bigint;
+    agreed_storage_gb: number;
+    agreed_egress_gb: number;
+    unpaid_storage_gb: number;
+    unpaid_egress_gb: number;
+    paid_storage_gb: number;
+    paid_egress_gb: number;
+    status: DealStatus;
+    balance_consumer: bigint;
+    balance_provider: bigint;
+    sla_avg_latency_ms: number;
+    sla_avg_uptime_pct: number;
+    slash_storage_gb: number;
+    slash_egress_gb: number;
+    slash_amount_usd: bigint;
+}
+export declare enum DealStatus {
+    Pending = "Pending",
+    Accepted = "Accepted",
+    Funded = "Funded",
+    Completed = "Completed",
+    Cancelled = "Cancelled",
+    BreachedConsumer = "BreachedConsumer",
+    BreachedProvider = "BreachedProvider"
+}
+export declare enum DataKey {
+    Owner = "Owner",
+    StableAssetAddress = "StableAssetAddress",
+    Provider = "Provider",
+    ProviderCount = "ProviderCount",
+    ProviderMap = "ProviderMap",
+    Consumer = "Consumer",
+    ConsumerCount = "ConsumerCount",
+    ConsumerMap = "ConsumerMap",
+    Bucket = "Bucket",
+    BucketCount = "BucketCount",
+    BucketMap = "BucketMap",
+    Deal = "Deal",
+    DealCount = "DealCount",
+    DealMap = "DealMap",
+    ActiveDealMap = "ActiveDealMap"
+}
+export declare enum ErrorCode {
+    ConsumerAlreadyExists = "ConsumerAlreadyExists",
+    ProviderAlreadyExists = "ProviderAlreadyExists",
+    BucketAlreadyExists = "BucketAlreadyExists",
+    BucketLocked = "BucketLocked"
+}
+export interface BucketCreateParams {
+    name: string;
+    region: string;
+    country: string;
+    versioning_enabled: boolean;
+    fb_bucket_id: string;
+    api_compatibility: string;
+    price_per_gb_storage: bigint;
+    price_per_gb_egress: bigint;
+}
+export interface DealCreateParams {
+    duration_secs: bigint;
+    agreed_storage_gb: number;
+    agreed_egress_gb: number;
+    fb_repo_id: string;
+    api_compatibility: string;
+}
+export interface BucketUpdateBasicParams {
+    name?: string;
+    region?: string;
+    country?: string;
+}
+export interface BucketUpdatePricingParams {
+    price_per_gb_storage?: bigint;
+    price_per_gb_egress?: bigint;
+    max_storage_gb?: number;
+    max_egress_gb?: number;
+}
+export interface BucketUpdateSLAParams {
+    sla_avg_latency_ms?: number;
+    sla_avg_uptime_pct?: number;
+}
+export interface DealConsumptionUpdateParams {
+    storage_gb: number;
+    egress_gb: number;
+}
+export interface DealSLAUpdateParams {
+    sla_avg_latency_ms: number;
+    sla_avg_uptime_pct: number;
+}