@flashbacktech/flashbackclient 0.1.28 → 0.1.31

package/dist/stellarv2/models.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * TypeScript models for FlashOnStellar V2 contract
+ * These models correspond to the Rust contract types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = exports.DataKey = exports.DealStatus = exports.BucketStatus = void 0;
+var BucketStatus;
+(function (BucketStatus) {
+    BucketStatus["Active"] = "Active";
+    BucketStatus["Inactive"] = "Inactive";
+    BucketStatus["Deleted"] = "Deleted";
+})(BucketStatus || (exports.BucketStatus = BucketStatus = {}));
+var DealStatus;
+(function (DealStatus) {
+    DealStatus["Pending"] = "Pending";
+    DealStatus["Accepted"] = "Accepted";
+    DealStatus["Funded"] = "Funded";
+    DealStatus["Completed"] = "Completed";
+    DealStatus["Cancelled"] = "Cancelled";
+    DealStatus["BreachedConsumer"] = "BreachedConsumer";
+    DealStatus["BreachedProvider"] = "BreachedProvider";
+})(DealStatus || (exports.DealStatus = DealStatus = {}));
+var DataKey;
+(function (DataKey) {
+    DataKey["Owner"] = "Owner";
+    DataKey["StableAssetAddress"] = "StableAssetAddress";
+    DataKey["Provider"] = "Provider";
+    DataKey["ProviderCount"] = "ProviderCount";
+    DataKey["ProviderMap"] = "ProviderMap";
+    DataKey["Consumer"] = "Consumer";
+    DataKey["ConsumerCount"] = "ConsumerCount";
+    DataKey["ConsumerMap"] = "ConsumerMap";
+    DataKey["Bucket"] = "Bucket";
+    DataKey["BucketCount"] = "BucketCount";
+    DataKey["BucketMap"] = "BucketMap";
+    DataKey["Deal"] = "Deal";
+    DataKey["DealCount"] = "DealCount";
+    DataKey["DealMap"] = "DealMap";
+    DataKey["ActiveDealMap"] = "ActiveDealMap";
+})(DataKey || (exports.DataKey = DataKey = {}));
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["ConsumerAlreadyExists"] = "ConsumerAlreadyExists";
+    ErrorCode["ProviderAlreadyExists"] = "ProviderAlreadyExists";
+    ErrorCode["BucketAlreadyExists"] = "BucketAlreadyExists";
+    ErrorCode["BucketLocked"] = "BucketLocked";
+    // Add more error codes as needed
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

package/dist/stellarv2/provider.d.ts

@@ -0,0 +1,72 @@
+import { ClientContext } from './client';
+import { Provider } from './models';
+/**
+ * Provider operations client for FlashOnStellar V2
+ * Implements all provider-related contract methods
+ */
+export declare class ProviderOps {
+    private context;
+    constructor(context: ClientContext);
+    /**
+     * Registers a new provider in the system
+     * @param provider_id - Address of the provider to register
+     * @param description - Description of the provider
+     * @returns Promise resolving to the registration result
+     */
+    registerProvider(provider_id: string, description: string): Promise<boolean>;
+    /**
+     * Updates an existing provider's information
+     * @param provider_id - Address of the provider to update
+     * @param description - New description for the provider
+     * @returns Promise resolving to the update result
+     */
+    updateProvider(provider_id: string, description: string): Promise<boolean>;
+    /**
+     * Deletes a provider from the system
+     * @param provider_id - Address of the provider to delete
+     * @returns Promise resolving to the deletion result
+     */
+    deleteProvider(provider_id: string): Promise<boolean>;
+    /**
+     * Retrieves provider information
+     * @param provider_id - Address of the provider to retrieve
+     * @returns Promise resolving to Provider object or null if not found
+     */
+    getProvider(provider_id: string): Promise<Provider | null>;
+    /**
+     * Gets the total count of providers in the system
+     * @returns Promise resolving to the total number of providers
+     */
+    getProviderCount(): Promise<number>;
+    /**
+     * Retrieves a paginated list of providers
+     * @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 provider addresses to Provider objects
+     */
+    getProviders(skip?: number, take?: number): Promise<Map<string, Provider>>;
+    /**
+     * Gets all buckets associated with a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of bucket IDs
+     */
+    getProviderBuckets(provider_id: string): Promise<string[]>;
+    /**
+     * Gets all deals associated with a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of deal IDs
+     */
+    getProviderDeals(provider_id: string): Promise<string[]>;
+    /**
+     * Gets all active deals associated with a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of active deal IDs
+     */
+    getProviderActiveDeals(provider_id: string): Promise<string[]>;
+    /**
+     * Gets the total number of units (buckets) owned by a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to the total number of units
+     */
+    getProviderUnitsCount(provider_id: string): Promise<number>;
+}

