@flashbacktech/flashbackclient 0.0.13

package/dist/stellar/client.js

@@ -0,0 +1,450 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { get_provider, get_provider_units, get_providers, get_provider_count, register_provider, delete_provider, update_provider, } from './provider.js';
+import { get_consumer, get_consumer_reservations, get_consumers, get_consumer_count, register_consumer, delete_consumer, update_consumer, } from './consumer.js';
+import { get_unit, get_unit_reservations, delete_unit, enter_maintenance, exit_maintenance, enter_decommissioning, exit_decommissioning, register_unit, } from './unit.js';
+import { create_reservation, get_reservation, delete_reservation, update_inuse_bytes_consumer, update_inuse_bytes_provider, } from './reservation.js';
+import { signTransaction, getPublicKeyFromPrivateKey } from './transaction.js';
+import { requiresSignature } from './decorator.js';
+import { get_stats } from './stats.js';
+/**
+ * Main client class for interacting with the FlashOnStellar system
+ * This client provides methods for managing providers, consumers, units, and reservations
+ * on the Stellar blockchain.
+ */
+class FlashOnStellarClient {
+    getContext() {
+        return {
+            network: this.network,
+            signTransaction: this.signTransaction,
+            contractAddress: this.contractAddress,
+        };
+    }
+    /**
+     * Creates a new instance of the FlashOnStellarClient
+     * @param config - Configuration options for the client
+     */
+    constructor(config) {
+        /**
+         * Derives a public key from a private key
+         * @param privateKey - Stellar private key
+         * @returns The corresponding public key
+         */
+        this.getPublicKey = (privateKey) => {
+            return getPublicKeyFromPrivateKey(privateKey);
+        };
+        /**
+         * Signs a transaction using the provided private key using Stellar SDK
+         * The alternative is providing your own signing function (for example, using Wallet Kit).
+         * @param xdrToSign - XDR-encoded transaction to sign
+         * @param privateKey - Stellar private key to sign with
+         * @returns Promise resolving to the signed XDR string
+         */
+        this.signTransactionWithKey = async (xdrToSign, privateKey) => {
+            const signedTx = await signTransaction(this.getContext(), xdrToSign, privateKey);
+            return signedTx.toXDR();
+        };
+        // Stats methods
+        /**
+         * Retrieves stats for the current user
+         * @param wallet_address - Address of the wallet requesting the information
+         * @returns Promise resolving to DashboardStats object
+         */
+        this.get_stats = (wallet_address) => {
+            return get_stats(this.getContext(), wallet_address);
+        };
+        // Provider methods
+        /**
+         * Retrieves provider information
+         * @param wallet_address - Address of the wallet requesting the information
+         * @param provider_address - Address of the provider to retrieve
+         * @param load_units - Optional flag to include provider's units in the response
+         * @returns Promise resolving to StorageProvider object
+         */
+        this.get_provider = (wallet_address, provider_address, load_units) => {
+            return get_provider(this.getContext(), wallet_address, provider_address, load_units);
+        };
+        /**
+         * Retrieves all units associated with a provider
+         * @param wallet_address - Address of the wallet requesting the information
+         * @param provider_address - Address of the provider
+         * @returns Promise resolving to an array of StorageUnit objects
+         */
+        this.get_provider_units = (wallet_address, provider_address) => {
+            return get_provider_units(this.getContext(), wallet_address, provider_address);
+        };
+        /**
+         * Retrieves a paginated list of providers
+         * @param wallet_address - Address of the wallet requesting the information
+         * @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 StorageProvider objects
+         */
+        this.get_providers = (wallet_address, skip = 0, take = 10) => {
+            return get_providers(this.getContext(), wallet_address, skip, take);
+        };
+        /**
+         * Gets the total count of providers in the system
+         * @param wallet_address - Address of the wallet requesting the information
+         * @returns Promise resolving to the total number of providers
+         */
+        this.get_provider_count = (wallet_address) => {
+            return get_provider_count(this.getContext(), wallet_address);
+        };
+        // Consumer methods
+        /**
+         * Retrieves consumer information
+         * @param wallet_address - Address of the wallet requesting the information
+         * @param consumer_address - Address of the consumer to retrieve
+         * @param load_reservations - Optional flag to include consumer's reservations
+         * @returns Promise resolving to StorageConsumer object
+         */
+        this.get_consumer = (wallet_address, consumer_address, load_reservations) => {
+            return get_consumer(this.getContext(), wallet_address, consumer_address, load_reservations);
+        };
+        /**
+         * Retrieves a paginated list of consumers
+         * @param wallet_address - Address of the wallet requesting the information
+         * @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 StorageConsumer objects
+         */
+        this.get_consumers = (wallet_address, skip = 0, take = 10) => {
+            return get_consumers(this.getContext(), wallet_address, skip, take);
+        };
+        /**
+         * Gets the total count of consumers in the system
+         * @param wallet_address - Address of the wallet requesting the information
+         * @returns Promise resolving to the total number of consumers
+         */
+        this.get_consumer_count = (wallet_address) => {
+            return get_consumer_count(this.getContext(), wallet_address);
+        };
+        /**
+         * Retrieves all reservations associated with a consumer
+         * @param wallet_address - Address of the wallet requesting the information
+         * @param consumer_address - Address of the consumer
+         * @returns Promise resolving to an array of StorageReservation objects
+         */
+        this.get_consumer_reservations = (wallet_address, consumer_address) => {
+            return get_consumer_reservations(this.getContext(), wallet_address, consumer_address);
+        };
+        /**
+         * Retrieves storage unit information
+         * @param wallet_address - Address of the wallet requesting the information
+         * @param unit_id - Identifier of the storage unit
+         * @param load_reservations - Optional flag to include unit's reservations
+         * @returns Promise resolving to StorageUnit object
+         */
+        this.get_unit = (wallet_address, unit_id, load_reservations) => {
+            return get_unit(this.getContext(), wallet_address, unit_id, load_reservations);
+        };
+        /**
+         * Retrieves all reservations for a specific storage unit
+         * @param wallet_address - Address of the wallet requesting the information
+         * @param unit_id - Identifier of the storage unit
+         * @returns Promise resolving to an array of StorageReservation objects
+         */
+        this.get_unit_reservations = (wallet_address, unit_id) => {
+            return get_unit_reservations(this.getContext(), wallet_address, unit_id);
+        };
+        // Reservation methods
+        /**
+         * Retrieves information about a specific reservation
+         * @param wallet_address - Address of the wallet requesting the information
+         * @param reservation_id - Identifier of the reservation
+         * @returns Promise resolving to StorageReservation object
+         */
+        this.get_reservation = (wallet_address, reservation_id) => {
+            return get_reservation(this.getContext(), wallet_address, reservation_id);
+        };
+        this.signTransaction = config.signTransaction;
+        this.contractAddress = config.contractAddress;
+        this.network = config.network;
+    }
+    /**
+     * Registers a new provider in the system
+     * @param wallet_address - Address of the wallet registering the provider
+     * @param provider_address - Address for the new provider
+     * @param provider_description - Description of the provider
+     * @returns Promise resolving to the registration transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if provider address is already registered
+     */
+    register_provider(wallet_address, provider_address, provider_description) {
+        return register_provider(this.getContext(), wallet_address, provider_address, provider_description);
+    }
+    /**
+     * Deletes a provider from the system
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider to delete
+     * @returns Promise resolving to the deletion transaction result
+     * @requires Signature - This method requires a transaction signature
+     */
+    delete_provider(wallet_address, provider_address) {
+        return delete_provider(this.getContext(), wallet_address, provider_address);
+    }
+    /**
+     * Updates provider information
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider to update
+     * @param provider_description - New description for the provider
+     * @returns Promise resolving to the update transaction result
+     * @requires Signature - This method requires a transaction signature
+     */
+    update_provider(wallet_address, provider_address, provider_description) {
+        return update_provider(this.getContext(), wallet_address, provider_address, provider_description);
+    }
+    /**
+     * Registers a new consumer in the system
+     * @param wallet_address - Address of the wallet registering the consumer
+     * @param consumer_address - Address for the new consumer
+     * @param consumer_description - Description of the consumer
+     * @returns Promise resolving to the registration transaction result
+     * @requires Signature - This method requires a transaction signature
+     */
+    register_consumer(wallet_address, consumer_address, consumer_description) {
+        return register_consumer(this.getContext(), wallet_address, consumer_address, consumer_description);
+    }
+    delete_consumer(wallet_address, consumer_address) {
+        return delete_consumer(this.getContext(), wallet_address, consumer_address);
+    }
+    update_consumer(wallet_address, consumer_address, consumer_description) {
+        return update_consumer(this.getContext(), wallet_address, consumer_address, consumer_description);
+    }
+    // Unit methods
+    /**
+     * Registers a new storage unit in the system
+     * @param wallet_address - Address of the wallet registering the unit
+     * @param provider_address - Address of the provider owning the unit
+     * @param capacity - Capacity of the storage unit in gigabytes
+     * @param endpoint - Endpoint for the storage unit
+     * @returns Promise resolving to the registration transaction result
+     * @requires Signature - This method requires a transaction signature
+     */
+    register_unit(wallet_address, provider_address, capacity, endpoint) {
+        return register_unit(this.getContext(), wallet_address, provider_address, capacity, endpoint);
+    }
+    /**
+     * Deletes a storage unit from the system
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider owning the unit
+     * @param unit_id - Identifier of the storage unit
+     * @returns Promise resolving to the deletion transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if unit has active reservations
+     */
+    delete_unit(wallet_address, provider_address, unit_id) {
+        return delete_unit(this.getContext(), wallet_address, provider_address, unit_id);
+    }
+    /**
+     * Places a storage unit into maintenance mode
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider owning the unit
+     * @param unit_id - Identifier of the storage unit
+     * @param maintenance_start - Start date of maintenance period
+     * @param maintenance_end - End date of maintenance period
+     * @returns Promise resolving to the maintenance transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if unit has active reservations that conflict with the maintenance window
+     */
+    enter_maintenance(wallet_address, provider_address, unit_id, maintenance_start, maintenance_end) {
+        return enter_maintenance(this.getContext(), wallet_address, provider_address, unit_id, maintenance_start, maintenance_end);
+    }
+    /**
+     * Exits maintenance mode for a storage unit
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider owning the unit
+     * @param unit_id - Identifier of the storage unit
+     * @returns Promise resolving to the maintenance exit transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if unit is not in maintenance mode
+     */
+    exit_maintenance(wallet_address, provider_address, unit_id) {
+        return exit_maintenance(this.getContext(), wallet_address, provider_address, unit_id);
+    }
+    /**
+     * Places a storage unit into decommissioning mode
+     * This starts the process of removing the unit from service.
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider owning the unit
+     * @param unit_id - Identifier of the storage unit
+     * @returns Promise resolving to the decommissioning transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if unit has active reservations
+     */
+    enter_decommissioning(wallet_address, provider_address, unit_id) {
+        return enter_decommissioning(this.getContext(), wallet_address, provider_address, unit_id);
+    }
+    /**
+     * Exits decommissioning mode for a storage unit
+     * This cancels the decommissioning process and returns the unit to service.
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider owning the unit
+     * @param unit_id - Identifier of the storage unit
+     * @returns Promise resolving to the decommissioning exit transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if unit is not in decommissioning mode
+     */
+    exit_decommissioning(wallet_address, provider_address, unit_id) {
+        return exit_decommissioning(this.getContext(), wallet_address, provider_address, unit_id);
+    }
+    /**
+     * Creates a new storage reservation
+     * @param wallet_address - Address of the wallet making the request
+     * @param consumer_address - Address of the consumer requesting storage
+     * @param unit_id - Identifier of the storage unit to reserve
+     * @param reserved_gb - Amount of storage to reserve in gigabytes
+     * @returns Promise resolving to the reservation creation transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if unit doesn't have enough available capacity
+     * @throws Will throw if unit is in maintenance or decommissioning mode
+     */
+    reserve_unit(wallet_address, consumer_address, unit_id, reserved_gb) {
+        return create_reservation(this.getContext(), wallet_address, consumer_address, unit_id, reserved_gb);
+    }
+    /**
+     * Deletes an existing reservation
+     * @param wallet_address - Address of the wallet making the request
+     * @param consumer_address - Address of the consumer who owns the reservation
+     * @param reservation_id - Identifier of the reservation to delete
+     * @returns Promise resolving to the reservation deletion transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if reservation has non-zero inuse_bytes
+     */
+    delete_reservation(wallet_address, consumer_address, reservation_id) {
+        return delete_reservation(this.getContext(), wallet_address, consumer_address, reservation_id);
+    }
+    /**
+     * Updates the amount of storage currently in use by a consumer
+     * @param wallet_address - Address of the wallet making the request
+     * @param consumer_address - Address of the consumer
+     * @param reservation_id - Identifier of the reservation
+     * @param inuse_bytes - Current number of bytes in use
+     * @returns Promise resolving to the update transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if inuse_bytes exceeds reserved amount
+     */
+    update_inuse_bytes_consumer(wallet_address, consumer_address, reservation_id, inuse_bytes) {
+        return update_inuse_bytes_consumer(this.getContext(), wallet_address, consumer_address, reservation_id, inuse_bytes);
+    }
+    /**
+     * Updates the amount of storage currently in use, reported by provider
+     * @param wallet_address - Address of the wallet making the request
+     * @param provider_address - Address of the provider
+     * @param reservation_id - Identifier of the reservation
+     * @param inuse_bytes - Current number of bytes in use
+     * @returns Promise resolving to the update transaction result
+     * @requires Signature - This method requires a transaction signature
+     * @throws Will throw if inuse_bytes exceeds reserved amount
+     * @throws Will throw if provider's report differs significantly from consumer's report
+     */
+    update_inuse_bytes_provider(wallet_address, provider_address, reservation_id, inuse_bytes) {
+        return update_inuse_bytes_provider(this.getContext(), wallet_address, provider_address, reservation_id, inuse_bytes);
+    }
+}
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "register_provider", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "delete_provider", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "update_provider", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "register_consumer", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "delete_consumer", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "update_consumer", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number, String]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "register_unit", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "delete_unit", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number, Date,
+        Date]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "enter_maintenance", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "exit_maintenance", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "enter_decommissioning", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "exit_decommissioning", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "reserve_unit", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "delete_reservation", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "update_inuse_bytes_consumer", null);
+__decorate([
+    requiresSignature,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number, Number]),
+    __metadata("design:returntype", void 0)
+], FlashOnStellarClient.prototype, "update_inuse_bytes_provider", null);
+export { FlashOnStellarClient };

