@flashbacktech/flashbackclient 0.0.13

package/dist/stellar/provider.js

@@ -0,0 +1,77 @@
+import { prepareTransaction, sendTransaction } from './transaction.js';
+const get_provider = async (context, wallet_address, provider_address, load_units = false) => {
+    const [provider, units] = await Promise.all([
+        prepareTransaction(context, wallet_address, {
+            method: 'get_provider',
+            args: [{ value: provider_address, type: 'address' }],
+        }),
+        load_units
+            ? get_provider_units(context, wallet_address, provider_address)
+            : new Map(),
+    ]);
+    const typedProviderData = provider.isSuccess ? provider.result : null;
+    if (typedProviderData) {
+        typedProviderData.units = units;
+    }
+    return typedProviderData;
+};
+const get_provider_units = async (context, wallet_address, provider_address) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_provider_units',
+        args: [{ value: provider_address, type: 'address' }],
+    });
+    const typedProviderUnits = response.isSuccess
+        ? response.result
+        : new Map();
+    return typedProviderUnits;
+};
+const get_providers = async (context, wallet_address, skip = 0, take = 10) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_providers',
+        args: [
+            { value: skip, type: 'u32' },
+            { value: take, type: 'u32' },
+        ],
+    });
+    if (!response.isSuccess) {
+        return new Map();
+    }
+    const providersObj = response.result;
+    return new Map(Object.entries(providersObj));
+};
+const get_provider_count = async (context, wallet_address) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_provider_count',
+    });
+    return response.isSuccess ? response.result : 0;
+};
+// Helper function to handle write-mode contract calls
+const executeProviderTransaction = async (context, wallet_address, provider_address, method, additionalArgs = []) => {
+    const isOwner = wallet_address !== provider_address;
+    const response = await prepareTransaction(context, wallet_address, {
+        method,
+        args: [
+            { value: provider_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_provider = async (context, wallet_address, provider_address, provider_description) => {
+    await executeProviderTransaction(context, wallet_address, provider_address, 'register_provider', [
+        { value: provider_description, type: 'string' },
+    ]);
+};
+const delete_provider = async (context, wallet_address, provider_address) => {
+    await executeProviderTransaction(context, wallet_address, provider_address, 'delete_provider');
+};
+const update_provider = async (context, wallet_address, provider_address, provider_description) => {
+    await executeProviderTransaction(context, wallet_address, provider_address, 'update_provider', [
+        { value: provider_description, type: 'string' },
+    ]);
+};
+export { get_provider, get_provider_units, get_providers, get_provider_count, register_provider, delete_provider, update_provider, };

package/dist/stellar/reservation.d.ts

@@ -0,0 +1,8 @@
+import { ClientContext } from './client.js';
+import { DeletionStatus, StorageReservation } from './models.js';
+declare const get_reservation: (context: ClientContext, wallet_address: string, reservation_id: number) => Promise<StorageReservation | null>;
+declare const create_reservation: (context: ClientContext, wallet_address: string, consumer_address: string, unit_id: number, reserved_gb: number) => Promise<boolean>;
+declare const delete_reservation: (context: ClientContext, wallet_address: string, consumer_address: string, reservation_id: number) => Promise<DeletionStatus>;
+declare const update_inuse_bytes_consumer: (context: ClientContext, wallet_address: string, consumer_address: string, reservation_id: number, inuse_bytes: number) => Promise<boolean>;
+declare const update_inuse_bytes_provider: (context: ClientContext, wallet_address: string, provider_address: string, reservation_id: number, inuse_bytes: number) => Promise<boolean>;
+export { get_reservation, create_reservation, delete_reservation, update_inuse_bytes_consumer, update_inuse_bytes_provider, };

package/dist/stellar/reservation.js

@@ -0,0 +1,54 @@
+import { prepareTransaction, sendTransaction } from './transaction.js';
+const get_reservation = async (context, wallet_address, reservation_id) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_reservation',
+        args: [{ value: reservation_id, type: 'u32' }],
+    });
+    return response.isSuccess ? response.result : null;
+};
+const executeReservationTransaction = async (context, wallet_address, method, additionalArgs = [], defaultValue) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method,
+        args: additionalArgs,
+    });
+    if (response.isSuccess && !response.isReadOnly) {
+        const signedTxXDR = await context.signTransaction(response.result);
+        return sendTransaction(context, signedTxXDR);
+    }
+    return defaultValue;
+};
+const create_reservation = async (context, wallet_address, consumer_address, unit_id, reserved_gb) => {
+    const isOwner = wallet_address !== consumer_address;
+    return executeReservationTransaction(context, wallet_address, 'create_reservation', [
+        { value: consumer_address, type: 'address' },
+        { value: unit_id, type: 'u32' },
+        { value: reserved_gb, type: 'u64' },
+        { value: isOwner, type: 'bool' },
+    ]);
+};
+const delete_reservation = async (context, wallet_address, consumer_address, reservation_id) => {
+    const isOwner = wallet_address !== consumer_address;
+    return (executeReservationTransaction(context, wallet_address, 'delete_reservation', [
+        { value: reservation_id, type: 'u32' },
+        { value: isOwner, type: 'bool' },
+    ]) || 'NotFound');
+};
+const update_inuse_bytes_consumer = async (context, wallet_address, consumer_address, reservation_id, inuse_bytes) => {
+    const isOwner = wallet_address !== consumer_address;
+    return executeReservationTransaction(context, wallet_address, 'update_inuse_bytes_consumer', [
+        { value: reservation_id, type: 'u32' },
+        { value: consumer_address, type: 'address' },
+        { value: inuse_bytes, type: 'u64' },
+        { value: isOwner, type: 'bool' },
+    ]);
+};
+const update_inuse_bytes_provider = async (context, wallet_address, provider_address, reservation_id, inuse_bytes) => {
+    const isOwner = wallet_address !== provider_address;
+    return executeReservationTransaction(context, wallet_address, 'update_inuse_bytes_consumer', [
+        { value: reservation_id, type: 'u32' },
+        { value: provider_address, type: 'address' },
+        { value: inuse_bytes, type: 'u64' },
+        { value: isOwner, type: 'bool' },
+    ]);
+};
+export { get_reservation, create_reservation, delete_reservation, update_inuse_bytes_consumer, update_inuse_bytes_provider, };

