lynx-client 0.0.32 → 0.0.34

package/dist/cjs/lib/addresses/lensAddresses.js

@@ -4,16 +4,16 @@ exports.LensAddresses = void 0;
 exports.LensAddresses = {
     boba: {
         intentsVerifierLens: "0x7DfA2F609573AB8eD8cA231498FF4E8f1e7d31Fa",
-        lexLens: "0x50D5Fb715c2A8d2f70B95960E86B33B0acB84288",
+        lexLens: "0xacd54792eB1844eEB2285C29dE267aA65a7A4fB0",
         tradingFloorLensLens: "0xa2320e397400bd2C56facFD958B602996FdC4a64",
-        triggersAndPortalLens: "0x1DD754d549d2643C5a798364a5cfb2fb24f151e7",
+        triggersAndPortalLens: "0x756934Ca491C177f5C28D1556E1a1a89109C822b",
         rateModelLens: "0xee6354F34892C5388FC69ea1CEc0f3050aF84fB9",
     },
     sonic: {
         intentsVerifierLens: "0x0C1Fcd85856b5564a87ae378336b7CC0c139C5f7",
-        lexLens: "0x63c665d10a23a6E52276a44bE7aC815a53C97904",
+        lexLens: "0x175b535ED0383e96Cc5f436464AF88768242E8d8",
         tradingFloorLensLens: "0xe8cB576813Eca9B3B9BD851Ce768eB0920274fE8",
-        triggersAndPortalLens: "0x1E3865f4Ff5d62dE2fec715d3e676B4b602c0893",
+        triggersAndPortalLens: "0x0D28C4ad0dD674Cbc15Fa54c1f6FacA1D7c81093",
         rateModelLens: "0x771176a09E84365552504437e3A026ea049CBa41",
     },
     fantom: {
@@ -25,9 +25,9 @@ exports.LensAddresses = {
     },
     flare: {
         intentsVerifierLens: "0x8fBb98F9BbBBB455A86371D4B2E8ECc7b1b9C6F6",
-        lexLens: "0x7F6D99833F25baCaC7Dfb14B93f928DC42eDF02c",
+        lexLens: "0x731C1CECb65ab3056BDbBBF3037FBf85A8C888c8",
         tradingFloorLensLens: "0x2779d0a13Bb4CB7798A8D656e8EdEbB560c17431",
-        triggersAndPortalLens: "0x22066b01a00dF4fC4Bc0567dE4D251c694dBA930",
+        triggersAndPortalLens: "0x618d7b961baC037bbbb01c06395Ee16c06A25A2c",
         rateModelLens: "0x7D1893Da64A559C5F23C0f565F62C8480ff6A295",
     },
 };

package/dist/cjs/lib/contractsIntegration/AcceptableImplementationClaimableAdminService/AcceptableImplementationClaimableAdminService.js

@@ -6,40 +6,40 @@ class AcceptableImplementationClaimableAdminFunctionsGroup_AdminManagement {
     constructor(contract) {
         this.contract = contract;
     }
-    async _setPendingAdmin(newPendingAdmin) {
-        return this.contract._setPendingAdmin(newPendingAdmin);
+    async _setPendingAdmin(newPendingAdmin, transactionOptions) {
+        return this.contract._setPendingAdmin(newPendingAdmin, { ...transactionOptions });
     }
-    async _acceptAdmin() {
-        return this.contract._acceptAdmin();
+    async _acceptAdmin(transactionOptions) {
+        return this.contract._acceptAdmin({ ...transactionOptions });
     }
 }
 class AcceptableImplementationClaimableAdminFunctionsGroup_ImplementationManagement {
     constructor(contract) {
         this.contract = contract;
     }
-    async _setPendingImplementation(newPendingImplementation) {
-        return this.contract._setPendingImplementation(newPendingImplementation);
+    async _setPendingImplementation(newPendingImplementation, transactionOptions) {
+        return this.contract._setPendingImplementation(newPendingImplementation, { ...transactionOptions });
     }
-    async _acceptImplementation() {
+    async _acceptImplementation(transactionOptions) {
         // This function modifies state and returns a uint status code (0 on success) via transaction receipt
-        return this.contract._acceptImplementation();
+        return this.contract._acceptImplementation({ ...transactionOptions });
     }
 }
 class AcceptableImplementationClaimableAdminFunctionsGroup_StateVariables {
     constructor(contract) {
         this.contract = contract;
     }
-    async admin() {
-        return this.contract.admin();
+    async admin(callOptions) {
+        return this.contract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return this.contract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return this.contract.pendingAdmin({ ...callOptions });
     }
-    async implementation() {
-        return this.contract.implementation();
+    async implementation(callOptions) {
+        return this.contract.implementation({ ...callOptions });
     }
-    async pendingImplementation() {
-        return this.contract.pendingImplementation();
+    async pendingImplementation(callOptions) {
+        return this.contract.pendingImplementation({ ...callOptions });
     }
 }
 class AcceptableImplementationClaimableAdminService {

package/dist/cjs/lib/contractsIntegration/ChipsIntentsVerifierService/ChipsIntentsVerifierService.js

@@ -7,85 +7,85 @@ class ChipsIntentsVerifierService {
         this.contract = ChipsIntentsVerifierV1__factory_1.ChipsIntentsVerifierV1__factory.connect(address, signerOrProvider);
         this.isSigner = 'sendTransaction' in signerOrProvider;
     }
-    async domainSeparatorForAsset(chip) {
-        return await this.contract.domainSeparatorForAsset(chip);
+    async domainSeparatorForAsset(chip, callOptions) {
+        return await this.contract.domainSeparatorForAsset(chip, { ...callOptions });
     }
-    async domainSeparatorForChain(chainId) {
-        return await this.contract.domainSeparatorForChain(chainId);
+    async domainSeparatorForChain(chainId, callOptions) {
+        return await this.contract.domainSeparatorForChain(chainId, { ...callOptions });
     }
-    async chipOutFeeForChip(chip) {
-        return await this.contract.chipOutFeeForChip(chip);
+    async chipOutFeeForChip(chip, callOptions) {
+        return await this.contract.chipOutFeeForChip(chip, { ...callOptions });
     }
-    async feesReceiver() {
-        return await this.contract.feesReceiver();
+    async feesReceiver(callOptions) {
+        return await this.contract.feesReceiver({ ...callOptions });
     }
-    async intentsPermissions(user) {
-        return await this.contract.intentsPermissions(user);
+    async intentsPermissions(user, callOptions) {
+        return await this.contract.intentsPermissions(user, { ...callOptions });
     }
-    async setIntentsPermissions(oftChip, dynAddressSuffix) {
+    async setIntentsPermissions(oftChip, dynAddressSuffix, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.setIntentsPermissions(oftChip, dynAddressSuffix);
+        const tx = await this.contract.setIntentsPermissions(oftChip, dynAddressSuffix, { ...transactionOptions });
         await tx.wait();
     }
-    async forceChipOut(chip, holder, amount, value) {
+    async forceChipOut(chip, holder, amount, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.forceChipOut(chip, holder, amount, { value: value || 0n });
+        const tx = await this.contract.forceChipOut(chip, holder, amount, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async interactOnBehalf_chipOut(chip, holder, amount, value) {
+    async interactOnBehalf_chipOut(chip, holder, amount, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.interactOnBehalf_chipOut(chip, holder, amount, { value: value || 0n });
+        const tx = await this.contract.interactOnBehalf_chipOut(chip, holder, amount, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_chipOut(payload, v, r, s, value) {
+    async verifyIntent_chipOut(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_chipOut(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_chipOut(payload, v, r, s, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_chipOutAndUnwrap(payload, v, r, s, value) {
+    async verifyIntent_chipOutAndUnwrap(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_chipOutAndUnwrap(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_chipOutAndUnwrap(payload, v, r, s, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async getLZDstChainIdFromChip(chip) {
-        return await this.contract.getLZDstChainIdFromChip(chip);
+    async getLZDstChainIdFromChip(chip, callOptions) {
+        return await this.contract.getLZDstChainIdFromChip(chip, { ...callOptions });
     }
-    async getLZDstChainIdFromEvmChainId(evmChainId) {
-        return await this.contract.getLZDstChainIdFromEvmChainId(evmChainId);
+    async getLZDstChainIdFromEvmChainId(evmChainId, callOptions) {
+        return await this.contract.getLZDstChainIdFromEvmChainId(evmChainId, { ...callOptions });
     }
-    async evmIdToLzEid(evmChainId) {
-        return await this.contract.evmIdToLzEid(evmChainId);
+    async evmIdToLzEid(evmChainId, callOptions) {
+        return await this.contract.evmIdToLzEid(evmChainId, { ...callOptions });
     }
-    async getWrapNativeChipInOutHelper(oftChip) {
-        return await this.contract.getWrapNativeChipInOutHelper(oftChip);
+    async getWrapNativeChipInOutHelper(oftChip, callOptions) {
+        return await this.contract.getWrapNativeChipInOutHelper(oftChip, { ...callOptions });
     }
-    async sourceChainIdForAsset(asset) {
-        return await this.contract.sourceChainIdForAsset(asset);
+    async sourceChainIdForAsset(asset, callOptions) {
+        return await this.contract.sourceChainIdForAsset(asset, { ...callOptions });
     }
-    async processedSignatures(signature) {
-        return await this.contract.processedSignatures(signature);
+    async processedSignatures(signature, callOptions) {
+        return await this.contract.processedSignatures(signature, { ...callOptions });
     }
-    async admin() {
-        return await this.contract.admin();
+    async admin(callOptions) {
+        return await this.contract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return await this.contract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return await this.contract.pendingAdmin({ ...callOptions });
     }
-    async registry() {
-        return await this.contract.registry();
+    async registry(callOptions) {
+        return await this.contract.registry({ ...callOptions });
     }
-    async wrapNativeChipInOutHelpers(oftChip) {
-        return await this.contract.wrapNativeChipInOutHelpers(oftChip);
+    async wrapNativeChipInOutHelpers(oftChip, callOptions) {
+        return await this.contract.wrapNativeChipInOutHelpers(oftChip, { ...callOptions });
     }
     getContract() {
         return this.contract;

package/dist/cjs/lib/contractsIntegration/EngineChipService/EngineChipService.js

@@ -8,41 +8,41 @@ class ERC20Operations {
         this.contract = contract;
         this.isSigner = isSigner;
     }
-    async name() {
-        return await this.contract.name();
+    async name(callOptions) {
+        return await this.contract.name({ ...callOptions });
     }
-    async symbol() {
-        return await this.contract.symbol();
+    async symbol(callOptions) {
+        return await this.contract.symbol({ ...callOptions });
     }
-    async decimals() {
-        return await this.contract.decimals();
+    async decimals(callOptions) {
+        return await this.contract.decimals({ ...callOptions });
     }
-    async totalSupply() {
-        return await this.contract.totalSupply();
+    async totalSupply(callOptions) {
+        return await this.contract.totalSupply({ ...callOptions });
     }
-    async balanceOf(account) {
-        return await this.contract.balanceOf(account);
+    async balanceOf(account, callOptions) {
+        return await this.contract.balanceOf(account, { ...callOptions });
     }
-    async allowance(owner, spender) {
-        return await this.contract.allowance(owner, spender);
+    async allowance(owner, spender, callOptions) {
+        return await this.contract.allowance(owner, spender, { ...callOptions });
     }
-    async approve(spender, value) {
+    async approve(spender, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.approve(spender, value);
+        return await this.contract.approve(spender, value, { ...transactionOptions });
     }
-    async transfer(to, value) {
+    async transfer(to, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.transfer(to, value);
+        return await this.contract.transfer(to, value, { ...transactionOptions });
     }
-    async transferFrom(from, to, value) {
+    async transferFrom(from, to, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.transferFrom(from, to, value);
+        return await this.contract.transferFrom(from, to, value, { ...transactionOptions });
     }
 }
 // ============ Minting Operations Implementation ============
@@ -51,29 +51,29 @@ class MintingOperations {
         this.contract = contract;
         this.isSigner = isSigner;
     }
-    async mintChip(toAddress, amount) {
+    async mintChip(toAddress, amount, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.mintChip(toAddress, amount);
+        return await this.contract.mintChip(toAddress, amount, { ...transactionOptions });
     }
-    async isMintingPaused() {
-        return await this.contract.isMintingPaused();
+    async isMintingPaused(callOptions) {
+        return await this.contract.isMintingPaused({ ...callOptions });
     }
-    async setIsMintingPaused(value) {
+    async setIsMintingPaused(value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.setIsMintingPaused(value);
+        return await this.contract.setIsMintingPaused(value, { ...transactionOptions });
     }
-    async setMintController(mintController) {
+    async setMintController(mintController, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.setMintController(mintController);
+        return await this.contract.setMintController(mintController, { ...transactionOptions });
     }
-    async mintController() {
-        return await this.contract.mintController();
+    async mintController(callOptions) {
+        return await this.contract.mintController({ ...callOptions });
     }
 }
 // ============ Burning Operations Implementation ============
@@ -82,35 +82,35 @@ class BurningOperations {
         this.contract = contract;
         this.isSigner = isSigner;
     }
-    async burnChip(receiver, amount) {
+    async burnChip(receiver, amount, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.burnChip(receiver, amount);
+        return await this.contract.burnChip(receiver, amount, { ...transactionOptions });
     }
-    async burnChipAndCall(amount, payload) {
+    async burnChipAndCall(amount, payload, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.burnChipAndCall(amount, payload);
+        return await this.contract.burnChipAndCall(amount, payload, { ...transactionOptions });
     }
-    async setBurnController(burnController) {
+    async setBurnController(burnController, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.setBurnController(burnController);
+        return await this.contract.setBurnController(burnController, { ...transactionOptions });
     }
-    async setBurnHandler(handler) {
+    async setBurnHandler(handler, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.setBurnHandler(handler);
+        return await this.contract.setBurnHandler(handler, { ...transactionOptions });
     }
-    async burnController() {
-        return await this.contract.burnController();
+    async burnController(callOptions) {
+        return await this.contract.burnController({ ...callOptions });
     }
-    async burnHandler() {
-        return await this.contract.burnHandler();
+    async burnHandler(callOptions) {
+        return await this.contract.burnHandler({ ...callOptions });
     }
 }
 // ============ Admin Functions Implementation ============
@@ -119,29 +119,29 @@ class AdminFunctions {
         this.contract = contract;
         this.isSigner = isSigner;
     }
-    async setPendingAdmin(newPendingAdmin) {
+    async setPendingAdmin(newPendingAdmin, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract._setPendingAdmin(newPendingAdmin);
+        return await this.contract._setPendingAdmin(newPendingAdmin, { ...transactionOptions });
     }
-    async acceptAdmin() {
+    async acceptAdmin(transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract._acceptAdmin();
+        return await this.contract._acceptAdmin({ ...transactionOptions });
     }
-    async sweepTokens(token, amount) {
+    async sweepTokens(token, amount, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.sweepTokens(token, amount);
+        return await this.contract.sweepTokens(token, amount, { ...transactionOptions });
     }
-    async sweepNative(amount) {
+    async sweepNative(amount, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.sweepNative(amount);
+        return await this.contract.sweepNative(amount, { ...transactionOptions });
     }
 }
 // ============ Auto Approval Management Implementation ============
@@ -150,20 +150,20 @@ class AutoApprovalManagement {
         this.contract = contract;
         this.isSigner = isSigner;
     }
-    async setAutoApprovedSpenderForRole(role, spender) {
+    async setAutoApprovedSpenderForRole(role, spender, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("EngineChipService: Write operations require a signer");
         }
-        return await this.contract.setAutoApprovedSpenderForRole(role, spender);
+        return await this.contract.setAutoApprovedSpenderForRole(role, spender, { ...transactionOptions });
     }
-    async getAutoApprovedSpenderAddressByRole(role) {
-        return await this.contract.getAutoApprovedSpenderAddressByRole(role);
+    async getAutoApprovedSpenderAddressByRole(role, callOptions) {
+        return await this.contract.getAutoApprovedSpenderAddressByRole(role, { ...callOptions });
     }
-    async autoApproved(address) {
-        return await this.contract.autoApproved(address);
+    async autoApproved(address, callOptions) {
+        return await this.contract.autoApproved(address, { ...callOptions });
     }
-    async autoApprovedSpendersByRoles(roleHash) {
-        return await this.contract.autoApprovedSpendersByRoles(roleHash);
+    async autoApprovedSpendersByRoles(roleHash, callOptions) {
+        return await this.contract.autoApprovedSpendersByRoles(roleHash, { ...callOptions });
     }
 }
 // ============ View Functions Implementation ============
@@ -171,31 +171,31 @@ class ViewFunctions {
     constructor(contract) {
         this.contract = contract;
     }
-    async exchangeRate() {
-        return await this.contract.exchangeRate();
+    async exchangeRate(callOptions) {
+        return await this.contract.exchangeRate({ ...callOptions });
     }
-    async underlyingToken() {
-        return await this.contract.underlyingToken();
+    async underlyingToken(callOptions) {
+        return await this.contract.underlyingToken({ ...callOptions });
     }
-    async chipMode() {
-        return await this.contract.chipMode();
+    async chipMode(callOptions) {
+        return await this.contract.chipMode({ ...callOptions });
     }
-    async registry() {
-        return await this.contract.registry();
+    async registry(callOptions) {
+        return await this.contract.registry({ ...callOptions });
     }
-    async SELF_UNIT_SCALE() {
-        return await this.contract.SELF_UNIT_SCALE();
+    async SELF_UNIT_SCALE(callOptions) {
+        return await this.contract.SELF_UNIT_SCALE({ ...callOptions });
     }
-    async getChipConfiguration() {
+    async getChipConfiguration(callOptions) {
         const [name, symbol, decimals, totalSupply, underlyingToken, exchangeRate, chipMode, selfUnitScale,] = await Promise.all([
-            this.contract.name(),
-            this.contract.symbol(),
-            this.contract.decimals(),
-            this.contract.totalSupply(),
-            this.contract.underlyingToken(),
-            this.contract.exchangeRate(),
-            this.contract.chipMode(),
-            this.contract.SELF_UNIT_SCALE(),
+            this.contract.name({ ...callOptions }),
+            this.contract.symbol({ ...callOptions }),
+            this.contract.decimals({ ...callOptions }),
+            this.contract.totalSupply({ ...callOptions }),
+            this.contract.underlyingToken({ ...callOptions }),
+            this.contract.exchangeRate({ ...callOptions }),
+            this.contract.chipMode({ ...callOptions }),
+            this.contract.SELF_UNIT_SCALE({ ...callOptions }),
         ]);
         return {
             name,
@@ -208,11 +208,11 @@ class ViewFunctions {
             selfUnitScale,
         };
     }
-    async getChipControllers() {
+    async getChipControllers(callOptions) {
         const [mintController, burnController, burnHandler] = await Promise.all([
-            this.contract.mintController(),
-            this.contract.burnController(),
-            this.contract.burnHandler(),
+            this.contract.mintController({ ...callOptions }),
+            this.contract.burnController({ ...callOptions }),
+            this.contract.burnHandler({ ...callOptions }),
         ]);
         return {
             mintController,
@@ -220,8 +220,8 @@ class ViewFunctions {
             burnHandler,
         };
     }
-    async getChipMintingState() {
-        const isMintingPaused = await this.contract.isMintingPaused();
+    async getChipMintingState(callOptions) {
+        const isMintingPaused = await this.contract.isMintingPaused({ ...callOptions });
         return {
             isMintingPaused,
         };
@@ -232,11 +232,11 @@ class PendableAdmin {
     constructor(contract) {
         this.contract = contract;
     }
-    async admin() {
-        return await this.contract.admin();
+    async admin(callOptions) {
+        return await this.contract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return await this.contract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return await this.contract.pendingAdmin({ ...callOptions });
     }
 }
 // ============ Lynx Versioned Contract Implementation ============
@@ -244,18 +244,18 @@ class LynxVersionedContract {
     constructor(contract) {
         this.contract = contract;
     }
-    async getContractName() {
+    async getContractName(callOptions) {
         // EngineChip may not have versioning methods, return the contract name
         return "EngineChip";
     }
-    async getContractVersion() {
+    async getContractVersion(callOptions) {
         // EngineChip may not have versioning methods, return a default version
         return "1.0.0";
     }
-    async CONTRACT_NAME() {
+    async CONTRACT_NAME(callOptions) {
         return "EngineChip";
     }
-    async CONTRACT_VERSION() {
+    async CONTRACT_VERSION(callOptions) {
         return "1.0.0";
     }
 }