@sodax/sdk 1.1.0-beta → 1.2.1-beta

package/dist/index.cjs

@@ -5791,6 +5791,97 @@ var IntentsAbi = [
   }
 ];
 
+// src/shared/abis/protocolIntents.abi.ts
+var ProtocolIntentsAbi = [
+  {
+    type: "function",
+    name: "setAutoSwapPreferences",
+    inputs: [
+      {
+        name: "outputToken",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "dstChain",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "dstAddress",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "createIntentAutoSwap",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "fromToken",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "minOutputAmount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getAutoSwapPreferences",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct AutoSwapPreferences",
+        components: [
+          {
+            name: "outputToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "dstChain",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "dstAddress",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
 // src/shared/abis/sonicWalletFactory.abi.ts
 var sonicWalletFactoryAbi = [
   { inputs: [{ internalType: "address", name: "target", type: "address" }], name: "AddressEmptyCode", type: "error" },
@@ -6959,6 +7050,9 @@ var ConfigService = class {
   getOriginalAssetAddress(chainId, hubAsset) {
     return this.hubAssetToOriginalAssetMap.get(chainId)?.get(hubAsset.toLowerCase());
   }
+  getSpokeTokenFromOriginalAssetAddress(chainId, originalAssetAddress) {
+    return this.supportedTokensPerChain.get(chainId)?.find((token) => token.address.toLowerCase() === originalAssetAddress.toLowerCase());
+  }
   isValidHubAsset(hubAsset) {
     return this.supportedHubAssetsSet.has(hubAsset.toLowerCase());
   }
@@ -15116,6 +15210,445 @@ var MoneyMarketService = class _MoneyMarketService {
     return this.configService.getMoneyMarketReserveAssets();
   }
 };
+var PartnerFeeClaimService = class {
+  config;
+  hubProvider;
+  configService;
+  constructor({ config, configService, hubProvider }) {
+    const solverConfig = config ? isConfiguredSolverConfig(config) ? config : types.getSolverConfig(hubProvider.chainConfig.chain.id) : types.getSolverConfig(types.SONIC_MAINNET_CHAIN_ID);
+    this.config = {
+      ...solverConfig,
+      relayerApiEndpoint: void 0,
+      protocolIntentsContract: solverConfig.protocolIntentsContract
+    };
+    this.configService = configService;
+    this.hubProvider = hubProvider;
+  }
+  /**
+   * Util methods for dealing with tokens and hub assets
+   */
+  getAllHubAssets() {
+    return this.configService.getHubAssets();
+  }
+  getOriginalAssetAddress(chainId, hubAsset) {
+    return this.configService.getOriginalAssetAddress(chainId, hubAsset);
+  }
+  getSpokeTokenFromOriginalAssetAddress(chainId, originalAssetAddress) {
+    return this.configService.getSpokeTokenFromOriginalAssetAddress(chainId, originalAssetAddress);
+  }
+  /**
+   * Fetches balances for all hub assets across all chains on Sonic for a given address or provider.
+   *
+   * @param params - Either an EVM address (as a string) or a SonicSpokeProviderType.
+   *   If an address, queries balances for that address.
+   *   If a SonicSpokeProviderType, uses the connected wallet's address.
+   * @returns A promise resolving to a Result containing a Map from wrapped asset address (on Sonic)
+   *   to PartnerFeeClaimAssetBalance, or an Error on failure.
+   */
+  async fetchAssetsBalances(params) {
+    try {
+      let queryAddress;
+      if ("address" in params) {
+        invariant6__default.default(viem.isAddress(params.address), "Address must be a valid EVM address");
+        queryAddress = params.address;
+      } else {
+        invariant6__default.default(
+          isSonicSpokeProviderType(params.spokeProvider),
+          "PartnerFeeClaimService only supports Sonic spoke provider"
+        );
+        queryAddress = await params.spokeProvider.walletProvider.getWalletAddress();
+      }
+      const allAssetEntries = [];
+      for (const [chainId, chainAssets] of Object.entries(this.getAllHubAssets())) {
+        for (const [originalTokenAddress, hubAsset] of Object.entries(chainAssets)) {
+          allAssetEntries.push({
+            assetAddress: hubAsset.asset.toLowerCase(),
+            // Use the wrapped asset address on Sonic
+            originalChain: chainId,
+            originalAddress: originalTokenAddress.toLowerCase(),
+            hubAsset: {
+              symbol: hubAsset.symbol,
+              name: hubAsset.name,
+              decimal: hubAsset.decimal
+            }
+          });
+        }
+      }
+      const uniqueAssets = /* @__PURE__ */ new Map();
+      for (const entry of allAssetEntries) {
+        if (!uniqueAssets.has(entry.assetAddress)) {
+          uniqueAssets.set(entry.assetAddress, entry);
+        }
+      }
+      const uniqueAssetEntries = Array.from(uniqueAssets.values());
+      const assetAddresses = uniqueAssetEntries.map((entry) => entry.assetAddress);
+      const balanceResults = await this.hubProvider.publicClient.multicall({
+        contracts: assetAddresses.map((assetAddress) => ({
+          address: assetAddress,
+          abi: viem.erc20Abi,
+          functionName: "balanceOf",
+          args: [queryAddress]
+        })),
+        allowFailure: false
+      });
+      const balancesMap = /* @__PURE__ */ new Map();
+      let nonZeroCount = 0;
+      uniqueAssetEntries.forEach((entry, index) => {
+        const balanceResult = balanceResults[index];
+        let balance;
+        if (typeof balanceResult === "bigint") {
+          balance = balanceResult;
+        } else {
+          console.warn(
+            `[PartnerFeeClaimService] Unexpected balance result format for ${entry.hubAsset.symbol} (${entry.assetAddress}):`,
+            balanceResult
+          );
+          balance = 0n;
+        }
+        if (balance > 0n) {
+          nonZeroCount++;
+          balancesMap.set(entry.assetAddress, {
+            symbol: entry.hubAsset.symbol,
+            name: entry.hubAsset.name,
+            address: entry.assetAddress,
+            // Wrapped asset address on Sonic
+            originalChain: entry.originalChain,
+            originalAddress: entry.originalAddress,
+            decimal: entry.hubAsset.decimal,
+            balance
+          });
+        }
+      });
+      return {
+        ok: true,
+        value: balancesMap
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  /**
+   * Gets the auto swap preferences for a user.
+   *
+   * @param params - Either an EVM address (as a string) or a SonicSpokeProviderType.
+   *   If an address, queries preferences for that address.
+   *   If a SonicSpokeProviderType, uses the connected wallet's address.
+   * @returns A promise resolving to a Result containing the auto swap preferences, or an Error on failure.
+   *   The auto swap preferences include the output token, destination chain, and destination address.
+   */
+  async getAutoSwapPreferences(params) {
+    try {
+      let queryAddress;
+      if ("address" in params) {
+        invariant6__default.default(viem.isAddress(params.address), "Address must be a valid EVM address");
+        queryAddress = params.address;
+      } else {
+        invariant6__default.default(
+          isSonicSpokeProviderType(params.spokeProvider),
+          "PartnerFeeClaimService only supports Sonic spoke provider"
+        );
+        queryAddress = await params.spokeProvider.walletProvider.getWalletAddress();
+      }
+      invariant6__default.default(this.config.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+      const autoSwapPreferences = await this.hubProvider.publicClient.readContract({
+        address: this.config.protocolIntentsContract,
+        abi: ProtocolIntentsAbi,
+        functionName: "getAutoSwapPreferences",
+        args: [queryAddress]
+      });
+      const dstChain = autoSwapPreferences.dstChain === 0n ? "not configured" : this.configService.getSpokeChainIdFromIntentRelayChainId(
+        autoSwapPreferences.dstChain
+      );
+      return {
+        ok: true,
+        value: {
+          outputToken: autoSwapPreferences.outputToken,
+          dstChain,
+          dstAddress: autoSwapPreferences.dstAddress
+        }
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  /**
+   * Sets the auto swap preferences for a user.
+   *
+   * @template S - Type of the Sonic spoke provider
+   * @template R - Whether to return raw transaction data (default: false)
+   * @param {Object} args - The argument object
+   * @param {SetSwapPreferenceParams} args.params - The swap preference parameters
+   * @param {S} args.spokeProvider - The Sonic spoke provider
+   * @param {R} [args.raw] - If true, the raw transaction data will be returned
+   * @returns {Promise<Result<TxReturnType<S, R>, SetSwapPreferenceError>>}
+   *   - If `raw` is true or the provider is a raw provider, returns the raw transaction object.
+   *   - Otherwise, returns the transaction hash of the submitted transaction.
+   *   - If failed, returns an error object with code 'SET_SWAP_PREFERENCE_FAILED'.
+   */
+  async setSwapPreference({
+    params,
+    spokeProvider,
+    raw
+  }) {
+    try {
+      invariant6__default.default(isSonicSpokeProviderType(spokeProvider), "PartnerFeeClaimService only supports Sonic spoke provider");
+      invariant6__default.default(this.config.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      const rawTx = {
+        from: walletAddress,
+        to: this.config.protocolIntentsContract,
+        value: 0n,
+        data: viem.encodeFunctionData({
+          abi: ProtocolIntentsAbi,
+          functionName: "setAutoSwapPreferences",
+          args: [
+            params.outputToken,
+            BigInt(types.getIntentRelayChainId(params.dstChain)),
+            encodeAddress(params.dstChain, params.dstAddress)
+          ]
+        })
+      };
+      if (raw || isSonicRawSpokeProvider(spokeProvider)) {
+        return {
+          ok: true,
+          value: rawTx
+        };
+      }
+      const txHash = await spokeProvider.walletProvider.sendTransaction(rawTx);
+      return {
+        ok: true,
+        value: txHash
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "SET_SWAP_PREFERENCE_FAILED",
+          data: {
+            payload: params,
+            error
+          }
+        }
+      };
+    }
+  }
+  /**
+   * Checks if a token is already approved to the protocol intents contract for a given address or the connected wallet.
+   *
+   * @param params - Object containing:
+   *   - token: The ERC20 token address to check.
+   *   - spokeProvider: The SonicSpokeProviderType instance.
+   *   - address (optional): The address to check allowance for. If not provided, uses the currently connected wallet.
+   * @returns Promise resolving to a Result. Value is true if token is approved (has max or sufficient allowance), false otherwise. Returns an error if the check fails.
+   */
+  async isTokenApproved({ token, spokeProvider }) {
+    try {
+      invariant6__default.default(isSonicSpokeProviderType(spokeProvider), "PartnerFeeClaimService only supports Sonic spoke provider");
+      invariant6__default.default(this.config.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+      const queryAddress = await spokeProvider.walletProvider.getWalletAddress();
+      if (token.toLowerCase() === spokeProvider.chainConfig.nativeToken.toLowerCase()) {
+        return {
+          ok: true,
+          value: true
+        };
+      }
+      const allowedAmount = await this.hubProvider.publicClient.readContract({
+        address: token,
+        abi: viem.erc20Abi,
+        functionName: "allowance",
+        args: [queryAddress, this.config.protocolIntentsContract]
+      });
+      const maxUint256 = 2n ** 256n - 1n;
+      const isMaxApproved = allowedAmount >= maxUint256 - 1000n;
+      return {
+        ok: true,
+        value: isMaxApproved
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  /**
+   * Approves a token to the protocol intents contract with maximum allowance
+   * @param {Address} token - The token address to approve
+   * @param {SonicSpokeProviderType} spokeProvider - The Sonic spoke provider
+   * @param {boolean} raw - Whether to return raw transaction data
+   * @returns {Promise<Result<TxReturnType<SonicSpokeProviderType, R>, Error>>} Transaction hash or raw transaction
+   */
+  async approveToken({
+    token,
+    spokeProvider,
+    raw
+  }) {
+    try {
+      invariant6__default.default(isSonicSpokeProviderType(spokeProvider), "PartnerFeeClaimService only supports Sonic spoke provider");
+      invariant6__default.default(this.config.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+      const maxUint256 = 2n ** 256n - 1n;
+      const result = await Erc20Service.approve(
+        token,
+        maxUint256,
+        this.config.protocolIntentsContract,
+        spokeProvider,
+        raw
+      );
+      return {
+        ok: true,
+        value: result
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  /**
+   * Creates an intent to auto swap tokens using the protocol intents contract
+   * @param {PartnerFeeClaimSwapParams} params - The swap parameters
+   * @param {SonicSpokeProviderType} spokeProvider - The Sonic spoke provider
+   * @param {boolean} raw - Whether to return raw transaction data
+   * @returns {Promise<TxReturnType<SonicSpokeProviderType, R>>} Transaction hash or raw transaction
+   */
+  async createIntentAutoSwap({
+    params,
+    spokeProvider,
+    raw
+  }) {
+    try {
+      invariant6__default.default(isSonicSpokeProvider(spokeProvider), "PartnerFeeClaimService only supports Sonic spoke provider");
+      invariant6__default.default(this.config.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      const minOutputAmount = 0n;
+      const rawTx = {
+        from: walletAddress,
+        to: this.config.protocolIntentsContract,
+        value: 0n,
+        data: viem.encodeFunctionData({
+          abi: ProtocolIntentsAbi,
+          functionName: "createIntentAutoSwap",
+          args: [walletAddress, params.fromToken, params.amount, minOutputAmount]
+        })
+      };
+      if (raw || isSonicRawSpokeProvider(spokeProvider)) {
+        return {
+          ok: true,
+          value: rawTx
+        };
+      }
+      const txHash = await spokeProvider.walletProvider.sendTransaction(rawTx);
+      return {
+        ok: true,
+        value: txHash
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "CREATE_INTENT_AUTO_SWAP_FAILED",
+          data: {
+            payload: params,
+            error
+          }
+        }
+      };
+    }
+  }
+  /**
+   * Creates an intent auto swap and handles post-execution
+   * @param {PartnerFeeClaimSwapParams} params - The swap parameters
+   * @param {SonicSpokeProviderType} spokeProvider - The Sonic spoke provider
+   * @returns {Promise<Result<SolverExecutionResponse, IntentError<IntentErrorCode>>>} Solver execution response
+   */
+  async swap({
+    params,
+    spokeProvider
+  }) {
+    try {
+      const txHash = await this.createIntentAutoSwap({ params, spokeProvider, raw: false });
+      if (!txHash.ok) {
+        return txHash;
+      }
+      let intentTxHash;
+      try {
+        const receipt = await spokeProvider.publicClient.waitForTransactionReceipt({ hash: txHash.value });
+        intentTxHash = receipt.transactionHash;
+      } catch (error) {
+        return {
+          ok: false,
+          error: {
+            code: "WAIT_INTENT_AUTO_SWAP_FAILED",
+            data: {
+              payload: params,
+              error
+            }
+          }
+        };
+      }
+      const solverExecutionResponse = await SolverApiService.postExecution(
+        {
+          intent_tx_hash: intentTxHash
+        },
+        this.config
+      );
+      if (!solverExecutionResponse.ok) {
+        return solverExecutionResponse;
+      }
+      return {
+        ok: true,
+        value: {
+          srcTxHash: txHash.value,
+          solverExecutionResponse: solverExecutionResponse.value,
+          intentTxHash
+        }
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "UNKNOWN",
+          data: { payload: params, error }
+        }
+      };
+    }
+  }
+};
+function isSetSwapPreferenceError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "SET_SWAP_PREFERENCE_FAILED";
+}
+function isCreateIntentAutoSwapError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "CREATE_INTENT_AUTO_SWAP_FAILED";
+}
+function isWaitIntentAutoSwapError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "WAIT_INTENT_AUTO_SWAP_FAILED";
+}
+function isSolverErrorResponse(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "SOLVER_ERROR";
+}
+function isUnknownIntentAutoSwapError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "UNKNOWN";
+}
+
+// src/partner/PartnerService.ts
+var PartnerService = class {
+  feeClaim;
+  // Partner Fee Claim service for partner fee operations
+  constructor(config) {
+    this.feeClaim = new PartnerFeeClaimService({
+      config: config?.feeClaim,
+      configService: config.configService,
+      hubProvider: config.hubProvider
+    });
+  }
+};
 
 // src/shared/entities/Sodax.ts
 var Sodax = class {
@@ -15132,6 +15665,8 @@ var Sodax = class {
   // Bridge service enabling cross-chain transfers
   staking;
   // Staking service enabling SODA staking operations
+  partners;
+  // Partner service enabling partner fee claim and other partner operations
   config;
   // Config service enabling configuration data fetching from the backend API or fallbacking to default values
   hubProvider;
@@ -15198,6 +15733,11 @@ var Sodax = class {
       relayerApiEndpoint: this.relayerApiEndpoint,
       configService: this.config
     });
+    this.partners = config?.partners ? new PartnerService({
+      feeClaim: config.partners.feeClaim,
+      configService: this.config,
+      hubProvider: this.hubProvider
+    }) : new PartnerService({ configService: this.config, hubProvider: this.hubProvider });
   }
   /**
    * Initializes the Sodax instance with dynamic configuration.
@@ -15801,6 +16341,9 @@ function isInjectiveRawSpokeProvider(value) {
 function isSonicRawSpokeProvider(value) {
   return isRawSpokeProvider(value) && value.chainConfig.chain.type === "EVM" && value.chainConfig.chain.id === types.SONIC_MAINNET_CHAIN_ID;
 }
+function isAddressString(value) {
+  return typeof value === "string";
+}
 async function retry(action, retryCount = DEFAULT_MAX_RETRY, delayMs = DEFAULT_RETRY_DELAY_MS) {
   do {
     try {
@@ -20168,6 +20711,9 @@ exports.MAX_UINT256 = MAX_UINT256;
 exports.MigrationService = MigrationService;
 exports.MoneyMarketDataService = MoneyMarketDataService;
 exports.MoneyMarketService = MoneyMarketService;
+exports.PartnerFeeClaimService = PartnerFeeClaimService;
+exports.PartnerService = PartnerService;
+exports.ProtocolIntentsAbi = ProtocolIntentsAbi;
 exports.RAY = RAY;
 exports.RAY_DECIMALS = RAY_DECIMALS;
 exports.SECONDS_PER_YEAR = SECONDS_PER_YEAR;
@@ -20255,9 +20801,11 @@ exports.getTransactionPackets = getTransactionPackets;
 exports.hexToBigInt = hexToBigInt;
 exports.hexToSolanaAddress = hexToSolanaAddress;
 exports.hyper = hyper;
+exports.isAddressString = isAddressString;
 exports.isBalnMigrateParams = isBalnMigrateParams;
 exports.isConfiguredMoneyMarketConfig = isConfiguredMoneyMarketConfig;
 exports.isConfiguredSolverConfig = isConfiguredSolverConfig;
+exports.isCreateIntentAutoSwapError = isCreateIntentAutoSwapError;
 exports.isEvmHubChainConfig = isEvmHubChainConfig;
 exports.isEvmInitializedConfig = isEvmInitializedConfig;
 exports.isEvmRawSpokeProvider = isEvmRawSpokeProvider;
@@ -20302,10 +20850,12 @@ exports.isPartnerFeePercentage = isPartnerFeePercentage;
 exports.isRawSpokeProvider = isRawSpokeProvider;
 exports.isResponseAddressType = isResponseAddressType;
 exports.isResponseSigningType = isResponseSigningType;
+exports.isSetSwapPreferenceError = isSetSwapPreferenceError;
 exports.isSolanaNativeToken = isSolanaNativeToken;
 exports.isSolanaRawSpokeProvider = isSolanaRawSpokeProvider;
 exports.isSolanaSpokeProvider = isSolanaSpokeProvider;
 exports.isSolanaSpokeProviderType = isSolanaSpokeProviderType;
+exports.isSolverErrorResponse = isSolverErrorResponse;
 exports.isSonicRawSpokeProvider = isSonicRawSpokeProvider;
 exports.isSonicSpokeProvider = isSonicSpokeProvider;
 exports.isSonicSpokeProviderType = isSonicSpokeProviderType;
@@ -20316,6 +20866,8 @@ exports.isSuiRawSpokeProvider = isSuiRawSpokeProvider;
 exports.isSuiSpokeProvider = isSuiSpokeProvider;
 exports.isSuiSpokeProviderType = isSuiSpokeProviderType;
 exports.isUnifiedBnUSDMigrateParams = isUnifiedBnUSDMigrateParams;
+exports.isUnknownIntentAutoSwapError = isUnknownIntentAutoSwapError;
+exports.isWaitIntentAutoSwapError = isWaitIntentAutoSwapError;
 exports.isWaitUntilIntentExecutedFailed = isWaitUntilIntentExecutedFailed;
 exports.nativeToUSD = nativeToUSD;
 exports.newbnUSDSpokeChainIds = newbnUSDSpokeChainIds;