@twin.org/dlt-iota 0.0.2-next.8 → 0.0.3-next.1

package/README.md

@@ -12,90 +12,10 @@ npm install @twin.org/dlt-iota
 
 The tests developed are functional tests and need an instance of the IOTA Gas Station and Redis up and running.
 
-### Quick Setup (Recommended)
-
 The simplest way to set up the testing environment using our unified container:
 
 ```shell
-# Start the unified container with Redis + Gas Station
-docker run -d --name twin-gas-station-test \
-  -p 6379:6379 -p 9527:9527 -p 9184:9184 \
-  twinfoundation/twin-gas-station-test:latest
-
-# Wait a moment for services to start, then verify
-docker exec twin-gas-station-test redis-cli ping  # Should return: PONG
-curl http://localhost:9527/  # Should return: OK
-
-# Services are ready - you can now run tests
-npm run test
-
-# When finished, cleanup
-docker stop twin-gas-station-test && docker rm twin-gas-station-test
-```
-
-That's it! The unified container includes:
-
-- Redis server (port 6379)
-- IOTA Gas Station (port 9527, metrics 9184)
-- Pre-configured with test keypair and settings
-- Health checks and proper startup sequencing
-
-### Alternative Setup Methods
-
-For advanced users who prefer alternative setups:
-
-#### Option A: Standalone Docker Images
-
-If you prefer to run services separately:
-
-```shell
-# Pull the required Docker images
-docker pull redis:7-alpine
-docker pull iotaledger/gas-station:latest
-
-# Start Redis
-docker run -d --name gas-station-redis -p 6379:6379 redis:7-alpine
-
-# Create gas station config file
-cat > gas-station-config.yaml << EOF
-signer-config:
-  local:
-    keypair: AKT1Ghtd+yNbI9fFCQin3FpiGx8xoUdJMe7iAhoFUm4f
-rpc-host-ip: 0.0.0.0
-rpc-port: 9527
-metrics-port: 9184
-storage-config:
-  redis:
-    redis_url: "redis://127.0.0.1:6379"
-fullnode-url: "https://api.testnet.iota.cafe"
-coin-init-config:
-  target-init-balance: 100000000
-  refresh-interval-sec: 86400
-daily-gas-usage-cap: 1500000000000
-access-controller:
-  access-policy: disabled
-EOF
-
-# Start IOTA Gas Station
-docker run -d --name gas-station \
-  -p 9527:9527 -p 9184:9184 \
-  -v $(pwd)/gas-station-config.yaml:/config/config.yaml \
-  --network host \
-  -e GAS_STATION_AUTH=qEyCL6d9BKKFl/tfDGAKeGFkhUlf7FkqiGV7Xw4JUsI= \
-  iotaledger/gas-station:latest \
-  --config-path /config/config.yaml
-```
-
-#### Option B: Docker Compose
-
-Using the IOTA gas station repository:
-
-```shell
-# Clone and setup gas station repository
-git clone https://github.com/iotaledger/gas-station.git
-cd gas-station/docker
-../target/debug/tool generate-sample-config --docker-compose --config-path config.yaml --network testnet
-GAS_STATION_AUTH=qEyCL6d9BKKFl/tfDGAKeGFkhUlf7FkqiGV7Xw4JUsI= docker-compose up -d
+docker run -d --name twin-gas-station-test -p 9527:9527 -p 6379:6379 -p 9184:9184 twinfoundation/twin-gas-station-test:latest
 ```
 
 ## Examples

package/dist/es/index.js