package/dist/stellarv2/provider.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderOps = void 0;
+const transaction_1 = require("./transaction");
+/**
+ * Provider operations client for FlashOnStellar V2
+ * Implements all provider-related contract methods
+ */
+class ProviderOps {
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Registers a new provider in the system
+     * @param provider_id - Address of the provider to register
+     * @param description - Description of the provider
+     * @returns Promise resolving to the registration result
+     */
+    async registerProvider(provider_id, description) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'register_provider',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: description, type: 'string' }
+            ]
+        });
+    }
+    /**
+     * Updates an existing provider's information
+     * @param provider_id - Address of the provider to update
+     * @param description - New description for the provider
+     * @returns Promise resolving to the update result
+     */
+    async updateProvider(provider_id, description) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'update_provider',
+            args: [
+                { value: provider_id, type: 'address' },
+                { value: description, type: 'string' }
+            ]
+        });
+    }
+    /**
+     * Deletes a provider from the system
+     * @param provider_id - Address of the provider to delete
+     * @returns Promise resolving to the deletion result
+     */
+    async deleteProvider(provider_id) {
+        return (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'delete_provider',
+            args: [
+                { value: provider_id, type: 'address' }
+            ]
+        });
+    }
+    /**
+     * Retrieves provider information
+     * @param provider_id - Address of the provider to retrieve
+     * @returns Promise resolving to Provider object or null if not found
+     */
+    async getProvider(provider_id) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, provider_id, {
+            method: 'get_provider',
+            args: [
+                { value: provider_id, type: 'address' }
+            ]
+        });
+        if (result && typeof result === 'object') {
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Gets the total count of providers in the system
+     * @returns Promise resolving to the total number of providers
+     */
+    async getProviderCount() {
+        const result = await (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'get_provider_count',
+            args: []
+        });
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
+    }
+    /**
+     * Retrieves a paginated list of providers
+     * @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 provider addresses to Provider objects
+     */
+    async getProviders(skip = 0, take = 10) {
+        const result = await (0, transaction_1.callContractMethod)(this.context, '', {
+            method: 'get_providers',
+            args: [
+                { value: skip, type: 'u32' },
+                { value: take, type: 'u32' }
+            ]
+        });
+        if (result && typeof result === 'object') {
+            // Convert the result to a Map<string, Provider>
+            const providerMap = new Map();
+            // Note: The actual conversion depends on how the contract returns the data
+            // This is a placeholder implementation
+            return providerMap;
+        }
+        return new Map();
+    }
+    /**
+     * Gets all buckets associated with a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of bucket IDs
+     */
+    async getProviderBuckets(provider_id) {
+        const provider = await this.getProvider(provider_id);
+        if (!provider) {
+            return [];
+        }
+        // Extract bucket IDs from the provider's buckets map
+        const bucketIds = [];
+        provider.buckets.forEach((_, bucketId) => {
+            bucketIds.push(bucketId);
+        });
+        return bucketIds;
+    }
+    /**
+     * Gets all deals associated with a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of deal IDs
+     */
+    async getProviderDeals(provider_id) {
+        const provider = await this.getProvider(provider_id);
+        if (!provider) {
+            return [];
+        }
+        // Extract deal IDs from the provider's deals map
+        const dealIds = [];
+        provider.deals.forEach((_, dealId) => {
+            dealIds.push(dealId);
+        });
+        return dealIds;
+    }
+    /**
+     * Gets all active deals associated with a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to an array of active deal IDs
+     */
+    async getProviderActiveDeals(provider_id) {
+        const provider = await this.getProvider(provider_id);
+        if (!provider) {
+            return [];
+        }
+        // Extract active deal IDs from the provider's active_deals map
+        const activeDealIds = [];
+        provider.active_deals.forEach((_, dealId) => {
+            activeDealIds.push(dealId);
+        });
+        return activeDealIds;
+    }
+    /**
+     * Gets the total number of units (buckets) owned by a provider
+     * @param provider_id - Address of the provider
+     * @returns Promise resolving to the total number of units
+     */
+    async getProviderUnitsCount(provider_id) {
+        const provider = await this.getProvider(provider_id);
+        if (!provider) {
+            return 0;
+        }
+        return provider.units_count;
+    }
+}
+exports.ProviderOps = ProviderOps;

package/dist/stellarv2/transaction.d.ts