package/dist/stellar/consumer.d.ts

@@ -0,0 +1,10 @@
+import { ClientContext } from './client.js';
+import { StorageConsumer, StorageReservation } from './models.js';
+declare const get_consumer: (context: ClientContext, wallet_address: string, consumer_address: string, load_reservations?: boolean) => Promise<StorageConsumer | null>;
+declare const get_consumers: (context: ClientContext, wallet_address: string, skip?: number, take?: number) => Promise<Map<string, StorageConsumer>>;
+declare const get_consumer_count: (context: ClientContext, wallet_address: string) => Promise<number>;
+declare const get_consumer_reservations: (context: ClientContext, wallet_address: string, consumer_address: string) => Promise<Map<number, StorageReservation>>;
+declare const register_consumer: (context: ClientContext, wallet_address: string, consumer_address: string, consumer_description: string) => Promise<void>;
+declare const delete_consumer: (context: ClientContext, wallet_address: string, consumer_address: string) => Promise<void>;
+declare const update_consumer: (context: ClientContext, wallet_address: string, consumer_address: string, consumer_description: string) => Promise<void>;
+export { get_consumer, get_consumers, get_consumer_count, get_consumer_reservations, register_consumer, delete_consumer, update_consumer, };

package/dist/stellar/consumer.js