@@ -0,0 +1,19 @@
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+export * from "./iota.js";
+export * from "./iotaSmartContractUtils.js";
+export * from "./models/IAdminCapFields.js";
+export * from "./models/IContractData.js";
+export * from "./models/IGasReservationResult.js";
+export * from "./models/IGasStationConfig.js";
+export * from "./models/IGasStationExecuteResponse.js";
+export * from "./models/IGasStationReserveGasResponse.js";
+export * from "./models/IGasStationReserveGasResult.js";
+export * from "./models/IIotaConfig.js";
+export * from "./models/IIotaDryRun.js";
+export * from "./models/IIotaResponseOptions.js";
+export * from "./models/IMigrationStateFields.js";
+export * from "./models/ISmartContractDeployments.js";
+export * from "./models/ISmartContractObject.js";
+export * from "./models/networkTypes.js";
+//# sourceMappingURL=index.js.map

package/dist/es/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,uCAAuC;AACvC,cAAc,WAAW,CAAC;AAC1B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yCAAyC,CAAC;AACxD,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC","sourcesContent":["// Copyright 2024 IOTA Stiftung.\n// SPDX-License-Identifier: Apache-2.0.\nexport * from \"./iota.js\";\nexport * from \"./iotaSmartContractUtils.js\";\nexport * from \"./models/IAdminCapFields.js\";\nexport * from \"./models/IContractData.js\";\nexport * from \"./models/IGasReservationResult.js\";\nexport * from \"./models/IGasStationConfig.js\";\nexport * from \"./models/IGasStationExecuteResponse.js\";\nexport * from \"./models/IGasStationReserveGasResponse.js\";\nexport * from \"./models/IGasStationReserveGasResult.js\";\nexport * from \"./models/IIotaConfig.js\";\nexport * from \"./models/IIotaDryRun.js\";\nexport * from \"./models/IIotaResponseOptions.js\";\nexport * from \"./models/IMigrationStateFields.js\";\nexport * from \"./models/ISmartContractDeployments.js\";\nexport * from \"./models/ISmartContractObject.js\";\nexport * from \"./models/networkTypes.js\";\n"]}

package/dist/es/iota.js