@@ -0,0 +1,36 @@
+import { Transaction, Memo, MemoType, Operation, FeeBumpTransaction } from '@stellar/stellar-sdk';
+interface ClientContext {
+    network: StellarNetwork;
+    signTransaction?: (xdrToSign: string) => Promise<string>;
+    contractAddress: string;
+}
+interface StellarNetwork {
+    network: string;
+    networkPassphrase: string;
+}
+declare const getNetwork: (network: string) => StellarNetwork;
+declare const getPublicKeyFromPrivateKey: (privateKey: string) => string;
+interface ContractMethodCall {
+    method: string;
+    args?: Array<{
+        value: number | string | bigint | boolean | null | undefined;
+        type: 'u32' | 'i32' | 'u64' | 'i64' | 'u128' | 'i128' | 'string' | 'symbol' | 'address' | 'bool';
+    }>;
+}
+interface ContractMethodResponse {
+    isSuccess: boolean;
+    isReadOnly: boolean;
+    result: string | unknown;
+}
+declare const prepareTransaction: (context: ClientContext, address: string, contractCall: ContractMethodCall) => Promise<ContractMethodResponse>;
+declare const signTransaction: (context: ClientContext, xdrToSign: string, privateKey: string) => Promise<Transaction<Memo<MemoType>, Operation[]> | FeeBumpTransaction>;
+declare const sendTransaction: (context: ClientContext, signedTransactionXDR: string) => Promise<any>;
+/**
+ * Calls a contract method and handles the transaction flow
+ * @param context - Client context
+ * @param address - Address to use for the transaction
+ * @param contractCall - Contract method call details
+ * @returns Promise resolving to the method result
+ */
+declare const callContractMethod: (context: ClientContext, address: string, contractCall: ContractMethodCall) => Promise<any>;
+export { prepareTransaction, sendTransaction, signTransaction, callContractMethod, getNetwork, StellarNetwork, getPublicKeyFromPrivateKey, };