@@ -0,0 +1,77 @@
+import { prepareTransaction, sendTransaction } from './transaction.js';
+const get_consumer = async (context, wallet_address, consumer_address, load_reservations = false) => {
+    const [consumer, reservations] = await Promise.all([
+        prepareTransaction(context, wallet_address, {
+            method: 'get_consumer',
+            args: [{ value: consumer_address, type: 'address' }],
+        }),
+        load_reservations
+            ? get_consumer_reservations(context, wallet_address, consumer_address)
+            : new Map(),
+    ]);
+    const typedConsumerData = consumer.isSuccess ? consumer.result : null;
+    if (typedConsumerData) {
+        typedConsumerData.reservations = reservations;
+    }
+    return typedConsumerData;
+};
+const get_consumers = async (context, wallet_address, skip = 0, take = 10) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_consumers',
+        args: [
+            { value: skip, type: 'u32' },
+            { value: take, type: 'u32' },
+        ],
+    });
+    if (!response.isSuccess) {
+        return new Map();
+    }
+    // Convert the plain object to a Map
+    const consumersObj = response.result;
+    return new Map(Object.entries(consumersObj));
+};
+const get_consumer_count = async (context, wallet_address) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_consumer_count',
+    });
+    return response.isSuccess ? response.result : 0;
+};
+const get_consumer_reservations = async (context, wallet_address, consumer_address) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_consumer_reservations',
+        args: [{ value: consumer_address, type: 'address' }],
+    });
+    const typedConsumerReservations = response.isSuccess
+        ? response.result
+        : new Map();
+    return typedConsumerReservations;
+};
+const executeConsumerTransaction = async (context, wallet_address, consumer_address, method, additionalArgs = []) => {
+    const isOwner = wallet_address !== consumer_address;
+    const response = await prepareTransaction(context, wallet_address, {
+        method,
+        args: [
+            { value: consumer_address, type: 'address' },
+            ...additionalArgs,
+            { value: isOwner, type: 'bool' },
+        ],
+    });
+    if (response.isSuccess && !response.isReadOnly) {
+        const signedTxXDR = await context.signTransaction(response.result);
+        await sendTransaction(context, signedTxXDR);
+    }
+};
+const register_consumer = async (context, wallet_address, consumer_address, consumer_description) => {
+    await executeConsumerTransaction(context, wallet_address, consumer_address, 'register_consumer', [
+        { value: consumer_description, type: 'string' },
+    ]);
+};
+const delete_consumer = async (context, wallet_address, consumer_address) => {
+    await executeConsumerTransaction(context, wallet_address, consumer_address, 'delete_consumer');
+};
+const update_consumer = async (context, wallet_address, consumer_address, consumer_description) => {
+    await executeConsumerTransaction(context, wallet_address, consumer_address, 'update_consumer', [
+        { value: consumer_description, type: 'string' },
+    ]);
+};
+export { get_consumer, get_consumers, get_consumer_count, get_consumer_reservations, register_consumer, delete_consumer, update_consumer, };

