@myx-trade/sdk 0.1.57 → 0.1.59

package/dist/index.mjs

@@ -1375,6 +1375,7 @@ function isSupportedChainFn(chainId) {
 
 // src/config/address/ARB_TEST_SEPOLIA.ts
 var ARB_TEST_SEPOLIA = {
+  USDC: "0x7E248Ec1721639413A280d9E82e2862Cae2E6E28",
   POOL_MANAGER: "0xA4A1dfbe40cB725A79D34bd529f0C1b54AB46954",
   Account: "0x6136899e8c77C452bc46AcD786aA2C09fD31f947",
   POSITION_MANAGER: "0x002F28be205E9A1e279d2eeF1f5e472CeA1d910C",
@@ -1385,14 +1386,13 @@ var ARB_TEST_SEPOLIA = {
   LIQUIDITY_ROUTER: "0xd185C3f675d991735FCF6885Ff6BADE02A21313d",
   BASE_POOL: "0x2c6AdaE4A01836487842b7369c1db3F441871E83",
   QUOTE_POOL: "0xe1Ff495206635570A8Eaf9517125Ce66a2d09d32",
-  BROKER: "0xB3DaeFF433c005e214D6cd73C35cD4bBCe7f94fD",
-  // MYXBroker
   ORACLE: "0x574001F6cB520b15d5a6db9F7B7a0ebf1A8E25c0",
   // MYXOracle
   EIP7702Delegation: "0x4e1B9aDf5Aa4a893f578c8502E6E28841b2403f3",
   MARKET_MANAGER: "0x12AD75316A92a66b92c79080c555594314e7aFB3",
   DATA_PROVIDER: "0x726A4978eDcb974B9889BC6f5Ee2Ec06D703038E",
-  ORACLE_RESERVE: "0xC46b81c38091933f4811EC16E93553f9801EB863"
+  ORACLE_RESERVE: "0xC46b81c38091933f4811EC16E93553f9801EB863",
+  FORWARDER: "0xD41c2078fe35c8ca5f95b28Ed3017C4f7b4Bd49d"
 };
 
 // src/config/address/LINEA_SEPOLIA.ts
@@ -1403,18 +1403,18 @@ var LINEA_SEPOLIA = {
   ORDER_MANAGER: "0x50602673C3506AFF2e7Df82dB6E93B6B134331Ae",
   PYTH: "0xA2aa501b19aff244D90cc15a4Cf739D2725B5729",
   // ！！！ 非Pyth Adapter
-  ERC20: "0x635eC74A4A39A27177310F0d605515D9df4bDe43",
+  ERC20: "0xD984fd34f91F92DA0586e1bE82E262fF27DC431b",
   LIQUIDITY_ROUTER: "0x7fa9B7C0D95E19f180A2bf359d980c0bD3aC2503",
   BASE_POOL: "0x6d3A2AB082388C35319007a2D635Cf7A8B8aF0E1",
   QUOTE_POOL: "0x5A6fdFD381B76eD163b60300E619F7EB6049e7bD",
-  BROKER: "0x0C6358400a8d86d8377640B1B783b8326b7D0fdc",
-  // MYXBroker
   ORACLE: "0xfbA4a141bb3BbD0EB34b24152caa3d2940629545",
   // MYXOracle
   EIP7702Delegation: "0xa55149B66A7fC4a4eF05c8da981E46Fe27695E6c",
   MARKET_MANAGER: "0x96Dd73d94c7359e92a45Ff75bC90909E66332990",
   DATA_PROVIDER: "0xF10B5736EA756488139135BF14aE5A542de435a9",
-  ORACLE_RESERVE: "0xb9433C0e23f38E8Ad48B9A6e562F0a543e06a9F4"
+  ORACLE_RESERVE: "0xb9433C0e23f38E8Ad48B9A6e562F0a543e06a9F4",
+  USDC: "0xD984fd34f91F92DA0586e1bE82E262fF27DC431b",
+  FORWARDER: "0xeDb8E5B27baB3125b5039fB4A9e3dCc962155d2E"
 };
 
 // src/config/address.ts
@@ -1473,6 +1473,7 @@ var linea_default = "./linea-ZTA3FOH3.png";
 
 // src/config/fee.ts
 var GAS_FEE_RESERVED_RATIO = 10;
+var SEAMLESS_ACCOUNT_GAS_LIMIT = 5e6;
 
 // src/config/chains/LINEA_SEPOLIA.ts
 var LINEA_SEPOLIA_default = {
@@ -1751,7 +1752,7 @@ var RotationProvider = class extends BaseProvider {
 // package.json
 var package_default = {
   name: "@myx-trade/sdk",
-  version: "0.1.57",
+  version: "0.1.59",
   private: false,
   publishConfig: {
     access: "public"
@@ -1810,6 +1811,7 @@ var package_default = {
     typescript: "^5.3.0"
   },
   dependencies: {
+    "@ethersproject/bytes": "^5.8.0",
     "@ethersproject/providers": "^5.8.0",
     "@types/ws": "^8.18.1",
     "crypto-js": "^4.2.0",
@@ -1820,7 +1822,8 @@ var package_default = {
     "reconnecting-websocket": "^4.4.0",
     viem: "^2.36.0",
     wretch: "^2.11.0",
-    ws: "^8.18.3"
+    ws: "^8.18.3",
+    dayjs: "^1.11.13"
   }
 };
 
@@ -2044,8 +2047,36 @@ var getTradeFlow = async ({
   );
 };
 
+// src/api/seamless/index.ts
+var forwarderTxApi = async (params, chainId) => {
+  console.log("forwarderTxApi params-->", params);
+  return http.post(
+    `${forwardUrl}/forwarder/tx-v2`,
+    params,
+    {
+      headers: {
+        "myx-chain-id": chainId.toString()
+      }
+    }
+  );
+};
+var ForwarderGetStatus = /* @__PURE__ */ ((ForwarderGetStatus2) => {
+  ForwarderGetStatus2[ForwarderGetStatus2["EXECUTING"] = 1] = "EXECUTING";
+  ForwarderGetStatus2[ForwarderGetStatus2["BROADCAST_FAILED"] = 2] = "BROADCAST_FAILED";
+  ForwarderGetStatus2[ForwarderGetStatus2["TIMEOUT_CANCEL"] = 3] = "TIMEOUT_CANCEL";
+  ForwarderGetStatus2[ForwarderGetStatus2["EXECUTED"] = 9] = "EXECUTED";
+  return ForwarderGetStatus2;
+})(ForwarderGetStatus || {});
+var fetchForwarderGetApi = async (params) => {
+  const rs = await http.get(
+    `${forwardUrl}/forwarder/get${addQueryParams(params)}`
+  );
+  return rs;
+};
+
 // src/api/index.ts
 var baseUrl = "https://api-test.myx.cash";
+var forwardUrl = "https://api-test.myx.cash/v2/agent";
 var getOraclePrice = async (chainId, poolIds = []) => {
   if (!!poolIds.length) {
     return http.get(`${baseUrl}/openapi/gateway/quote/price/oracles`, {
@@ -9867,91 +9898,1291 @@ var DataProvider_default = [
       },
       {
         type: "uint256",
-        name: "price"
+        name: "price"
+      }
+    ],
+    outputs: [
+      {
+        type: "int256",
+        name: "netCollateral"
+      },
+      {
+        type: "uint256",
+        name: "collateralAmount"
+      },
+      {
+        type: "uint256",
+        name: "tradingFee"
+      },
+      {
+        type: "int256",
+        name: "fundingFee"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getUserPositionInfos",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "user"
+      },
+      {
+        type: "bytes32[]",
+        name: "poolIds"
+      }
+    ],
+    outputs: [
+      {
+        type: "tuple[]",
+        name: "positions",
+        components: [
+          {
+            type: "bytes32",
+            name: "positionId"
+          },
+          {
+            type: "bytes32",
+            name: "poolId"
+          },
+          {
+            type: "uint256",
+            name: "size"
+          },
+          {
+            type: "uint256",
+            name: "entryPrice"
+          },
+          {
+            type: "int256",
+            name: "fundingRateIndex"
+          },
+          {
+            type: "uint256",
+            name: "earlyClosePrice"
+          },
+          {
+            type: "uint8",
+            name: "direction"
+          },
+          {
+            type: "uint8",
+            name: "riskTier"
+          },
+          {
+            type: "uint64",
+            name: "lastUpdateTime"
+          },
+          {
+            type: "uint256",
+            name: "collateralAmount"
+          }
+        ]
+      }
+    ]
+  }
+];
+
+// src/abi/Forwarder.json
+var Forwarder_default = [
+  {
+    type: "constructor",
+    payable: false,
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AddressEmptyCode",
+    inputs: [
+      {
+        type: "address",
+        name: "target"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC1967InvalidImplementation",
+    inputs: [
+      {
+        type: "address",
+        name: "implementation"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC1967NonPayable",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "ERC2771ForwarderExpiredRequest",
+    inputs: [
+      {
+        type: "uint48",
+        name: "deadline"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC2771ForwarderInvalidSigner",
+    inputs: [
+      {
+        type: "address",
+        name: "signer"
+      },
+      {
+        type: "address",
+        name: "from"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC2771ForwarderMismatchedValue",
+    inputs: [
+      {
+        type: "uint256",
+        name: "requestedValue"
+      },
+      {
+        type: "uint256",
+        name: "msgValue"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC2771UntrustfulTarget",
+    inputs: [
+      {
+        type: "address",
+        name: "target"
+      },
+      {
+        type: "address",
+        name: "forwarder"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ExceedsMaximumRelayFee",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "FailedCall",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InconsistentParamsLength",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InsufficientBalance",
+    inputs: [
+      {
+        type: "uint256",
+        name: "balance"
+      },
+      {
+        type: "uint256",
+        name: "needed"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InsufficientFeeAllowance",
+    inputs: [
+      {
+        type: "address",
+        name: "user"
+      },
+      {
+        type: "uint256",
+        name: "allowance"
+      },
+      {
+        type: "uint256",
+        name: "required"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InsufficientFeeBalance",
+    inputs: [
+      {
+        type: "address",
+        name: "user"
+      },
+      {
+        type: "uint256",
+        name: "balance"
+      },
+      {
+        type: "uint256",
+        name: "required"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InvalidAccountNonce",
+    inputs: [
+      {
+        type: "address",
+        name: "account"
+      },
+      {
+        type: "uint256",
+        name: "currentNonce"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InvalidInitialization",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "MismatchedSender",
+    inputs: [
+      {
+        type: "address",
+        name: "sender"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "NotAddressManager",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotAllowedTarget",
+    inputs: [
+      {
+        type: "address",
+        name: "target"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "NotDependencyManager",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotInitializing",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotProxyAdmin",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "OnlyRelayer",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "PermissionDenied",
+    inputs: [
+      {
+        type: "address",
+        name: "caller"
+      },
+      {
+        type: "address",
+        name: "target"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ReentrancyGuardReentrantCall",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "RelayerRegistered",
+    inputs: [
+      {
+        type: "address",
+        name: "relayer"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "SafeERC20FailedOperation",
+    inputs: [
+      {
+        type: "address",
+        name: "token"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "UUPSUnauthorizedCallContext",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "UUPSUnsupportedProxiableUUID",
+    inputs: [
+      {
+        type: "bytes32",
+        name: "slot"
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "AddAllowedTarget",
+    inputs: [
+      {
+        type: "address",
+        name: "target",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "EIP712DomainChanged",
+    inputs: []
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "ERC20PermitFailed",
+    inputs: [
+      {
+        type: "address",
+        name: "token",
+        indexed: false
+      },
+      {
+        type: "string",
+        name: "reason",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "ERC20PermitLowLevelFailed",
+    inputs: [
+      {
+        type: "bytes",
+        name: "data",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "ExecutedForwardRequest",
+    inputs: [
+      {
+        type: "address",
+        name: "signer",
+        indexed: true
+      },
+      {
+        type: "uint256",
+        name: "nonce",
+        indexed: false
+      },
+      {
+        type: "bool",
+        name: "success",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "Initialized",
+    inputs: [
+      {
+        type: "uint64",
+        name: "version",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "RemoveAllowedTarget",
+    inputs: [
+      {
+        type: "address",
+        name: "target",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "SetUserRelayer",
+    inputs: [
+      {
+        type: "address",
+        name: "account",
+        indexed: false
+      },
+      {
+        type: "address",
+        name: "relayer",
+        indexed: false
+      },
+      {
+        type: "bool",
+        name: "enable",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "UpdateMaxRelayFee",
+    inputs: [
+      {
+        type: "address",
+        name: "sender",
+        indexed: false
+      },
+      {
+        type: "uint256",
+        name: "oldMaxRelayFee",
+        indexed: false
+      },
+      {
+        type: "uint256",
+        name: "newMaxRelayFee",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "UpdateRelayInfo",
+    inputs: [
+      {
+        type: "address",
+        name: "sender",
+        indexed: false
+      },
+      {
+        type: "uint256",
+        name: "oldRelayFee",
+        indexed: false
+      },
+      {
+        type: "uint256",
+        name: "newRelayFee",
+        indexed: false
+      },
+      {
+        type: "uint256",
+        name: "oldRelayGas",
+        indexed: false
+      },
+      {
+        type: "uint256",
+        name: "newRelayGas",
+        indexed: false
+      }
+    ]
+  },
+  {
+    type: "event",
+    anonymous: false,
+    name: "Upgraded",
+    inputs: [
+      {
+        type: "address",
+        name: "implementation",
+        indexed: true
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "UPGRADE_INTERFACE_VERSION",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "string"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "__ERC2771ContextUpgradeable_init",
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "trustedForwarder_"
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "addAllowedTarget",
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "target"
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "batchExecuteForwarder",
+    constant: false,
+    stateMutability: "payable",
+    payable: true,
+    inputs: [
+      {
+        type: "tuple[]",
+        name: "bundleParams",
+        components: [
+          {
+            type: "address",
+            name: "from"
+          },
+          {
+            type: "address",
+            name: "to"
+          },
+          {
+            type: "uint256",
+            name: "value"
+          },
+          {
+            type: "uint256",
+            name: "gas"
+          },
+          {
+            type: "uint48",
+            name: "deadline"
+          },
+          {
+            type: "bytes",
+            name: "data"
+          },
+          {
+            type: "bytes",
+            name: "signature"
+          }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "eip712Domain",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "bytes1",
+        name: "fields"
+      },
+      {
+        type: "string",
+        name: "name"
+      },
+      {
+        type: "string",
+        name: "version"
+      },
+      {
+        type: "uint256",
+        name: "chainId"
+      },
+      {
+        type: "address",
+        name: "verifyingContract"
+      },
+      {
+        type: "bytes32",
+        name: "salt"
+      },
+      {
+        type: "uint256[]",
+        name: "extensions"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "execute",
+    constant: false,
+    stateMutability: "payable",
+    payable: true,
+    inputs: [
+      {
+        type: "tuple",
+        name: "request",
+        components: [
+          {
+            type: "address",
+            name: "from"
+          },
+          {
+            type: "address",
+            name: "to"
+          },
+          {
+            type: "uint256",
+            name: "value"
+          },
+          {
+            type: "uint256",
+            name: "gas"
+          },
+          {
+            type: "uint48",
+            name: "deadline"
+          },
+          {
+            type: "bytes",
+            name: "data"
+          },
+          {
+            type: "bytes",
+            name: "signature"
+          }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "executeBatch",
+    constant: false,
+    stateMutability: "payable",
+    payable: true,
+    inputs: [
+      {
+        type: "tuple[]",
+        name: "requests",
+        components: [
+          {
+            type: "address",
+            name: "from"
+          },
+          {
+            type: "address",
+            name: "to"
+          },
+          {
+            type: "uint256",
+            name: "value"
+          },
+          {
+            type: "uint256",
+            name: "gas"
+          },
+          {
+            type: "uint48",
+            name: "deadline"
+          },
+          {
+            type: "bytes",
+            name: "data"
+          },
+          {
+            type: "bytes",
+            name: "signature"
+          }
+        ]
+      },
+      {
+        type: "address",
+        name: "refundReceiver"
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "executeForwarder",
+    constant: false,
+    stateMutability: "payable",
+    payable: true,
+    inputs: [
+      {
+        type: "tuple",
+        name: "params",
+        components: [
+          {
+            type: "address",
+            name: "from"
+          },
+          {
+            type: "address",
+            name: "to"
+          },
+          {
+            type: "uint256",
+            name: "value"
+          },
+          {
+            type: "uint256",
+            name: "gas"
+          },
+          {
+            type: "uint48",
+            name: "deadline"
+          },
+          {
+            type: "bytes",
+            name: "data"
+          },
+          {
+            type: "bytes",
+            name: "signature"
+          }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "feeToken",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "address"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getAddressManager",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "address"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getAllowedTargets",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "address[]"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getDependencyAddress",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
+      {
+        type: "bytes32",
+        name: "identifier"
+      }
+    ],
+    outputs: [
+      {
+        type: "address"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getFeeToken",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "address"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getImplementation",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "address"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getMaxRelayFee",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getRelayFee",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getRelayGas",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getUserRelayers",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "account"
+      }
+    ],
+    outputs: [
+      {
+        type: "address[]"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "initialize",
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "addressManager"
+      },
+      {
+        type: "address",
+        name: "_feeToken"
+      },
+      {
+        type: "uint256",
+        name: "_relayFee"
+      },
+      {
+        type: "uint256",
+        name: "_relayGas"
+      },
+      {
+        type: "uint256",
+        name: "_maxRelayFee"
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "isTrustedForwarder",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "forwarder"
+      }
+    ],
+    outputs: [
+      {
+        type: "bool"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "isUserRelayerEnabled",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "account"
+      },
+      {
+        type: "address",
+        name: "relayer"
+      }
+    ],
+    outputs: [
+      {
+        type: "bool"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "maxRelayFee",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "nonces",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "owner"
+      }
+    ],
+    outputs: [
+      {
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "originAccount",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "relayer"
+      }
+    ],
+    outputs: [
+      {
+        type: "address",
+        name: "account"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "permitAndApproveForwarder",
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "relayer"
+      },
+      {
+        type: "bool",
+        name: "enable"
+      },
+      {
+        type: "tuple[]",
+        name: "permitParams",
+        components: [
+          {
+            type: "address",
+            name: "token"
+          },
+          {
+            type: "address",
+            name: "owner"
+          },
+          {
+            type: "address",
+            name: "spender"
+          },
+          {
+            type: "uint256",
+            name: "value"
+          },
+          {
+            type: "uint256",
+            name: "deadline"
+          },
+          {
+            type: "uint8",
+            name: "v"
+          },
+          {
+            type: "bytes32",
+            name: "r"
+          },
+          {
+            type: "bytes32",
+            name: "s"
+          }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "proxiableUUID",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "bytes32"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "relayFee",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "relayGas",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "removeAllowedTarget",
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: "address",
+        name: "target"
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "trustedForwarder",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [],
+    outputs: [
+      {
+        type: "address"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "updateMaxRelayFee",
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: "uint256",
+        name: "_maxRelayFee"
       }
     ],
-    outputs: [
-      {
-        type: "int256",
-        name: "netCollateral"
-      },
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "updateRelayInfo",
+    constant: false,
+    payable: false,
+    inputs: [
       {
         type: "uint256",
-        name: "collateralAmount"
+        name: "_relayFee"
       },
       {
         type: "uint256",
-        name: "tradingFee"
+        name: "_relayGas"
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "upgradeTo",
+    constant: false,
+    stateMutability: "payable",
+    payable: true,
+    inputs: [
+      {
+        type: "address",
+        name: "newImplementation"
       },
       {
-        type: "int256",
-        name: "fundingFee"
+        type: "bytes",
+        name: "data"
       }
-    ]
+    ],
+    outputs: []
   },
   {
     type: "function",
-    name: "getUserPositionInfos",
-    constant: true,
-    stateMutability: "view",
-    payable: false,
+    name: "upgradeToAndCall",
+    constant: false,
+    stateMutability: "payable",
+    payable: true,
     inputs: [
       {
         type: "address",
-        name: "user"
+        name: "newImplementation"
       },
       {
-        type: "bytes32[]",
-        name: "poolIds"
+        type: "bytes",
+        name: "data"
       }
     ],
-    outputs: [
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "verify",
+    constant: true,
+    stateMutability: "view",
+    payable: false,
+    inputs: [
       {
-        type: "tuple[]",
-        name: "positions",
+        type: "tuple",
+        name: "request",
         components: [
           {
-            type: "bytes32",
-            name: "positionId"
-          },
-          {
-            type: "bytes32",
-            name: "poolId"
+            type: "address",
+            name: "from"
           },
           {
-            type: "uint256",
-            name: "size"
+            type: "address",
+            name: "to"
           },
           {
             type: "uint256",
-            name: "entryPrice"
-          },
-          {
-            type: "int256",
-            name: "fundingRateIndex"
+            name: "value"
           },
           {
             type: "uint256",
-            name: "earlyClosePrice"
-          },
-          {
-            type: "uint8",
-            name: "direction"
+            name: "gas"
           },
           {
-            type: "uint8",
-            name: "riskTier"
+            type: "uint48",
+            name: "deadline"
           },
           {
-            type: "uint64",
-            name: "lastUpdateTime"
+            type: "bytes",
+            name: "data"
           },
           {
-            type: "uint256",
-            name: "collateralAmount"
+            type: "bytes",
+            name: "signature"
           }
         ]
       }
+    ],
+    outputs: [
+      {
+        type: "bool"
+      }
     ]
   }
 ];
@@ -10024,6 +11255,12 @@ var getDataProviderContract = async (chainId, type = 0 /* JSON */) => {
   const provider = type === 0 /* JSON */ ? getJSONProvider(chainId) : await getSignerProvider(chainId);
   return getContract(address, DataProvider_default, provider);
 };
+var getForwarderContract = async (chainId, type = 0 /* JSON */) => {
+  const addresses = address_default[chainId];
+  const address = addresses.FORWARDER;
+  const provider = type === 0 /* JSON */ ? getJSONProvider(chainId) : await getSignerProvider(chainId);
+  return getContract(address, Forwarder_default, provider);
+};
 
 // src/config/error.ts
 import { ErrorType, ErrorDecoder } from "ethers-decode-error";
@@ -13118,30 +14355,6 @@ var Order = class {
           useAccountBalance: false
         };
       });
-      const gasLimittest = await brokerContract.placeOrdersWithPosition.estimateGas(["0x8d11a77fc9225f16955c717b40ea826befc1703a4b6810b30093af4860085b8f"], [{
-        user: "0x0F5A0a5F807A76244897A93aa8FE9121E7df15cf",
-        poolId: "0x0f3a23ce1f81d792bb74b7e748d7ee0c0c459db3c5fd06e1c792935f9a90fce0",
-        orderType: 0,
-        triggerType: 0,
-        operation: 1,
-        direction: 0,
-        collateralAmount: 1000000n,
-        size: "1000000000000000000",
-        price: "87711469284207055000000000000000000",
-        timeInForce: TIME_IN_FORCE,
-        postOnly: false,
-        slippagePct: 1e3,
-        executionFeeToken: "0x7e248ec1721639413a280d9e82e2862cae2e6e28",
-        leverage: 10,
-        tpSize: 0,
-        tpPrice: 0,
-        slSize: 0,
-        slPrice: 0,
-        useAccountBalance: false
-      }]);
-      console.log("gasLimittest--->", gasLimittest);
-      this.logger.info("closeAllPositions positionIds--->", positionIds);
-      this.logger.info("closeAllPositions dataMap--->", dataMap);
       const gasLimit = await brokerContract.placeOrdersWithPosition.estimateGas(positionIds, dataMap);
       const transaction = await brokerContract.placeOrdersWithPosition(positionIds, dataMap, {
         gasLimit: gasLimit * 120n / 100n
@@ -19051,6 +20264,470 @@ var Account = class {
   }
 };
 
+// src/manager/seamless/index.ts
+import CryptoJS from "crypto-js";
+import { toUtf8Bytes, keccak256 as keccak2562, hexlify, ethers as ethers9, isHexString, getBytes, ZeroAddress as ZeroAddress2 } from "ethers";
+import dayjs from "dayjs";
+
+// src/utils/index.ts
+function getChainDomainConfig(chainId, address) {
+  return CHAIN_DOMAIN?.[chainId]?.[address];
+}
+var CHAIN_DOMAIN = {
+  [421614 /* ARB_TESTNET */]: {
+    [getContractAddressByChainId(421614 /* ARB_TESTNET */).USDC]: {
+      name: "USDC",
+      version: "2",
+      chainId: 421614 /* ARB_TESTNET */.toString(),
+      verifyingContract: getContractAddressByChainId(421614 /* ARB_TESTNET */).USDC
+    }
+  }
+};
+var getEIP712Domain = async (contract) => {
+  try {
+    const eip712Domain = await contract.eip712Domain();
+    return {
+      name: eip712Domain.name,
+      version: eip712Domain.version,
+      chainId: BigInt(eip712Domain.chainId),
+      // 确保 chainId 是ForwarderGetStatus bigint 类型
+      verifyingContract: eip712Domain.verifyingContract
+    };
+  } catch (error) {
+    throw new Error(`Error fetching EIP712 domain: ${error}`);
+  }
+};
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function waitRandom(min, max) {
+  return wait(min + Math.round(Math.random() * Math.max(0, max - min)));
+}
+var CanceledError = class extends Error {
+  constructor() {
+    super();
+    this.name = "CanceledError";
+    this.message = "Retryable was canceled";
+    this.name = "CanceledError";
+  }
+};
+var RetryableError = class extends Error {
+  constructor() {
+    super();
+    this.name = "RetryableError";
+    this.name = "RetryableError";
+  }
+};
+var TimeoutError = class extends Error {
+  constructor() {
+    super();
+    this.name = "TimeoutError";
+    this.message = "Retryable was Timeout";
+    this.name = "TimeoutError";
+  }
+};
+function retry(fn, { n, minWait, maxWait }) {
+  let completed = false;
+  let rejectCancelled;
+  const promise = new Promise(async (resolve, reject) => {
+    rejectCancelled = reject;
+    while (true) {
+      let result;
+      try {
+        result = await fn();
+        if (!completed) {
+          resolve(result);
+          completed = true;
+        }
+        break;
+      } catch (error) {
+        if (completed) {
+          break;
+        }
+        if (n <= 0 || !(error instanceof RetryableError)) {
+          if (error instanceof RetryableError) {
+            reject(new TimeoutError());
+          } else {
+            reject(error);
+          }
+          completed = true;
+          break;
+        }
+        n--;
+      }
+      await waitRandom(minWait, maxWait);
+    }
+  });
+  return {
+    promise,
+    cancel: () => {
+      if (completed) return;
+      completed = true;
+      rejectCancelled(new CanceledError());
+    }
+  };
+}
+
+// src/manager/seamless/index.ts
+import { splitSignature } from "@ethersproject/bytes";
+var contractTypes = {
+  ForwardRequest: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "gas", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint48" },
+    { name: "data", type: "bytes" }
+  ]
+};
+var FORWARD_PLEDGE_FEE_RADIO = 2;
+var calculateSignature = async (message) => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(message);
+  const hashBuffer = await window.crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+var seamlessNonceString = "jAkBlC4~5!6@#$%^";
+var generateEthWalletFromHashedSignature = (hashedSignature) => {
+  const seedStringToUtf8Bytes = toUtf8Bytes(hashedSignature);
+  const seedStringToKeccak256 = keccak2562(seedStringToUtf8Bytes);
+  const seedStringToKeccak256Array = getBytes(seedStringToKeccak256);
+  const privateKey = hexlify(seedStringToKeccak256Array);
+  if (!isHexString(privateKey, 32)) {
+    throw new MyxSDKError("INVALID_PRIVATE_KEY" /* InvalidPrivateKey */, "Invalid private key generated");
+  }
+  const wallet = new ethers9.Wallet(privateKey);
+  return {
+    privateKey,
+    wallet
+  };
+};
+var charFill = (ping) => {
+  const targetLength = 16;
+  if (ping.length >= targetLength) {
+    return ping;
+  }
+  const remainingLength = targetLength - ping.length;
+  const repeatTimes = Math.ceil(remainingLength / ping.length);
+  const paddedString = ping.repeat(repeatTimes).slice(0, remainingLength);
+  return ping + paddedString;
+};
+var getIvMapString = () => CryptoJS.enc.Utf8.parse(seamlessNonceString);
+async function signPermit(provider, contract, owner, spender, value, nonce, deadline, chainId) {
+  const chainDomainConfig = getChainDomainConfig(chainId, contract.target);
+  const domain = chainDomainConfig ?? await getEIP712Domain(contract);
+  const types = {
+    Permit: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "nonce", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ]
+  };
+  const message = {
+    owner,
+    spender,
+    value,
+    nonce,
+    deadline
+  };
+  const signature = await provider.signTypedData(domain, types, message);
+  const { v, r, s } = splitSignature(signature);
+  return { v, r, s };
+}
+var Seamless = class {
+  constructor(configManager, logger, utils, account) {
+    this.configManager = configManager;
+    this.logger = logger;
+    this.utils = utils;
+    this.account = account;
+    this.seamlessWallet = null;
+    this.seamlessWalletAuthorized = false;
+    this.seamlessWalletApikey = "";
+  }
+  async onCheckRelayer(account, relayer) {
+    const config = this.configManager.getConfig();
+    const forwarderContract = await getForwarderContract(config.chainId);
+    const checkRelayerResult = await forwarderContract.isUserRelayerEnabled(account, relayer);
+    console.log("checkRelayerResult-->", checkRelayerResult);
+    return checkRelayerResult;
+  }
+  async getUSDPermitParams(deadline) {
+    const config = this.configManager.getConfig();
+    const chainId = config.chainId;
+    const masterAddress = config.signer?.getAddress();
+    const brokerAddress = config.brokerAddress;
+    const contractAddress = getContractAddressByChainId(config.chainId);
+    const erc20Contract = new ethers9.Contract(
+      contractAddress.ERC20,
+      ERC20Token_default,
+      config.signer
+    );
+    const walletProvider = await getWalletProvider(chainId);
+    try {
+      const nonces = await erc20Contract.nonces(masterAddress);
+      const brokerSignPermit = await signPermit(
+        // @ts-ignore
+        walletProvider,
+        erc20Contract,
+        masterAddress,
+        brokerAddress,
+        ethers9.MaxUint256,
+        nonces,
+        deadline.toString(),
+        chainId
+      );
+      const brokerSeamlessUSDPermitParams = {
+        token: erc20Contract.target,
+        owner: masterAddress,
+        spender: brokerAddress,
+        value: ethers9.MaxUint256,
+        deadline,
+        v: brokerSignPermit.v,
+        r: brokerSignPermit.r,
+        s: brokerSignPermit.s
+      };
+      return [brokerSeamlessUSDPermitParams];
+    } catch (error) {
+      throw new MyxSDKError("INVALID_PRIVATE_KEY" /* InvalidPrivateKey */, "Invalid private key generated");
+    }
+    return;
+  }
+  async forwarderTx({
+    from,
+    to,
+    value,
+    gas,
+    deadline,
+    data,
+    nonce
+  }) {
+    const config = this.configManager.getConfig();
+    const forwarderContract = await getForwarderContract(config.chainId);
+    const forwarderJsonRpcContractDomain = await forwarderContract.eip712Domain();
+    const domain = {
+      name: forwarderJsonRpcContractDomain.name,
+      version: forwarderJsonRpcContractDomain.version,
+      chainId: forwarderJsonRpcContractDomain.chainId,
+      verifyingContract: forwarderJsonRpcContractDomain.verifyingContract
+    };
+    const walletProvider = await getSignerProvider(config.chainId);
+    const signature = await walletProvider.signTypedData(domain, contractTypes, {
+      from,
+      to,
+      value,
+      gas,
+      nonce,
+      deadline,
+      data
+    });
+    const txRs = await forwarderTxApi({ from, to, value, gas, nonce, data, deadline, signature }, config.chainId);
+    return txRs;
+  }
+  async authorizeSeamlessAccount({ approve: approve2, seamlessAddress }) {
+    console.log("authorizeSeamlessAccount-->", approve2, seamlessAddress);
+    const config = this.configManager.getConfig();
+    const accessToken = await this.configManager.getAccessToken();
+    if (!accessToken) {
+      throw new MyxSDKError("INVALID_ACCESS_TOKEN" /* InvalidAccessToken */, "Invalid access token");
+    }
+    const masterAddress = await config.signer?.getAddress() ?? "";
+    if (approve2) {
+      const balanceRes = await this.account.getWalletQuoteTokenBalance();
+      const balance = balanceRes.data;
+      const forwarderContract2 = await getForwarderContract(config.chainId);
+      const pledgeFee = await forwarderContract2.getRelayFee();
+      const gasFee = BigInt(pledgeFee) * BigInt(FORWARD_PLEDGE_FEE_RADIO);
+      if (gasFee > 0 && gasFee > BigInt(balance)) {
+        throw new MyxSDKError("INSUFFICIENT_BALANCE" /* InsufficientBalance */, "Insufficient balance");
+      }
+    }
+    const deadline = dayjs().add(60, "minute").unix();
+    let permitParams = [];
+    if (approve2) {
+      try {
+        permitParams = await this.getUSDPermitParams(deadline);
+      } catch (error) {
+        console.warn("Failed to get USD permit params, proceeding without permit:", error);
+        permitParams = [];
+      }
+    }
+    const forwarderContract = await getForwarderContract(config.chainId);
+    const nonce = await forwarderContract.nonces(masterAddress);
+    const gasLimit = SEAMLESS_ACCOUNT_GAS_LIMIT;
+    const provider = await getJSONProvider(config.chainId);
+    const { gasPrice } = await provider.getFeeData();
+    const gas = BigInt(gasLimit) * BigInt(120) * BigInt(gasPrice ?? 0) / BigInt(100);
+    const functionHash = forwarderContract.interface.encodeFunctionData("permitAndApproveForwarder", [
+      seamlessAddress,
+      approve2,
+      permitParams
+    ]);
+    const txRs = await this.forwarderTx({
+      from: masterAddress ?? "",
+      to: forwarderContract?.target,
+      value: "0",
+      gas: "350000",
+      //gas.toString(),
+      nonce: nonce.toString(),
+      data: functionHash,
+      deadline
+    });
+    if (!txRs.data?.txHash) {
+      const retryOptions = { n: 10, minWait: 250, maxWait: 1e3 };
+      const { promise } = retry(async () => {
+        const getRs = await fetchForwarderGetApi({
+          requestId: txRs.data?.requestId
+        });
+        this.logger.info("authorizeSeamlessAccount result-->", getRs);
+        if (getRs.data?.status === 9 /* EXECUTED */) {
+          if (getRs.data?.txHash) {
+            txRs.data.txHash = getRs.data.txHash;
+            return {
+              code: 0,
+              data: {
+                seamlessAccount: seamlessAddress,
+                authorized: approve2
+              }
+            };
+          } else {
+            throw new MyxSDKError("OPERATION_FAILED" /* OperationFailed */, "Operation failed, please try again later");
+          }
+        } else if ([2 /* BROADCAST_FAILED */, 3 /* TIMEOUT_CANCEL */].includes(getRs?.data?.status)) {
+          throw new MyxSDKError("OPERATION_FAILED" /* OperationFailed */, "Operation failed, please try again later");
+        }
+        throw new RetryableError();
+      }, retryOptions);
+      try {
+        await promise;
+      } catch (err) {
+        if (err instanceof TimeoutError) {
+          throw new MyxSDKError("TIMEOUT" /* Timeout */, "Your request timed out, please try again");
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+  async unLockSeamlessWallet({ masterAddress, password, apiKey }) {
+    const key = CryptoJS.enc.Utf8.parse(charFill(password));
+    const iv = getIvMapString();
+    const decrypted = CryptoJS.AES.decrypt(apiKey, key, {
+      iv,
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7
+    });
+    const privateKey = decrypted.toString(CryptoJS.enc.Utf8);
+    const wallet = new ethers9.Wallet(privateKey);
+    this.seamlessWallet = wallet;
+    const isAuthorized = await this.onCheckRelayer(masterAddress, wallet.address);
+    this.seamlessWalletAuthorized = isAuthorized;
+    return {
+      code: 0,
+      data: {
+        masterAddress,
+        seamlessAccount: wallet.address,
+        authorized: isAuthorized
+      }
+    };
+  }
+  async exportSeamlessPrivateKey({ password, apiKey }) {
+    const key = CryptoJS.enc.Utf8.parse(charFill(password));
+    const iv = getIvMapString();
+    const decrypted = CryptoJS.AES.decrypt(apiKey, key, {
+      iv,
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7
+    });
+    const privateKey = decrypted.toString(CryptoJS.enc.Utf8);
+    const wallet = new ethers9.Wallet(privateKey);
+    if (wallet.address !== this.seamlessWallet?.address) {
+      throw new MyxSDKError("INVALID_PRIVATE_KEY" /* InvalidPrivateKey */, "Invalid private key");
+    }
+    return {
+      code: 0,
+      data: {
+        privateKey
+      }
+    };
+  }
+  async importSeamlessPrivateKey({ privateKey, password }) {
+    const config = this.configManager.getConfig();
+    if (!ethers9.isHexString(privateKey, 32)) {
+      throw new MyxSDKError("INVALID_PRIVATE_KEY" /* InvalidPrivateKey */, "Invalid private key");
+    }
+    const wallet = new ethers9.Wallet(privateKey);
+    const forwarderContract = await getForwarderContract(config.chainId);
+    const masterAddress = await forwarderContract.originAccount(wallet.address);
+    if (masterAddress === ZeroAddress2) {
+      throw new MyxSDKError("INVALID_PRIVATE_KEY" /* InvalidPrivateKey */, "The private key is not a senseless account");
+    }
+    const isAuthorized = await this.onCheckRelayer(masterAddress, wallet.address);
+    const key = CryptoJS.enc.Utf8.parse(charFill(password));
+    const iv = getIvMapString();
+    const encrypted = CryptoJS.AES.encrypt(privateKey, key, {
+      iv,
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7
+    });
+    const apiKey = encrypted.toString();
+    this.seamlessWallet = wallet;
+    this.seamlessWalletAuthorized = isAuthorized;
+    this.seamlessWalletApikey = apiKey;
+    return {
+      code: 0,
+      data: {
+        masterAddress,
+        seamlessAccount: wallet.address,
+        authorized: isAuthorized,
+        apiKey
+      }
+    };
+  }
+  async createSeamless({ password }) {
+    const config = this.configManager.getConfig();
+    const signer = config.signer;
+    const account = await signer?.getAddress() ?? "";
+    if (!signer) {
+      throw new MyxSDKError("INVALID_SIGNER" /* InvalidSigner */, "Invalid signer");
+    }
+    try {
+      const createAccountSignature = await signer.signMessage(`${account}_${password}`);
+      const hashedSignature = await calculateSignature(createAccountSignature);
+      const { privateKey, wallet } = generateEthWalletFromHashedSignature(hashedSignature);
+      const key = CryptoJS.enc.Utf8.parse(charFill(password));
+      const iv = getIvMapString();
+      const encrypted = CryptoJS.AES.encrypt(privateKey, key, {
+        iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7
+      });
+      const apiKey = encrypted.toString();
+      const isAuthorized = await this.onCheckRelayer(account, wallet.address);
+      this.seamlessWallet = wallet;
+      this.seamlessWalletAuthorized = isAuthorized;
+      this.seamlessWalletApikey = apiKey;
+      return {
+        code: 0,
+        data: {
+          masterAddress: account,
+          seamlessAccount: wallet.address,
+          authorized: isAuthorized,
+          apiKey
+        }
+      };
+    } catch (error) {
+      return {
+        code: -1,
+        message: error.message
+      };
+    }
+  }
+};
+
 // src/manager/index.ts
 var MyxClient = class {
   /**
@@ -19070,6 +20747,7 @@ var MyxClient = class {
     this.position = new Position(this.configManager, this.logger, this.utils);
     this.order = new Order(this.configManager, this.logger, this.utils, this.account);
     this.subscription = new SubScription(this.configManager, this.logger);
+    this.seamless = new Seamless(this.configManager, this.logger, this.utils, this.account);
     const lp = MxSDK.getInstance();
     lp.setConfigManager(this.configManager);
   }
@@ -19102,6 +20780,7 @@ export {
   DirectionEnum,
   ErrorCode,
   ExecTypeEnum,
+  ForwarderGetStatus,
   HttpKlineIntervalEnum,
   MarketCapType,
   MarketPoolState,
@@ -19126,7 +20805,10 @@ export {
   bigintAmountSlipperCalculator,
   bigintTradingGasPriceWithRatio,
   bigintTradingGasToRatioCalculator,
+  fetchForwarderGetApi,
   formatUnits2 as formatUnits,
+  forwardUrl,
+  forwarderTxApi,
   getAllTickers,
   getAllowanceApproved,
   getBalanceOf,