@flashbacktech/flashbackclient 0.1.34 → 0.1.36

package/dist/stellarv2/utils/decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSignature = withSignature;
+exports.withSignatureProperty = withSignatureProperty;
+function withSignature(method) {
+    return async function (...args) {
+        const context = this.getContext();
+        if (!context.signTransaction) {
+            throw new Error("FlashOnStellarClient: signTransaction method is required for write operations");
+        }
+        return method.apply(this, args);
+    };
+}
+// For arrow functions/properties
+function withSignatureProperty(target, propertyKey) {
+    const value = target[propertyKey];
+    Object.defineProperty(target, propertyKey, {
+        configurable: true,
+        enumerable: true,
+        get() {
+            return async (...args) => {
+                const context = this.getContext();
+                if (!context.signTransaction) {
+                    throw new Error("FlashOnStellarClient: signTransaction method is required for write operations");
+                }
+                return value.apply(this, args);
+            };
+        },
+    });
+}

package/dist/stellarv2/utils/lib.d.ts

@@ -0,0 +1,13 @@
+export type Environment = "node" | "browser";
+/**
+ * Detects the current runtime environment
+ */
+export declare function getEnvironment(): Environment;
+/**
+ * Checks if the code is running in a browser environment
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Checks if the code is running in a Node.js environment
+ */
+export declare function isNode(): boolean;

package/dist/stellarv2/utils/lib.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironment = getEnvironment;
+exports.isBrowser = isBrowser;
+exports.isNode = isNode;
+/**
+ * Detects the current runtime environment
+ */
+function getEnvironment() {
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+        return "browser";
+    }
+    return "node";
+}
+/**
+ * Checks if the code is running in a browser environment
+ */
+function isBrowser() {
+    return getEnvironment() === "browser";
+}
+/**
+ * Checks if the code is running in a Node.js environment
+ */
+function isNode() {
+    return getEnvironment() === "node";
+}

package/dist/stellarv2/utils/timing.d.ts

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

package/dist/stellarv2/utils/timing.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+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");
+};
+const sleep = (ms) => {
+    const globalScope = getGlobalThis();
+    return new Promise((resolve) => globalScope.setTimeout(resolve, ms));
+};
+exports.sleep = sleep;

package/dist/stellarv2/wallet/balance.d.ts

@@ -0,0 +1,2 @@
+import { AccountResponse } from "@stellar/stellar-sdk/lib/horizon";
+export declare function getBalances(accountAddress: string, network: string): Promise<AccountResponse["balances"]>;

package/dist/stellarv2/wallet/balance.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBalances = getBalances;
+const transaction_1 = require("./transaction");
+async function getBalances(accountAddress, network) {
+    const server = (0, transaction_1.getHorizonServer)(network);
+    const account = await server.loadAccount(accountAddress);
+    return account.balances;
+}

package/dist/stellarv2/wallet/batch.d.ts

@@ -0,0 +1,44 @@
+import { ClientContext } from "../client/index";
+export type ContractArg = {
+    value: string | number | bigint | boolean | null | undefined;
+    type: "string" | "symbol" | "address" | "u32" | "i32" | "u64" | "i64" | "bool";
+};
+export type ReadOperation<T> = {
+    method: string;
+    getArgs: (wallet_address: string, ...extraParams: any[]) => ContractArg[];
+    transformResult: (result: any) => T;
+};
+export type BatchedOperation<T> = {
+    operation: string;
+    params: any[];
+    transform: (result: any) => T;
+};
+export type BatchedWriteOperation = {
+    operation: string;
+    params: any[];
+};
+/**
+ * Executes multiple read operations in a single transaction
+ * @param context The client context
+ * @param wallet_address The wallet address to use for the operations
+ * @param operations Array of operations with their parameters to execute
+ * @returns Array of results in the same order as the input operations
+ */
+export declare function batchReadOperations<T>(context: ClientContext, wallet_address: string, operations: BatchedOperation<T>[]): Promise<T[]>;
+/**
+ * Creates a read operation with the given method and transform function
+ * @param method The contract method to call
+ * @param getArgs Function that generates the arguments for the method
+ * @param transformResult Function that transforms the raw result into the expected type
+ * @returns A ReadOperation object
+ */
+export declare function createReadOperation<T>(method: string, getArgs: (wallet_address: string, ...extraParams: any[]) => ContractArg[], transformResult: (result: any) => T): ReadOperation<T>;
+export declare function createOperationFromMethod<T>(method: string, transformResult: (result: any) => T): ReadOperation<T>;
+/**
+ * Executes multiple write operations in a single transaction
+ * @param context The client context
+ * @param wallet_address The wallet address to use for the operations
+ * @param operations Array of operations with their parameters to execute
+ * @returns void
+ */
+export declare function batchWriteOperations(context: ClientContext, wallet_address: string, operations: BatchedWriteOperation[]): Promise<void>;