package/dist/stellar/decorator.d.ts

@@ -0,0 +1 @@
+export declare function requiresSignature(target: any, propertyKey: string | symbol, descriptor?: PropertyDescriptor): any;

package/dist/stellar/decorator.js

@@ -0,0 +1,30 @@
+export function requiresSignature(target, propertyKey, descriptor) {
+    if (descriptor) {
+        // Method decorator
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const context = this.getContext();
+            if (!context.signTransaction) {
+                throw new Error('FlashOnStellarClient: signTransaction method is required for write operations');
+            }
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    }
+    // Property decorator (for arrow functions)
+    const propertyDescriptor = {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const value = target[propertyKey];
+            return (...args) => {
+                const context = this.getContext();
+                if (!context.signTransaction) {
+                    throw new Error('FlashOnStellarClient: signTransaction method is required for write operations');
+                }
+                return value.apply(this, args);
+            };
+        },
+    };
+    Object.defineProperty(target, propertyKey, propertyDescriptor);
+}

package/dist/stellar/index.d.ts

@@ -0,0 +1,4 @@
+import { StellarNetwork } from './transaction.js';
+import { FlashOnStellarClient, FlashOnStellarClientConfig } from './client.js';
+export type * from './models.js';
+export { StellarNetwork, FlashOnStellarClient, FlashOnStellarClientConfig };