package/dist/stellar/stats.d.ts

@@ -0,0 +1,4 @@
+import { ClientContext } from './client.js';
+import { ContractStats } from './models.js';
+declare const get_stats: (context: ClientContext, wallet_address: string) => Promise<ContractStats | null>;
+export { get_stats };

package/dist/stellar/stats.js

@@ -0,0 +1,9 @@
+import { prepareTransaction } from './transaction.js';
+const get_stats = async (context, wallet_address) => {
+    const stats = await prepareTransaction(context, wallet_address, {
+        method: 'get_stats',
+        args: [],
+    });
+    return stats.isSuccess ? stats.result : null;
+};
+export { get_stats };

package/dist/stellar/transaction.d.ts

@@ -0,0 +1,24 @@
+import { Transaction, Memo, MemoType, Operation, FeeBumpTransaction } from '@stellar/stellar-sdk';
+import { ClientContext } from './client.js';
+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' | '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>;
+export { prepareTransaction, sendTransaction, signTransaction, getNetwork, StellarNetwork, getPublicKeyFromPrivateKey, };

package/dist/stellar/transaction.js

@@ -0,0 +1,130 @@
+import { sleep } from '../utils/timing.js';
+// Polyfill for BigInt JSON serialization
+BigInt.prototype.toJSON = function () {
+    return this.toString();
+};
+import { Contract, TransactionBuilder, nativeToScVal, BASE_FEE, scValToNative, Keypair, } from '@stellar/stellar-sdk';
+import { rpc } from '@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 };
+};
+const getPublicKeyFromPrivateKey = (privateKey) => {
+    const keypair = Keypair.fromSecret(privateKey);
+    return keypair.publicKey();
+};
+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 rpc.Server(serverUrl);
+    return server;
+};
+const TIMEOUT_TRANSACTION = 60;
+const prepareTransaction = async (context, address, contractCall) => {
+    const contractAddress = context.contractAddress;
+    const contract = new 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) => nativeToScVal(arg.value, { type: arg.type })) || [];
+    const builtTransaction = new TransactionBuilder(sourceAccount, {
+        fee: BASE_FEE,
+        networkPassphrase: context.network.networkPassphrase,
+    })
+        .addOperation(contract.call(contractCall.method, ...convertedArgs))
+        .setTimeout(TIMEOUT_TRANSACTION)
+        .build();
+    const sim = await server.simulateTransaction(builtTransaction);
+    if (rpc.Api.isSimulationSuccess(sim)) {
+        response.isSuccess = true;
+        //console.log('Simulation success:', JSON.stringify(sim));
+        const result = sim.result && sim.result.retval ? 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 (rpc.Api.isSimulationError(sim)) {
+            throw new Error(`Tansaction simulation error: ${JSON.stringify(sim.error)}`);
+        }
+        throw new Error('Transaction simulation failed');
+    }
+};
+const signTransaction = async (context, xdrToSign, privateKey) => {
+    const preparedTransaction = TransactionBuilder.fromXDR(xdrToSign, context.network.networkPassphrase);
+    const sourceKeypair = Keypair.fromSecret(privateKey);
+    preparedTransaction.sign(sourceKeypair);
+    return preparedTransaction;
+};
+const sendTransaction = async (context, signedTransactionXDR) => {
+    const server = getServer(context.network);
+    const signedTransaction = 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 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 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)}`);
+    }
+};
+export { prepareTransaction, sendTransaction, signTransaction, getNetwork, getPublicKeyFromPrivateKey, };

package/dist/stellar/unit.d.ts

@@ -0,0 +1,12 @@
+import { ClientContext } from './client.js';
+import { DeletionStatus, StorageReservation, StorageUnit } from './models.js';
+type RegisterUnitResponse = [unitId: number, unit: StorageUnit];
+declare const get_unit: (context: ClientContext, wallet_address: string, unit_id: number, load_reservations?: boolean) => Promise<StorageUnit | null>;
+declare const get_unit_reservations: (context: ClientContext, wallet_address: string, unit_id: number) => Promise<Map<number, StorageReservation>>;
+declare const register_unit: (context: ClientContext, wallet_address: string, provider_address: string, capacity: number, endpoint: string) => Promise<RegisterUnitResponse | null>;
+declare const delete_unit: (context: ClientContext, wallet_address: string, provider_address: string, unit_id: number) => Promise<DeletionStatus | null>;
+declare const enter_maintenance: (context: ClientContext, wallet_address: string, provider_address: string, unit_id: number, maintenanceStart: Date, maintenanceEnd: Date) => Promise<boolean | null>;
+declare const exit_maintenance: (context: ClientContext, wallet_address: string, provider_address: string, unit_id: number) => Promise<boolean | null>;
+declare const enter_decommissioning: (context: ClientContext, wallet_address: string, provider_address: string, unit_id: number) => Promise<boolean | null>;
+declare const exit_decommissioning: (context: ClientContext, wallet_address: string, provider_address: string, unit_id: number) => Promise<boolean | null>;
+export { get_unit, get_unit_reservations, register_unit, delete_unit, enter_maintenance, exit_maintenance, enter_decommissioning, exit_decommissioning, };

package/dist/stellar/unit.js

@@ -0,0 +1,90 @@
+import { prepareTransaction, sendTransaction } from './transaction.js';
+const get_unit = async (context, wallet_address, unit_id, load_reservations = false) => {
+    const [unit, reservations] = await Promise.all([
+        prepareTransaction(context, wallet_address, {
+            method: 'get_unit',
+            args: [{ value: unit_id, type: 'u32' }],
+        }),
+        load_reservations
+            ? get_unit_reservations(context, wallet_address, unit_id)
+            : new Map(),
+    ]);
+    const typedUnitData = unit.isSuccess ? unit.result : null;
+    if (typedUnitData) {
+        typedUnitData.reservations = reservations;
+    }
+    return typedUnitData;
+};
+const get_unit_reservations = async (context, wallet_address, unit_id) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method: 'get_unit_reservations',
+        args: [{ value: unit_id, type: 'u32' }],
+    });
+    const typedUnitReservations = response.isSuccess
+        ? response.result
+        : new Map();
+    return typedUnitReservations;
+};
+const executeUnitTransaction = async (context, wallet_address, provider_address, method, additionalArgs = []) => {
+    const isOwner = wallet_address !== provider_address;
+    const response = await prepareTransaction(context, wallet_address, {
+        method,
+        args: [
+            { value: provider_address, type: 'address' },
+            ...additionalArgs,
+            { value: isOwner, type: 'bool' },
+        ],
+    });
+    if (response.isSuccess && !response.isReadOnly) {
+        const signedTxXDR = await context.signTransaction(response.result);
+        return sendTransaction(context, signedTxXDR);
+    }
+    return null;
+};
+const register_unit = async (context, wallet_address, provider_address, capacity, endpoint) => {
+    return executeUnitTransaction(context, wallet_address, provider_address, 'register_unit', [
+        { value: capacity, type: 'u32' },
+        { value: endpoint, type: 'string' },
+    ]);
+};
+const delete_unit = async (context, wallet_address, provider_address, unit_id) => {
+    return executeUnitTransaction(context, wallet_address, provider_address, 'delete_unit', [{ value: unit_id, type: 'u32' }]);
+};
+const change_unit_status = async (context, method, wallet_address, provider_address, unit_id, maintenanceStart, maintenanceEnd) => {
+    const isOwner = wallet_address !== provider_address;
+    const response = await prepareTransaction(context, wallet_address, {
+        method: method,
+        args: [
+            { value: provider_address, type: 'address' },
+            { value: unit_id, type: 'u32' },
+            ...(method === 'enter_maintenance'
+                ? [
+                    { value: Math.floor(maintenanceStart.getTime() / 1000), type: 'u64' },
+                    { value: Math.floor(maintenanceEnd.getTime() / 1000), type: 'u64' },
+                ]
+                : []),
+            { value: isOwner, type: 'bool' },
+        ],
+    });
+    if (response.isSuccess && !response.isReadOnly) {
+        const signedTxXDR = await context.signTransaction(response.result);
+        const responseSend = (await sendTransaction(context, signedTxXDR));
+        return responseSend;
+    }
+    return null;
+};
+const createUnitMaintenanceChanger = (method) => {
+    return async (context, wallet_address, provider_address, unit_id, maintenanceStart, maintenanceEnd) => {
+        return change_unit_status(context, method, wallet_address, provider_address, unit_id, maintenanceStart, maintenanceEnd);
+    };
+};
+const createUnitStatusChanger = (method) => {
+    return async (context, wallet_address, provider_address, unit_id) => {
+        return change_unit_status(context, method, wallet_address, provider_address, unit_id);
+    };
+};
+const enter_maintenance = createUnitMaintenanceChanger('enter_maintenance');
+const exit_maintenance = createUnitStatusChanger('exit_maintenance');
+const enter_decommissioning = createUnitStatusChanger('enter_decommissioning');
+const exit_decommissioning = createUnitStatusChanger('exit_decommissioning');
+export { get_unit, get_unit_reservations, register_unit, delete_unit, enter_maintenance, exit_maintenance, enter_decommissioning, exit_decommissioning, };

package/dist/utils/timing.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/utils/timing.js

@@ -0,0 +1,15 @@
+const getGlobalThis = () => {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    throw new Error('Unable to locate global object');
+};
+export const sleep = (ms) => {
+    const globalScope = getGlobalThis();
+    return new Promise((resolve) => globalScope.setTimeout(resolve, ms));
+};

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@flashbacktech/flashbackclient",
+  "version": "0.0.13",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "dev": "tsc",
+    "dev:watch": "nodemon --exec 'npm run dev || exit 1'",
+    "lint": "eslint . --ext .ts",
+    "build": "npm run dev",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "clean": "rm -rf dist",
+    "format": "eslint \"**/*.ts\" --ignore-pattern 'dist/**' --fix && prettier --write . --ignore-path .gitignore",
+    "docs": "typedoc",
+    "pub": "npm run build && npm version patch && npm publish --access public"
+  },
+  "author": "Javier Ortiz <javier.ortiz@flashback.tech>",
+  "license": "ISC",
+  "dependencies": {
+    "@stellar/stellar-sdk": "^13.0.0"
+  },
+  "bin": {
+    "": "./dist/.min.js"
+  },
+  "exports": {
+    "./stellar": {
+      "types": "./dist/stellar/index.d.ts",
+      "import": "./dist/stellar/index.js",
+      "default": "./dist/stellar/index.js"
+    },
+    "./path2": {
+      "types": "./dist/path2/index.d.ts",
+      "import": "./dist/path2/index.js",
+      "default": "./dist/path2/index.js"
+    },
+    "./path3": {
+      "types": "./dist/path3/index.d.ts",
+      "import": "./dist/path3/index.js",
+      "default": "./dist/path3/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^8.56.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.1",
+    "@typescript-eslint/eslint-plugin": "^8.17.0",
+    "@typescript-eslint/parser": "^8.17.0",
+    "dotenv": "^16.4.7",
+    "eslint": "^9.16.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.4.1",
+    "ts-jest": "^29.2.5",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.7.2"
+  },
+  "type": "module",
+  "typesVersions": {
+    "*": {
+      "stellar": [
+        "./dist/stellar/index.d.ts"
+      ],
+      "path2": [
+        "./dist/path2/index.d.ts"
+      ],
+      "path3": [
+        "./dist/path3/index.d.ts"
+      ]
+    }
+  }
+}