package/dist/stellarv2/transaction.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicKeyFromPrivateKey = exports.getNetwork = exports.callContractMethod = exports.signTransaction = exports.sendTransaction = exports.prepareTransaction = void 0;
+const timing_js_1 = require("../utils/timing.js");
+// Polyfill for BigInt JSON serialization
+BigInt.prototype.toJSON = function () {
+    return this.toString();
+};
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const stellar_sdk_2 = require("@stellar/stellar-sdk");
+const getNetwork = (network) => {
+    let networkPassphrase = '';
+    switch (network) {
+        case 'TESTNET':
+            networkPassphrase = 'Test SDF Network ; September 2015';
+            break;
+        case 'PUBLIC':
+            networkPassphrase = 'Public Global Stellar Network ; September 2015';
+            break;
+    }
+    return { network, networkPassphrase };
+};
+exports.getNetwork = getNetwork;
+const getPublicKeyFromPrivateKey = (privateKey) => {
+    const keypair = stellar_sdk_1.Keypair.fromSecret(privateKey);
+    return keypair.publicKey();
+};
+exports.getPublicKeyFromPrivateKey = getPublicKeyFromPrivateKey;
+const getServer = (network) => {
+    let serverUrl = '';
+    switch (network.network) {
+        case 'TESTNET':
+            serverUrl = 'https://soroban-testnet.stellar.org:443';
+            break;
+        case 'PUBLIC':
+            serverUrl = 'https://rpc.stellar.org:443';
+            break;
+    }
+    const server = new stellar_sdk_2.rpc.Server(serverUrl);
+    return server;
+};
+const TIMEOUT_TRANSACTION = 60;
+const prepareTransaction = async (context, address, contractCall) => {
+    const contractAddress = context.contractAddress;
+    const contract = new stellar_sdk_1.Contract(contractAddress);
+    const server = getServer(context.network);
+    const sourceAccount = await server.getAccount(address);
+    const response = {
+        isSuccess: false,
+        isReadOnly: false,
+        result: '',
+    };
+    // Convert raw values to ScVal
+    const convertedArgs = contractCall.args?.map((arg) => (0, stellar_sdk_1.nativeToScVal)(arg.value, { type: arg.type })) || [];
+    const builtTransaction = new stellar_sdk_1.TransactionBuilder(sourceAccount, {
+        fee: stellar_sdk_1.BASE_FEE,
+        networkPassphrase: context.network.networkPassphrase,
+    })
+        .addOperation(contract.call(contractCall.method, ...convertedArgs))
+        .setTimeout(TIMEOUT_TRANSACTION)
+        .build();
+    const sim = await server.simulateTransaction(builtTransaction);
+    if (stellar_sdk_2.rpc.Api.isSimulationSuccess(sim)) {
+        response.isSuccess = true;
+        //console.log('Simulation success:', JSON.stringify(sim));
+        const result = sim.result && sim.result.retval ? (0, stellar_sdk_1.scValToNative)(sim.result.retval) : undefined;
+        const footprint = sim.transactionData.getFootprint();
+        const isReadOnly = footprint.readOnly().length > 0 && footprint.readWrite().length === 0;
+        if (isReadOnly) {
+            response.isReadOnly = true;
+            response.result = result;
+            return response;
+        }
+        // For write operations, continue with the normal flow of returning the XDR
+        const preparedTransaction = await server.prepareTransaction(builtTransaction);
+        response.result = preparedTransaction.toXDR();
+        return response;
+    }
+    else {
+        if (stellar_sdk_2.rpc.Api.isSimulationError(sim)) {
+            throw new Error(`Tansaction simulation error: ${JSON.stringify(sim.error)}`);
+        }
+        throw new Error('Transaction simulation failed');
+    }
+};
+exports.prepareTransaction = prepareTransaction;
+const signTransaction = async (context, xdrToSign, privateKey) => {
+    const preparedTransaction = stellar_sdk_1.TransactionBuilder.fromXDR(xdrToSign, context.network.networkPassphrase);
+    const sourceKeypair = stellar_sdk_1.Keypair.fromSecret(privateKey);
+    preparedTransaction.sign(sourceKeypair);
+    return preparedTransaction;
+};
+exports.signTransaction = signTransaction;
+const sendTransaction = async (context, signedTransactionXDR) => {
+    const server = getServer(context.network);
+    const signedTransaction = stellar_sdk_1.TransactionBuilder.fromXDR(signedTransactionXDR, context.network.networkPassphrase);
+    // Submit the transaction to the Stellar-RPC server. The RPC server will
+    // then submit the transaction into the network for us. Then we will have to
+    // wait, polling `getTransaction` until the transaction completes.
+    try {
+        const sendResponse = await server.sendTransaction(signedTransaction);
+        if (sendResponse.status === 'PENDING') {
+            let getResponse = await server.getTransaction(sendResponse.hash);
+            // Poll `getTransaction` until the status is not "NOT_FOUND"
+            while (getResponse.status === 'NOT_FOUND') {
+                // See if the transaction is complete
+                getResponse = await server.getTransaction(sendResponse.hash);
+                // Wait one second
+                await (0, timing_js_1.sleep)(1000);
+            }
+            //console.log(`getTransaction response: ${JSON.stringify(getResponse)}`);
+            if (getResponse.status === 'SUCCESS') {
+                // Make sure the transaction's resultMetaXDR is not empty
+                if (!getResponse.resultMetaXdr) {
+                    throw new Error('Empty resultMetaXDR in getTransaction response');
+                }
+                // Find the return value from the contract and return it
+                const transactionMeta = getResponse.resultMetaXdr;
+                const returnValue = transactionMeta.v3().sorobanMeta()?.returnValue();
+                if (returnValue) {
+                    return (0, stellar_sdk_1.scValToNative)(returnValue);
+                }
+            }
+            else {
+                throw new Error(`Transaction failed: ${getResponse.resultXdr}`);
+            }
+        }
+        else {
+            throw new Error(sendResponse.errorResult?.toString() || 'Unknown error');
+        }
+    }
+    catch (err) {
+        // Catch and report any errors we've thrown
+        throw new Error(`Transaction sending error: ${JSON.stringify(err)}`);
+    }
+};
+exports.sendTransaction = sendTransaction;
+/**
+ * Calls a contract method and handles the transaction flow
+ * @param context - Client context
+ * @param address - Address to use for the transaction
+ * @param contractCall - Contract method call details
+ * @returns Promise resolving to the method result
+ */
+const callContractMethod = async (context, address, contractCall) => {
+    try {
+        // Prepare the transaction
+        const preparedResponse = await prepareTransaction(context, address, contractCall);
+        if (preparedResponse.isReadOnly) {
+            // For read-only operations, return the result directly
+            return preparedResponse.result;
+        }
+        // For write operations, we need to sign and send the transaction
+        if (!context.signTransaction) {
+            throw new Error('Sign transaction callback required for write operations');
+        }
+        // Sign the transaction
+        const signedXDR = await context.signTransaction(preparedResponse.result);
+        // Send the signed transaction
+        const result = await sendTransaction(context, signedXDR);
+        return result;
+    }
+    catch (error) {
+        console.error('Error calling contract method:', error);
+        throw error;
+    }
+};
+exports.callContractMethod = callContractMethod;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flashbacktech/flashbackclient",
-  "version": "0.1.28",
+  "version": "0.1.31",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"