package/dist/stellarv2/wallet/batch.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchReadOperations = batchReadOperations;
+exports.createReadOperation = createReadOperation;
+exports.createOperationFromMethod = createOperationFromMethod;
+exports.batchWriteOperations = batchWriteOperations;
+const transaction_1 = require("./transaction");
+/**
+ * Executes multiple read operations in a single transaction
+ * @param context The client context
+ * @param wallet_address The wallet address to use for the operations
+ * @param operations Array of operations with their parameters to execute
+ * @returns Array of results in the same order as the input operations
+ */
+async function batchReadOperations(context, wallet_address, operations) {
+    const contractCalls = operations.map(({ operation, params }) => ({
+        method: operation,
+        args: [
+            { value: wallet_address, type: "address" },
+            ...params.map((param) => ({ value: param, type: "string" })),
+        ],
+    }));
+    const response = await (0, transaction_1.prepareTransaction)(context, wallet_address, contractCalls);
+    if (!response.isSuccess || !response.isReadOnly) {
+        throw new Error("Batch read operation failed");
+    }
+    const results = Array.isArray(response.result)
+        ? response.result
+        : [response.result];
+    return operations.map(({ transform }, index) => transform(results[index]));
+}
+/**
+ * Creates a read operation with the given method and transform function
+ * @param method The contract method to call
+ * @param getArgs Function that generates the arguments for the method
+ * @param transformResult Function that transforms the raw result into the expected type
+ * @returns A ReadOperation object
+ */
+function createReadOperation(method, getArgs, transformResult) {
+    return {
+        method,
+        getArgs,
+        transformResult,
+    };
+}
+function createOperationFromMethod(method, transformResult) {
+    return createReadOperation(method, (wallet_address, ...extraParams) => {
+        // First arg is always wallet_address
+        const args = [{ value: wallet_address, type: "address" }];
+        // Add any extra params as strings (or we could make this more sophisticated)
+        extraParams.forEach((param) => {
+            args.push({ value: param, type: "string" });
+        });
+        return args;
+    }, transformResult);
+}
+/**
+ * Executes multiple write operations in a single transaction
+ * @param context The client context
+ * @param wallet_address The wallet address to use for the operations
+ * @param operations Array of operations with their parameters to execute
+ * @returns void
+ */
+async function batchWriteOperations(context, wallet_address, operations) {
+    const contractCalls = operations.map(({ operation, params }) => ({
+        method: operation,
+        args: [
+            { value: wallet_address, type: "address" },
+            ...params.map((param) => ({ value: param, type: "string" })),
+        ],
+    }));
+    const response = await (0, transaction_1.prepareTransaction)(context, wallet_address, contractCalls);
+    if (response.isSuccess && !response.isReadOnly) {
+        const signedTxXDR = await context.signTransaction(response.result);
+        await (0, transaction_1.sendTransaction)(context, signedTxXDR);
+    }
+}

package/dist/stellarv2/wallet/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./token";
+export * from "./transaction";
+export * from "./balance";
+export * from "./batch";

package/dist/stellarv2/wallet/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./token"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./balance"), exports);
+__exportStar(require("./batch"), exports);

package/dist/stellarv2/wallet/token.d.ts

@@ -0,0 +1,3 @@
+import { StellarNetwork } from "./transaction";
+declare const changeTrustXDR: (network: StellarNetwork, source: string, issuerPublikKey: string, asset_ticker: string, bRemove: boolean) => Promise<string>;
+export { changeTrustXDR };