@@ -0,0 +1,508 @@
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+import { IotaClient } from "@iota/iota-sdk/client";
+import { Ed25519Keypair } from "@iota/iota-sdk/keypairs/ed25519";
+import { Transaction } from "@iota/iota-sdk/transactions";
+import { BaseError, Converter, GeneralError, Guards, Is, StringHelper } from "@twin.org/core";
+import { Bip39, Bip44, KeyType } from "@twin.org/crypto";
+import { FetchHelper, HttpMethod } from "@twin.org/web";
+/**
+ * Class for performing operations on IOTA.
+ */
+export class Iota {
+    /**
+     * Default name for the mnemonic secret.
+     */
+    static DEFAULT_MNEMONIC_SECRET_NAME = "mnemonic";
+    /**
+     * Default name for the seed secret.
+     */
+    static DEFAULT_SEED_SECRET_NAME = "seed";
+    /**
+     * Default coin type.
+     */
+    static DEFAULT_COIN_TYPE = 4218;
+    /**
+     * Default scan range.
+     */
+    static DEFAULT_SCAN_RANGE = 1000;
+    /**
+     * Default inclusion timeout.
+     */
+    static DEFAULT_INCLUSION_TIMEOUT = 60;
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "Iota";
+    /**
+     * Create a new IOTA client.
+     * @param config The configuration.
+     * @returns The client instance.
+     */
+    static createClient(config) {
+        Guards.object(Iota.CLASS_NAME, "config", config);
+        Guards.object(Iota.CLASS_NAME, "config.clientOptions", config.clientOptions);
+        Guards.string(Iota.CLASS_NAME, "config.clientOptions.url", config.clientOptions.url);
+        return new IotaClient(config.clientOptions);
+    }
+    /**
+     * Create configuration using defaults where necessary.
+     * @param config The configuration to populate.
+     */
+    static populateConfig(config) {
+        Guards.object(Iota.CLASS_NAME, "config.clientOptions", config.clientOptions);
+        config.vaultMnemonicId ??= Iota.DEFAULT_MNEMONIC_SECRET_NAME;
+        config.vaultSeedId ??= Iota.DEFAULT_SEED_SECRET_NAME;
+        config.coinType ??= Iota.DEFAULT_COIN_TYPE;
+        config.inclusionTimeoutSeconds ??= Iota.DEFAULT_INCLUSION_TIMEOUT;
+    }
+    /**
+     * Get addresses for the identity.
+     * @param seed The seed to use for generating addresses.
+     * @param coinType The coin type to use.
+     * @param accountIndex The account index to get the addresses for.
+     * @param startAddressIndex The start index for the addresses.
+     * @param count The number of addresses to generate.
+     * @param isInternal Whether the addresses are internal.
+     * @returns The list of addresses.
+     */
+    static getAddresses(seed, coinType, accountIndex, startAddressIndex, count, isInternal) {
+        Guards.integer(Iota.CLASS_NAME, "coinType", coinType);
+        Guards.integer(Iota.CLASS_NAME, "accountIndex", accountIndex);
+        Guards.integer(Iota.CLASS_NAME, "startAddressIndex", startAddressIndex);
+        Guards.integer(Iota.CLASS_NAME, "count", count);
+        const addresses = [];
+        for (let i = startAddressIndex; i < startAddressIndex + count; i++) {
+            // Derive the keypair using the seed
+            const keyPair = Bip44.keyPair(seed, KeyType.Ed25519, coinType ?? Iota.DEFAULT_COIN_TYPE, accountIndex, isInternal ?? false, i);
+            const keypair = Ed25519Keypair.fromSecretKey(keyPair.privateKey);
+            addresses.push(keypair.getPublicKey().toIotaAddress());
+        }
+        return addresses;
+    }
+    /**
+     * Get a key pair for the specified index.
+     * @param seed The seed to use for generating the key pair.
+     * @param coinType The coin type to use.
+     * @param accountIndex The account index to get the key pair for.
+     * @param addressIndex The address index to get the key pair for.
+     * @param isInternal Whether the address is internal.
+     * @returns The key pair containing private key and public key.
+     */
+    static getKeyPair(seed, coinType, accountIndex, addressIndex, isInternal) {
+        Guards.integer(Iota.CLASS_NAME, "coinType", coinType);
+        Guards.integer(Iota.CLASS_NAME, "accountIndex", accountIndex);
+        Guards.integer(Iota.CLASS_NAME, "addressIndex", addressIndex);
+        const keyPair = Bip44.keyPair(seed, KeyType.Ed25519, coinType ?? Iota.DEFAULT_COIN_TYPE, accountIndex, isInternal ?? false, addressIndex);
+        return keyPair;
+    }
+    /**
+     * Prepare and post a transaction.
+     * @param config The configuration.
+     * @param vaultConnector The vault connector.
+     * @param logging The logging component.
+     * @param identity The identity of the user to access the vault keys.
+     * @param client The client instance.
+     * @param source The source address.
+     * @param amount The amount to transfer.
+     * @param recipient The recipient address.
+     * @param options The transaction options.
+     * @returns The transaction result.
+     */
+    static async prepareAndPostValueTransaction(config, vaultConnector, logging, identity, client, source, amount, recipient, options) {
+        try {
+            const txb = new Transaction();
+            const [coin] = txb.splitCoins(txb.gas, [txb.pure.u64(amount)]);
+            txb.transferObjects([coin], txb.pure.address(recipient));
+            // Check if gas station configuration is present
+            if (Is.object(config.gasStation)) {
+                return await Iota.prepareAndPostGasStationTransaction(config, vaultConnector, identity, client, source, txb);
+            }
+            const result = await Iota.prepareAndPostTransaction(config, vaultConnector, logging, identity, client, source, txb, options);
+            return result;
+        }
+        catch (error) {
+            throw new GeneralError(Iota.CLASS_NAME, "valueTransactionFailed", undefined, Iota.extractPayloadError(error));
+        }
+    }
+    /**
+     * Prepare and post a transaction.
+     * @param config The configuration.
+     * @param vaultConnector The vault connector.
+     * @param logging The logging component.
+     * @param identity The identity of the user to access the vault keys.
+     * @param client The client instance.
+     * @param owner The owner of the address.
+     * @param transaction The transaction to execute.
+     * @param options The transaction options.
+     * @returns The transaction response.
+     */
+    static async prepareAndPostTransaction(config, vaultConnector, logging, identity, client, owner, transaction, options) {
+        // Check if gas station configuration is present
+        if (Is.object(config.gasStation)) {
+            return Iota.prepareAndPostGasStationTransaction(config, vaultConnector, identity, client, owner, transaction, options);
+        }
+        // Traditional transaction flow
+        // Dry run the transaction if cost logging is enabled to get the gas and storage costs
+        if (Is.stringValue(options?.dryRunLabel)) {
+            await Iota.dryRunTransaction(client, logging, transaction, owner, options.dryRunLabel);
+        }
+        const seed = await Iota.getSeed(config, vaultConnector, identity);
+        const addressKeyPair = Iota.findAddress(config.maxAddressScanRange ?? Iota.DEFAULT_SCAN_RANGE, config.coinType ?? Iota.DEFAULT_COIN_TYPE, seed, owner);
+        const keypair = Ed25519Keypair.fromSecretKey(addressKeyPair.privateKey);
+        try {
+            const response = await client.signAndExecuteTransaction({
+                transaction,
+                signer: keypair,
+                requestType: "WaitForLocalExecution",
+                options: {
+                    showEffects: options?.showEffects ?? true,
+                    showEvents: options?.showEvents ?? true,
+                    showObjectChanges: options?.showObjectChanges ?? true
+                }
+            });
+            if (options?.waitForConfirmation ?? true) {
+                // Wait for transaction to be indexed and available over API
+                const confirmedTransaction = await Iota.waitForTransactionConfirmation(client, response.digest, config, {
+                    showEffects: options?.showEffects ?? true,
+                    showEvents: options?.showEvents ?? true,
+                    showObjectChanges: options?.showObjectChanges ?? true
+                });
+                return confirmedTransaction;
+            }
+            return response;
+        }
+        catch (error) {
+            throw new GeneralError(Iota.CLASS_NAME, "transactionFailed", undefined, Iota.extractPayloadError(error));
+        }
+    }
+    /**
+     * Get the seed from the vault.
+     * @param config The configuration to use.
+     * @param vaultConnector The vault connector to use.
+     * @param identity The identity of the user to access the vault keys.
+     * @returns The seed.
+     */
+    static async getSeed(config, vaultConnector, identity) {
+        try {
+            const seedBase64 = await vaultConnector.getSecret(Iota.buildSeedKey(identity, config.vaultSeedId));
+            return Converter.base64ToBytes(seedBase64);
+        }
+        catch { }
+        const mnemonic = await vaultConnector.getSecret(Iota.buildMnemonicKey(identity, config.vaultMnemonicId));
+        return Bip39.mnemonicToSeed(mnemonic);
+    }
+    /**
+     * Find the address in the seed.
+     * @param maxScanRange The maximum range to scan.
+     * @param coinType The coin type to use.
+     * @param seed The seed to use.
+     * @param address The address to find.
+     * @returns The address key pair.
+     * @throws Error if the address is not found.
+     */
+    static findAddress(maxScanRange, coinType, seed, address) {
+        for (let i = 0; i < maxScanRange; i++) {
+            const addressKeyPair = Bip44.address(seed, KeyType.Ed25519, coinType, 0, false, i);
+            if (addressKeyPair.address === address) {
+                return addressKeyPair;
+            }
+        }
+        throw new GeneralError(Iota.CLASS_NAME, "addressNotFound", { address });
+    }
+    /**
+     * Extract error from SDK payload.
+     * Errors from the IOTA SDK are usually not JSON strings but objects.
+     * @param error The error to extract.
+     * @returns The extracted error.
+     */
+    static extractPayloadError(error) {
+        if (Is.object(error)) {
+            if (!Is.empty(error.inner)) {
+                error.inner = Iota.extractPayloadError(error.inner);
+            }
+            if (!Is.empty(error.cause)) {
+                error.cause = Iota.extractPayloadError(error.cause);
+            }
+            if (error.code === "InsufficientGas") {
+                return new GeneralError(Iota.CLASS_NAME, "insufficientFunds");
+            }
+            else if (error.message?.startsWith("ErrorObject")) {
+                const msg = /message: "(.*)"/.exec(error.message);
+                if (msg && msg.length > 1) {
+                    error = msg[1];
+                }
+            }
+        }
+        const baseError = BaseError.fromError(error);
+        if (baseError.name === "Base" && !Is.stringValue(baseError.source)) {
+            baseError.name = "IOTA";
+            baseError.source = Iota.CLASS_NAME;
+        }
+        return baseError;
+    }
+    /**
+     * Get the key for storing the mnemonic.
+     * @param identity The identity to use.
+     * @param vaultMnemonicId The mnemonic ID to use.
+     * @returns The mnemonic key.
+     */
+    static buildMnemonicKey(identity, vaultMnemonicId) {
+        return `${identity}/${vaultMnemonicId ?? Iota.DEFAULT_MNEMONIC_SECRET_NAME}`;
+    }
+    /**
+     * Get the key for storing the seed.
+     * @param identity The identity to use.
+     * @param vaultSeedId The seed ID to use.
+     * @returns The seed key.
+     */
+    static buildSeedKey(identity, vaultSeedId) {
+        return `${identity}/${vaultSeedId ?? Iota.DEFAULT_SEED_SECRET_NAME}`;
+    }
+    /**
+     * Check if the package exists on the network.
+     * @param client The client to use.
+     * @param packageId The package ID to check.
+     * @returns True if the package exists, false otherwise.
+     */
+    static async packageExistsOnNetwork(client, packageId) {
+        try {
+            const packageObject = await client.getObject({
+                id: packageId,
+                options: {
+                    showType: true
+                }
+            });
+            if ("error" in packageObject) {
+                if (packageObject?.error?.code === "notExists") {
+                    return false;
+                }
+                throw new GeneralError(Iota.CLASS_NAME, "packageObjectError", {
+                    packageId,
+                    error: packageObject.error
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            throw new GeneralError(Iota.CLASS_NAME, "packageNotFoundOnNetwork", {
+                packageId
+            }, Iota.extractPayloadError(error));
+        }
+    }
+    /**
+     * Dry run a transaction and log the results.
+     * @param client The IOTA client.
+     * @param logging The logging component.
+     * @param txb The transaction to dry run.
+     * @param sender The sender address.
+     * @param operation The operation to log.
+     * @returns void.
+     */
+    static async dryRunTransaction(client, logging, txb, sender, operation) {
+        try {
+            txb.setSender(sender);
+            const builtTx = await txb.build({
+                client,
+                onlyTransactionKind: false
+            });
+            const dryRunResult = await client.dryRunTransactionBlock({
+                transactionBlock: builtTx
+            });
+            if (dryRunResult.effects.status?.status !== "success") {
+                throw new GeneralError(Iota.CLASS_NAME, "dryRunFailed", {
+                    error: dryRunResult.effects?.status?.error
+                });
+            }
+            const result = {
+                status: dryRunResult.effects.status.status,
+                costs: {
+                    computationCost: dryRunResult.effects.gasUsed.computationCost,
+                    computationCostBurned: dryRunResult.effects.gasUsed.computationCostBurned,
+                    storageCost: dryRunResult.effects.gasUsed.storageCost,
+                    storageRebate: dryRunResult.effects.gasUsed.storageRebate,
+                    nonRefundableStorageFee: dryRunResult.effects.gasUsed.nonRefundableStorageFee
+                },
+                events: dryRunResult.events ?? [],
+                balanceChanges: dryRunResult.balanceChanges ?? [],
+                objectChanges: dryRunResult.objectChanges ?? []
+            };
+            await logging?.log({
+                level: "info",
+                source: Iota.CLASS_NAME,
+                ts: Date.now(),
+                message: "transactionCosts",
+                data: {
+                    operation,
+                    cost: JSON.stringify(result)
+                }
+            });
+            return result;
+        }
+        catch (error) {
+            if (BaseError.isErrorName(error, GeneralError.CLASS_NAME)) {
+                throw error;
+            }
+            throw new GeneralError(Iota.CLASS_NAME, "dryRunFailed", undefined, Iota.extractPayloadError(error));
+        }
+    }
+    /**
+     * Wait for a transaction to be indexed and available over the API.
+     * @param client The IOTA client instance.
+     * @param digest The digest of the transaction to wait for.
+     * @param config The IOTA configuration.
+     * @param options Additional options for the transaction query.
+     * @param options.showEffects Whether to show effects.
+     * @param options.showEvents Whether to show events.
+     * @param options.showObjectChanges Whether to show object changes.
+     * @returns The confirmed transaction response.
+     */
+    static async waitForTransactionConfirmation(client, digest, config, options) {
+        const timeoutMs = (config.inclusionTimeoutSeconds ?? Iota.DEFAULT_INCLUSION_TIMEOUT) * 1000;
+        return client.waitForTransaction({
+            digest,
+            timeout: timeoutMs,
+            options: {
+                showEffects: options?.showEffects ?? true,
+                showEvents: options?.showEvents ?? true,
+                showObjectChanges: options?.showObjectChanges ?? true
+            }
+        });
+    }
+    /**
+     * Check if the error is an abort error.
+     * @param error The error to check.
+     * @param code The error code to check for.
+     * @returns True if the error is an abort error, false otherwise.
+     */
+    static isAbortError(error, code) {
+        const err = BaseError.fromError(error);
+        if (Is.stringValue(err.properties?.error) && err.properties.error.startsWith("MoveAbort")) {
+            if (Is.number(code)) {
+                return err.properties.error.includes(code.toString());
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Prepare and post a transaction using gas station sponsoring.
+     * @param config The configuration.
+     * @param vaultConnector The vault connector.
+     * @param identity The identity of the user to access the vault keys.
+     * @param client The client instance.
+     * @param owner The owner of the address.
+     * @param transaction The transaction to execute.
+     * @param options Response options including confirmation behavior.
+     * @returns The transaction response.
+     */
+    static async prepareAndPostGasStationTransaction(config, vaultConnector, identity, client, owner, transaction, options) {
+        Guards.object(Iota.CLASS_NAME, "config.gasStation", config.gasStation);
+        try {
+            // Reserve gas from the gas station
+            const gasBudget = config.gasBudget ?? 50000000;
+            const gasReservation = await Iota.reserveGas(config, gasBudget);
+            // Set transaction parameters for sponsoring
+            transaction.setSender(owner);
+            transaction.setGasOwner(gasReservation.sponsorAddress);
+            transaction.setGasPayment(gasReservation.gasCoins);
+            transaction.setGasBudget(gasBudget);
+            // Build and sign transaction
+            const unsignedTxBytes = await transaction.build({ client });
+            // Sign the transaction with the user's private key
+            const seed = await Iota.getSeed(config, vaultConnector, identity);
+            const addressKeyPair = Iota.findAddress(config.maxAddressScanRange ?? Iota.DEFAULT_SCAN_RANGE, config.coinType ?? Iota.DEFAULT_COIN_TYPE, seed, owner);
+            const keypair = Ed25519Keypair.fromSecretKey(addressKeyPair.privateKey);
+            const signature = await keypair.signTransaction(unsignedTxBytes);
+            return await Iota.executeAndConfirmGasStationTransaction(config, client, gasReservation.reservationId, unsignedTxBytes, signature.signature, options);
+        }
+        catch (error) {
+            throw new GeneralError(Iota.CLASS_NAME, "gasStationTransactionFailed", undefined, Iota.extractPayloadError(error));
+        }
+    }
+    /**
+     * Reserve gas from the gas station.
+     * @param config The configuration containing gas station settings.
+     * @param gasBudget The gas budget to reserve.
+     * @returns The gas reservation result.
+     */
+    static async reserveGas(config, gasBudget) {
+        Guards.object(Iota.CLASS_NAME, "config.gasStation", config.gasStation);
+        const requestData = {
+            // eslint-disable-next-line camelcase
+            gas_budget: gasBudget,
+            // eslint-disable-next-line camelcase
+            reserve_duration_secs: 30
+        };
+        const baseUrl = StringHelper.trimTrailingSlashes(config.gasStation.gasStationUrl);
+        const result = await FetchHelper.fetchJson(Iota.CLASS_NAME, `${baseUrl}/v1/reserve_gas`, HttpMethod.POST, requestData, {
+            headers: {
+                Authorization: `Bearer ${config.gasStation.gasStationAuthToken}`
+            }
+        });
+        const apiResponse = result.result;
+        return {
+            sponsorAddress: apiResponse.sponsor_address,
+            reservationId: apiResponse.reservation_id,
+            gasCoins: apiResponse.gas_coins
+        };
+    }
+    /**
+     * Execute a sponsored transaction through the gas station.
+     * @param config The configuration containing gas station settings.
+     * @param reservationId The reservation ID from gas reservation.
+     * @param transactionBytes The unsigned transaction bytes.
+     * @param userSignature The user's signature.
+     * @returns The transaction response.
+     */
+    static async executeGasStationTransaction(config, reservationId, transactionBytes, userSignature) {
+        Guards.object(Iota.CLASS_NAME, "config.gasStation", config.gasStation);
+        const requestData = {
+            // eslint-disable-next-line camelcase
+            reservation_id: reservationId,
+            // eslint-disable-next-line camelcase
+            tx_bytes: Converter.bytesToBase64(transactionBytes),
+            // eslint-disable-next-line camelcase
+            user_sig: userSignature
+        };
+        const baseUrl = StringHelper.trimTrailingSlashes(config.gasStation.gasStationUrl);
+        const result = await FetchHelper.fetchJson(Iota.CLASS_NAME, `${baseUrl}/v1/execute_tx`, HttpMethod.POST, requestData, {
+            headers: {
+                Authorization: `Bearer ${config.gasStation.gasStationAuthToken}`
+            }
+        });
+        const effectsData = result.effects;
+        // Match IotaTransactionBlockResponse format
+        return {
+            digest: effectsData.transactionDigest,
+            effects: effectsData,
+            events: [],
+            objectChanges: [],
+            confirmedLocalExecution: true
+        };
+    }
+    /**
+     * Execute and confirm a gas station transaction.
+     * @param config The configuration containing gas station settings.
+     * @param client The IOTA client for confirmation.
+     * @param reservationId The reservation ID from gas reservation.
+     * @param transactionBytes The unsigned transaction bytes.
+     * @param userSignature The user's signature.
+     * @param options Response options including confirmation behavior.
+     * @returns The transaction response (confirmed if waitForConfirmation is true).
+     */
+    static async executeAndConfirmGasStationTransaction(config, client, reservationId, transactionBytes, userSignature, options) {
+        Guards.object(Iota.CLASS_NAME, "config.gasStation", config.gasStation);
+        const response = await Iota.executeGasStationTransaction(config, reservationId, transactionBytes, userSignature);
+        if (options?.waitForConfirmation ?? true) {
+            const confirmedTransaction = await Iota.waitForTransactionConfirmation(client, response.digest, config, {
+                showEffects: options?.showEffects ?? true,
+                showEvents: options?.showEvents ?? true,
+                showObjectChanges: options?.showObjectChanges ?? true
+            });
+            return confirmedTransaction;
+        }
+        return response;
+    }
+}
+//# sourceMappingURL=iota.js.map