package/dist/stellar/index.js

@@ -0,0 +1,2 @@
+import { FlashOnStellarClient } from './client.js';
+export { FlashOnStellarClient };

package/dist/stellar/models.d.ts

@@ -0,0 +1,55 @@
+interface StorageConsumer {
+    description: string;
+    reputation: number;
+    registered_ts: number;
+    last_update_ts: number;
+    reservations: Map<number, StorageReservation>;
+    reservations_count: number;
+}
+type StorageReservationStatus = 'Reserved' | 'In Use' | 'Maintenance' | 'Decommissioning';
+interface StorageReservation {
+    unit_id: number;
+    consumer_id: string;
+    status: StorageReservationStatus | StorageReservationStatus[];
+    reserved_gb: number;
+    inuse_bytes_consumer: bigint;
+    inuse_bytes_consumer_ts: bigint;
+    inuse_bytes_provider: bigint;
+    inuse_bytes_provider_ts: bigint;
+    creation_ts: number;
+}
+type StorageUnitStatus = 'Available' | 'Reserved' | 'In Use' | 'Maintenance' | 'Decommissioning';
+type DeletionStatus = 'ReservationInUse' | 'UnitInUse' | 'UnitNotDecommissioned' | 'Unauthorized' | 'NotFound' | 'Success';
+interface StorageUnit {
+    provider_id: string;
+    address: string;
+    status: StorageUnitStatus | StorageUnitStatus[];
+    last_update_ts: number;
+    maintenance_start_ts: number;
+    maintenance_end_ts: number;
+    previous_status: StorageUnitStatus | StorageUnitStatus[];
+    capacity_gb: number;
+    reserved_gb: number;
+    inuse_bytes_provider: number;
+    inuse_bytes_provider_ts: number;
+    reservations_count: number;
+    reservations: Map<number, StorageReservation>;
+}
+interface StorageProvider {
+    units: Map<number, StorageUnit>;
+    description: string;
+    reputation: number;
+    registered_ts: number;
+    last_update_ts: number;
+    units_count: number;
+}
+interface ContractStats {
+    unit_count: number;
+    total_capacity_gb: number;
+    total_reserved_gb: number;
+    total_inuse_bytes_consumer: number;
+    total_inuse_bytes_provider: number;
+    total_maintenance_gb: number;
+    total_decommissioning_gb: number;
+}
+export type { StorageConsumer, StorageReservation, StorageUnit, StorageProvider, ContractStats, StorageUnitStatus, StorageReservationStatus, DeletionStatus, };

package/dist/stellar/models.js

@@ -0,0 +1 @@
+export {};

package/dist/stellar/provider.d.ts

@@ -0,0 +1,10 @@
+import { ClientContext } from './client.js';
+import { StorageProvider, StorageUnit } from './models.js';
+declare const get_provider: (context: ClientContext, wallet_address: string, provider_address: string, load_units?: boolean) => Promise<StorageProvider | null>;
+declare const get_provider_units: (context: ClientContext, wallet_address: string, provider_address: string) => Promise<Map<number, StorageUnit>>;
+declare const get_providers: (context: ClientContext, wallet_address: string, skip?: number, take?: number) => Promise<Map<string, StorageProvider>>;
+declare const get_provider_count: (context: ClientContext, wallet_address: string) => Promise<number>;
+declare const register_provider: (context: ClientContext, wallet_address: string, provider_address: string, provider_description: string) => Promise<void>;
+declare const delete_provider: (context: ClientContext, wallet_address: string, provider_address: string) => Promise<void>;
+declare const update_provider: (context: ClientContext, wallet_address: string, provider_address: string, provider_description: string) => Promise<void>;
+export { get_provider, get_provider_units, get_providers, get_provider_count, register_provider, delete_provider, update_provider, };