package/dist/stellarv2/wallet/token.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeTrustXDR = void 0;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const transaction_1 = require("./transaction");
+const changeTrustXDR = async (network, source, issuerPublikKey, asset_ticker, bRemove) => {
+    const server = (0, transaction_1.getServer)(network);
+    const account = await server.getAccount(source);
+    const asset = new stellar_sdk_1.Asset(asset_ticker, issuerPublikKey);
+    const changeParams = bRemove ? { limit: "0" } : {};
+    const transaction = new stellar_sdk_1.TransactionBuilder(account, {
+        fee: stellar_sdk_1.BASE_FEE,
+        networkPassphrase: network.networkPassphrase,
+    })
+        .addOperation(stellar_sdk_1.Operation.changeTrust({
+        asset,
+        ...changeParams,
+    }))
+        .setTimeout(30)
+        .build();
+    return transaction.toXDR();
+};
+exports.changeTrustXDR = changeTrustXDR;

package/dist/stellarv2/wallet/transaction.d.ts

@@ -0,0 +1,38 @@
+import { Transaction, Memo, MemoType, Operation, FeeBumpTransaction, Horizon } from "@stellar/stellar-sdk";
+import { rpc } from "@stellar/stellar-sdk";
+import { ClientContext } from "../client";
+export interface StellarNetwork {
+    network: string;
+    networkPassphrase: string;
+}
+declare const getNetwork: (network: string) => StellarNetwork;
+declare const getPublicKeyFromPrivateKey: (privateKey: string) => string;
+declare const getServer: (network: StellarNetwork) => rpc.Server;
+interface ContractMethodCall {
+    method: string;
+    args?: Array<{
+        value: number | string | bigint | boolean | null | undefined | Array<unknown>;
+        type: "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "string" | "symbol" | "address" | "bool" | "vec";
+    }>;
+}
+interface ContractMethodResponse {
+    isSuccess: boolean;
+    isReadOnly: boolean;
+    result: string | unknown;
+}
+export declare const getHorizonServer: (network: string) => Horizon.Server;
+export declare const executeWalletTransaction: (context: ClientContext, wallet_address: string, method: string, additionalArgs?: Array<{
+    value: string | number | bigint | boolean | null | Array<unknown> | undefined;
+    type: "string" | "symbol" | "address" | "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "bool" | "vec";
+}>) => Promise<ContractMethodResponse>;
+export declare const executeMultiWalletTransactions: (context: ClientContext, wallet_address: string, methods: Array<{
+    method: string;
+    additionalArgs?: Array<{
+        value: string | number | bigint | boolean | null | undefined;
+        type: "string" | "symbol" | "address" | "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "bool" | "vec";
+    }>;
+}>) => Promise<ContractMethodResponse>;
+declare const prepareTransaction: (context: ClientContext, address: string, contractCalls: ContractMethodCall | 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, bDebug?: boolean) => Promise<any>;
+export { prepareTransaction, sendTransaction, signTransaction, getNetwork, getPublicKeyFromPrivateKey, getServer, };

package/dist/stellarv2/wallet/transaction.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServer = exports.getPublicKeyFromPrivateKey = exports.getNetwork = exports.signTransaction = exports.sendTransaction = exports.prepareTransaction = exports.executeMultiWalletTransactions = exports.executeWalletTransaction = exports.getHorizonServer = void 0;
+const timing_1 = require("../utils/timing");
+// 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";
+            break;
+        case "PUBLIC":
+            serverUrl = "https://rpc.stellar.org";
+            break;
+    }
+    // For newer versions of Stellar SDK, we need to allow HTTP connections
+    // even for HTTPS URLs due to how the SDK handles server connections
+    const server = new stellar_sdk_2.rpc.Server(serverUrl, {
+        allowHttp: true
+    });
+    return server;
+};
+exports.getServer = getServer;
+const TIMEOUT_TRANSACTION = 60;
+const getHorizonServer = (network) => {
+    if (network === "TESTNET") {
+        return new stellar_sdk_1.Horizon.Server("https://horizon-testnet.stellar.org", {
+            allowHttp: true
+        });
+    }
+    else {
+        return new stellar_sdk_1.Horizon.Server("https://horizon.stellar.org", {
+            allowHttp: true
+        });
+    }
+};
+exports.getHorizonServer = getHorizonServer;
+const executeWalletTransaction = async (context, wallet_address, method, additionalArgs = []) => {
+    const response = await prepareTransaction(context, wallet_address, {
+        method,
+        args: [{ value: wallet_address, type: "address" }, ...additionalArgs],
+    });
+    if (response.isSuccess) {
+        if (response.isReadOnly) {
+            return response;
+        }
+        const signedTxXDR = await context.signTransaction(response.result);
+        const sendResponse = await sendTransaction(context, signedTxXDR);
+        return {
+            isSuccess: true,
+            isReadOnly: false,
+            result: sendResponse,
+        };
+    }
+    return response;
+};
+exports.executeWalletTransaction = executeWalletTransaction;
+const executeMultiWalletTransactions = async (context, wallet_address, methods) => {
+    const contractCalls = methods.map(({ method, additionalArgs = [] }) => ({
+        method,
+        args: [
+            { value: wallet_address, type: "address" },
+            ...additionalArgs,
+        ],
+    }));
+    const response = await prepareTransaction(context, wallet_address, contractCalls);
+    if (response.isSuccess) {
+        if (response.isReadOnly) {
+            return response;
+        }
+        const signedTxXDR = await context.signTransaction(response.result);
+        const sendResponse = await sendTransaction(context, signedTxXDR);
+        return {
+            isSuccess: true,
+            isReadOnly: false,
+            result: sendResponse,
+        };
+    }
+    return response;
+};
+exports.executeMultiWalletTransactions = executeMultiWalletTransactions;
+const prepareTransaction = async (context, address, contractCalls) => {
+    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: "",
+    };
+    // Ensure contractCalls is an array
+    const calls = Array.isArray(contractCalls) ? contractCalls : [contractCalls];
+    // Convert raw values to ScVal for all calls
+    const convertedCalls = calls.map((call) => {
+        const converted = {
+            method: call.method,
+            args: call.args?.map((arg) => {
+                let scVal;
+                if (arg.type === "vec") {
+                    if (arg.value === null) {
+                        // Handle null vectors as None
+                        scVal = (0, stellar_sdk_1.nativeToScVal)(null, { type: "vec" });
+                    }
+                    else if (Array.isArray(arg.value)) {
+                        // Handle non-empty vectors
+                        const vecScVals = arg.value.map((item) => (0, stellar_sdk_1.nativeToScVal)(item.value, { type: item.type }));
+                        scVal = (0, stellar_sdk_1.nativeToScVal)({ vec: vecScVals }, { type: "vec" });
+                    }
+                    else {
+                        // Fallback for invalid vector values
+                        scVal = (0, stellar_sdk_1.nativeToScVal)(null, { type: "vec" });
+                    }
+                }
+                else {
+                    scVal = (0, stellar_sdk_1.nativeToScVal)(arg.value, { type: arg.type });
+                }
+                return scVal;
+            }) || [],
+        };
+        return converted;
+    });
+    const transactionBuilder = new stellar_sdk_1.TransactionBuilder(sourceAccount, {
+        fee: stellar_sdk_1.BASE_FEE,
+        networkPassphrase: context.network.networkPassphrase,
+    });
+    // Add all operations to the transaction
+    convertedCalls.forEach((call) => {
+        transactionBuilder.addOperation(contract.call(call.method, ...call.args));
+    });
+    const builtTransaction = transactionBuilder
+        .setTimeout(TIMEOUT_TRANSACTION)
+        .build();
+    const sim = await server.simulateTransaction(builtTransaction);
+    if (stellar_sdk_2.rpc.Api.isSimulationSuccess(sim)) {
+        response.isSuccess = true;
+        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(`Transaction 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, bDebug = false) => {
+    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);
+            while (getResponse.status === "NOT_FOUND") {
+                // See if the transaction is complete
+                getResponse = await server.getTransaction(sendResponse.hash);
+                // Wait one second
+                await (0, timing_1.sleep)(1000);
+            }
+            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);
+                }
+                return getResponse; // Return the full transaction response
+            }
+            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;

package/package.json

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