@tonappchain/sdk 0.9.0-rc2 → 0.9.0-rc3

package/dist/esm/src/index.mjs

@@ -7,6 +7,914 @@ import {
   testnet_exports
 } from "../chunk-6AEFUAMZ.mjs";
 
+// src/accountAbstraction/abi.ts
+var TacAccountFactoryABI = [
+  "function getOrCreateAccount(bytes32 publicKey) external returns (address)",
+  "function getAccountAddress(bytes32 publicKey) public view returns (address)"
+];
+var TacAccountABI = [
+  // From TacBaseAccount (execute surface)
+  "function execute(address target, uint256 value, bytes calldata data) external",
+  "function executeBatch(tuple(address target, uint256 value, bytes data)[] calls) external",
+  // From IAccount + TacBaseAccount
+  "function getNonce() public view returns (uint256)",
+  "function getNonce(uint192 key) public view returns (uint256)",
+  // From TacAccount
+  "function publicKey() public view returns (bytes32)",
+  "function entryPoint() public view returns (address)"
+];
+var TacERC20PaymasterABI = [
+  "function token() public view returns (address)",
+  "function tacPermit2() public view returns (address)",
+  "function priceMarkup() public view returns (uint32)",
+  "function refundPostOpCost() public view returns (uint256)",
+  "function internalBalance(address account) public view returns (uint256)",
+  "function getPrice() public view returns (uint192)"
+];
+
+// src/accountAbstraction/BaseAccountAPI.ts
+import { concat as concat2, Contract } from "ethers";
+
+// src/accountAbstraction/internal/entryPointAbi.ts
+var IEntryPointABI = [
+  // off-chain-matching userOpHash (avoids re-implementing EIP-712 packing in the SDK)
+  "function getUserOpHash((address sender,uint256 nonce,bytes initCode,bytes callData,bytes32 accountGasLimits,uint256 preVerificationGas,bytes32 gasFees,bytes paymasterAndData,bytes signature) userOp) view returns (bytes32)",
+  // reverts with SenderAddressResult(sender) — used to derive an undeployed account address
+  "function getSenderAddress(bytes initCode)",
+  "error SenderAddressResult(address sender)",
+  "function senderCreator() view returns (address)",
+  "function getNonce(address sender, uint192 key) view returns (uint256)",
+  "event UserOperationEvent(bytes32 indexed userOpHash, address indexed sender, address indexed paymaster, uint256 nonce, bool success, uint256 actualGasCost, uint256 actualGasUsed)"
+];
+
+// src/accountAbstraction/internal/userOp.ts
+import { concat, hexlify, toBeHex, toBigInt, toQuantity, zeroPadValue } from "ethers";
+function toHexBytes(v) {
+  return v == null || v === "" ? "0x" : hexlify(v);
+}
+function packUint(high128, low128) {
+  return zeroPadValue(toBeHex((toBigInt(high128) << 128n) + toBigInt(low128)), 32);
+}
+function packPaymasterData(paymaster, paymasterVerificationGasLimit, postOpGasLimit, paymasterData) {
+  return concat([paymaster, packUint(paymasterVerificationGasLimit, postOpGasLimit), toHexBytes(paymasterData)]);
+}
+function packUserOp(op) {
+  let paymasterAndData = "0x";
+  if (op.paymaster != null) {
+    if (op.paymasterVerificationGasLimit == null || op.paymasterPostOpGasLimit == null) {
+      throw new Error("paymaster with no gas limits");
+    }
+    paymasterAndData = packPaymasterData(
+      op.paymaster,
+      op.paymasterVerificationGasLimit,
+      op.paymasterPostOpGasLimit,
+      op.paymasterData
+    );
+  }
+  const initCode = op.factory == null ? "0x" : concat([op.factory, toHexBytes(op.factoryData)]);
+  return {
+    sender: op.sender,
+    nonce: toBeHex(toBigInt(op.nonce)),
+    initCode,
+    callData: toHexBytes(op.callData),
+    accountGasLimits: packUint(op.verificationGasLimit, op.callGasLimit),
+    preVerificationGas: toBeHex(toBigInt(op.preVerificationGas)),
+    gasFees: packUint(op.maxPriorityFeePerGas, op.maxFeePerGas),
+    paymasterAndData,
+    signature: toHexBytes(op.signature)
+  };
+}
+function deepHexlify(obj) {
+  if (typeof obj === "function") {
+    return void 0;
+  }
+  if (obj == null || typeof obj === "string" || typeof obj === "boolean") {
+    return obj;
+  }
+  if (typeof obj === "bigint" || typeof obj === "number") {
+    return toQuantity(obj);
+  }
+  if (obj instanceof Uint8Array) {
+    return hexlify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((member) => deepHexlify(member));
+  }
+  const record = obj;
+  return Object.keys(record).reduce((set, key) => ({ ...set, [key]: deepHexlify(record[key]) }), {});
+}
+
+// src/accountAbstraction/BaseAccountAPI.ts
+var BaseAccountAPI = class {
+  constructor(params) {
+    this.isPhantom = true;
+    this.provider = params.provider;
+    this.entryPointAddress = params.entryPointAddress;
+    this.accountAddress = params.accountAddress;
+    this.paymasterAPI = params.paymasterAPI;
+    this.entryPointView = new Contract(params.entryPointAddress, IEntryPointABI, params.provider);
+  }
+  async init() {
+    if (await this.provider.getCode(this.entryPointAddress) === "0x") {
+      throw new Error(`entryPoint not deployed at ${this.entryPointAddress}`);
+    }
+    await this.getAccountAddress();
+    return this;
+  }
+  /** Whether the account contract is not yet deployed. */
+  async checkAccountPhantom() {
+    if (!this.isPhantom) {
+      return this.isPhantom;
+    }
+    const senderAddressCode = await this.provider.getCode(await this.getAccountAddress());
+    if (senderAddressCode.length > 2) {
+      this.isPhantom = false;
+    }
+    return this.isPhantom;
+  }
+  /** Compute the account address before deployment (via EntryPoint.getSenderAddress). */
+  async getCounterFactualAddress() {
+    const { factory, factoryData } = await this.getFactoryData() ?? {};
+    if (factory == null) {
+      throw new Error("no counterfactual address without a factory");
+    }
+    const initCode = concat2([factory, toHexBytes(factoryData)]);
+    try {
+      await this.entryPointView.getSenderAddress.staticCall(initCode);
+    } catch (e) {
+      const err = e;
+      if (err.revert?.name === "SenderAddressResult") {
+        return err.revert.args?.[0];
+      }
+      if (err.data != null) {
+        return this.entryPointView.interface.decodeErrorResult("SenderAddressResult", err.data)[0];
+      }
+      throw e;
+    }
+    throw new Error("getSenderAddress did not revert as expected");
+  }
+  /** initCode for the UserOp (factory + factoryData), or null if already deployed. */
+  async getRequiredFactoryData() {
+    if (await this.checkAccountPhantom()) {
+      return await this.getFactoryData();
+    }
+    return null;
+  }
+  /** Maximum gas used for verification (creation cost is added on top when phantom). */
+  async getVerificationGasLimit() {
+    return 1e5;
+  }
+  /** Return userOpHash for signing — computed on-chain to match EntryPoint exactly. */
+  async getUserOpHash(op) {
+    return await this.entryPointView.getUserOpHash.staticCall(packUserOp(op));
+  }
+  /** Account address (valid even before deployment). */
+  async getAccountAddress() {
+    if (this.senderAddress == null) {
+      this.senderAddress = this.accountAddress ?? await this.getCounterFactualAddress();
+    }
+    return this.senderAddress;
+  }
+  async encodeUserOpCallDataAndGasLimit(detailsForUserOp) {
+    const value = detailsForUserOp.value != null && detailsForUserOp.value !== "" ? BigInt(detailsForUserOp.value) : 0n;
+    const callData = await this.encodeExecute(detailsForUserOp.target, value, detailsForUserOp.data);
+    const callGasLimit = detailsForUserOp.gasLimit != null && detailsForUserOp.gasLimit !== "" ? BigInt(detailsForUserOp.gasLimit) : await this.provider.estimateGas({
+      from: this.entryPointAddress,
+      to: await this.getAccountAddress(),
+      data: callData
+    });
+    return { callData, callGasLimit };
+  }
+  async estimateCreationGas(factoryParams) {
+    if (factoryParams == null) {
+      return 0n;
+    }
+    const senderCreator = await this.entryPointView.senderCreator();
+    return await this.provider.estimateGas({
+      from: senderCreator,
+      to: factoryParams.factory,
+      data: toHexBytes(factoryParams.factoryData)
+    });
+  }
+  /**
+   * Create an unsigned UserOperation with all fields filled (signature empty).
+   */
+  async createUnsignedUserOp(info) {
+    const { callData, callGasLimit } = await this.encodeUserOpCallDataAndGasLimit(info);
+    const factoryParams = await this.getRequiredFactoryData();
+    const initGas = await this.estimateCreationGas(factoryParams);
+    const verificationGasLimit = BigInt(await this.getVerificationGasLimit()) + initGas;
+    let maxFeePerGas = info.maxFeePerGas;
+    let maxPriorityFeePerGas = info.maxPriorityFeePerGas;
+    if (maxFeePerGas == null || maxPriorityFeePerGas == null) {
+      const feeData = await this.provider.getFeeData();
+      maxFeePerGas ?? (maxFeePerGas = feeData.maxFeePerGas ?? void 0);
+      maxPriorityFeePerGas ?? (maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? void 0);
+    }
+    if (maxFeePerGas == null || maxPriorityFeePerGas == null) {
+      throw new Error("could not resolve gas fees from provider; pass maxFeePerGas/maxPriorityFeePerGas explicitly");
+    }
+    let partialUserOp = {
+      sender: await this.getAccountAddress(),
+      nonce: info.nonce ?? await this.getNonce(),
+      factory: factoryParams?.factory,
+      factoryData: factoryParams?.factoryData,
+      callData,
+      callGasLimit,
+      verificationGasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      preVerificationGas: 6e4,
+      signature: "",
+      authorizationList: []
+    };
+    if (this.paymasterAPI != null) {
+      const pmFields = await this.paymasterAPI.getTemporaryPaymasterData();
+      if (pmFields != null) {
+        partialUserOp = {
+          ...partialUserOp,
+          paymaster: pmFields.paymaster,
+          paymasterPostOpGasLimit: pmFields.paymasterPostOpGasLimit,
+          paymasterVerificationGasLimit: pmFields.paymasterVerificationGasLimit,
+          paymasterData: pmFields.paymasterData
+        };
+      }
+    }
+    return partialUserOp;
+  }
+  /** Sign a filled userOp. */
+  async signUserOp(userOp) {
+    const userOpHash = await this.getUserOpHash(userOp);
+    const signature = await this.signUserOpHash(userOpHash);
+    return { ...userOp, signature };
+  }
+  /** Create and sign a UserOperation. */
+  async createSignedUserOp(info) {
+    return await this.signUserOp(await this.createUnsignedUserOp(info));
+  }
+};
+
+// src/accountAbstraction/Ed25519.ts
+import { AbiCoder, concat as concat3, hexlify as hexlify2, zeroPadValue as zeroPadValue2 } from "ethers";
+var abiCoder = AbiCoder.defaultAbiCoder();
+function packRawEd25519Signature(sig) {
+  return abiCoder.encode(["bytes32[2]"], [[zeroPadValue2(hexlify2(sig.r), 32), zeroPadValue2(hexlify2(sig.s), 32)]]);
+}
+function packPermitBoundUserOpSignature(sig, permitHash) {
+  return concat3([zeroPadValue2(hexlify2(sig.r), 32), zeroPadValue2(hexlify2(sig.s), 32), zeroPadValue2(hexlify2(permitHash), 32)]);
+}
+function packPermit2InnerSignature(sig, userOpHash) {
+  return concat3([zeroPadValue2(hexlify2(sig.r), 32), zeroPadValue2(hexlify2(sig.s), 32), zeroPadValue2(hexlify2(userOpHash), 32)]);
+}
+function buildPermitBinding(userOpHash, permitHash) {
+  return concat3([zeroPadValue2(hexlify2(userOpHash), 32), zeroPadValue2(hexlify2(permitHash), 32)]);
+}
+var ZERO_HASH = "0x" + "00".repeat(32);
+function packTonConnectUserOpSignature(parts, permitHash = ZERO_HASH) {
+  return abiCoder.encode(
+    ["bytes32", "bytes32", "uint64", "string", "int32", "bytes32", "bytes32"],
+    [
+      zeroPadValue2(hexlify2(parts.r), 32),
+      zeroPadValue2(hexlify2(parts.s), 32),
+      parts.timestamp,
+      parts.domain,
+      parts.workchain,
+      zeroPadValue2(hexlify2(parts.addrHash), 32),
+      zeroPadValue2(hexlify2(permitHash), 32)
+    ]
+  );
+}
+function packTonConnectPermit2InnerSignature(parts, userOpHash) {
+  return abiCoder.encode(
+    ["bytes32", "bytes32", "uint64", "string", "int32", "bytes32", "bytes32"],
+    [
+      zeroPadValue2(hexlify2(parts.r), 32),
+      zeroPadValue2(hexlify2(parts.s), 32),
+      parts.timestamp,
+      parts.domain,
+      parts.workchain,
+      zeroPadValue2(hexlify2(parts.addrHash), 32),
+      zeroPadValue2(hexlify2(userOpHash), 32)
+    ]
+  );
+}
+function ed25519SignerFromSecretKey(secretKey, ed25519Sign) {
+  return async (message) => {
+    const msgBytes = hexToBytes(message);
+    const sig = ed25519Sign(msgBytes, secretKey);
+    if (sig.length !== 64) {
+      throw new Error(`expected 64-byte Ed25519 signature, got ${sig.length}`);
+    }
+    return {
+      r: "0x" + bytesToHex(sig.slice(0, 32)),
+      s: "0x" + bytesToHex(sig.slice(32, 64))
+    };
+  };
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const out = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function bytesToHex(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, "0");
+  return s;
+}
+
+// src/accountAbstraction/HttpRpcClient.ts
+import { JsonRpcProvider, resolveProperties } from "ethers";
+var HttpRpcClient = class {
+  constructor(bundlerUrl, entryPointAddress, chainId) {
+    this.bundlerUrl = bundlerUrl;
+    this.entryPointAddress = entryPointAddress;
+    this.chainId = chainId;
+    this.userOpJsonRpcProvider = new JsonRpcProvider(this.bundlerUrl);
+    this.initializing = this.validateChainId();
+  }
+  async validateChainId() {
+    const chain = await this.userOpJsonRpcProvider.send("eth_chainId", []);
+    const bundlerChain = parseInt(chain);
+    if (bundlerChain !== this.chainId) {
+      throw new Error(`bundler ${this.bundlerUrl} is on chainId ${bundlerChain}, but the client expects ${this.chainId}`);
+    }
+  }
+  /**
+   * Send a UserOperation to the bundler.
+   * @returns the userOpHash (id of this operation).
+   */
+  async sendUserOpToBundler(userOp) {
+    await this.initializing;
+    const hexifiedUserOp = deepHexlify(await resolveProperties(userOp));
+    return await this.userOpJsonRpcProvider.send("eth_sendUserOperation", [hexifiedUserOp, this.entryPointAddress]);
+  }
+  /**
+   * Ask the bundler to estimate gas for a UserOperation.
+   */
+  async estimateUserOpGas(userOp) {
+    await this.initializing;
+    const hexifiedUserOp = deepHexlify(userOp);
+    return await this.userOpJsonRpcProvider.send("eth_estimateUserOperationGas", [hexifiedUserOp, this.entryPointAddress]);
+  }
+  /** Fetch the bundler's receipt for a UserOperation, or null if not yet mined. */
+  async getUserOperationReceipt(userOpHash) {
+    await this.initializing;
+    return await this.userOpJsonRpcProvider.send("eth_getUserOperationReceipt", [userOpHash]);
+  }
+};
+
+// src/sdk/Consts.ts
+import { toNano } from "@ton/ton";
+var JETTON_TRANSFER_FORWARD_TON_AMOUNT = toNano(0.2);
+var NFT_TRANSFER_FORWARD_TON_AMOUNT = toNano(0.3);
+var LEGACY_FORWARD_FEE_ESTIMATE_NUMERATOR = 3n;
+var LEGACY_FORWARD_FEE_ESTIMATE_DENOMINATOR = 2n;
+var LEGACY_STRICTLY_GREATER_THAN_FEE_EPSILON = 1n;
+var LEGACY_JETTON_WALLET_MIN_TONS_FOR_STORAGE = 10000000n;
+var LEGACY_JETTON_WALLET_GAS_CONSUMPTION = 15000000n;
+var LEGACY_JETTON_WALLET_GAS_CONSUMPTION_COUNT = 2n;
+var LEGACY_JETTON_TRANSFER_BASE_OUTBOUND_MESSAGE_COUNT = 1n;
+var LEGACY_JETTON_TRANSFER_WITH_FORWARD_OUTBOUND_MESSAGE_COUNT = 2n;
+var LEGACY_JETTON_WALLET_TRANSFER_GAS_AND_STORAGE = LEGACY_JETTON_WALLET_GAS_CONSUMPTION_COUNT * LEGACY_JETTON_WALLET_GAS_CONSUMPTION + LEGACY_JETTON_WALLET_MIN_TONS_FOR_STORAGE;
+var LEGACY_NFT_ITEM_MIN_TONS_FOR_STORAGE = 50000000n;
+var LEGACY_NFT_TRANSFER_BASE_OUTBOUND_MESSAGE_COUNT = 1n;
+var LEGACY_NFT_TRANSFER_WITH_FORWARD_OUTBOUND_MESSAGE_COUNT = 2n;
+var USDT_JETTON_WALLET_CODE_HASH = "89468f02c78e570802e39979c8516fc38df07ea76a48357e0536f2ba7b3ee37b";
+var DYNAMIC_JETTON_WALLET_CODE_HASHES = [USDT_JETTON_WALLET_CODE_HASH];
+var FIXED_POINT_SHIFT = 2 ** 16;
+var MAX_ITERATION_COUNT = 120;
+var DEFAULT_DELAY = 0;
+var SOLIDITY_SIGNATURE_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*(\((bytes,bytes)\))?$/;
+var SOLIDITY_METHOD_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var MAX_EXT_MSG_SIZE = 65535;
+var MAX_HIGHLOAD_GROUP_MSG_NUM = 254;
+var MAX_MSG_DEPTH = 512;
+var TON_SYMBOL = "TON";
+var TAC_SYMBOL = "TAC";
+var TON_MAINNET_GLOBAL_ID = -239;
+var TON_TESTNET_GLOBAL_ID = -3;
+var FIFTEEN_MINUTES = 15 * 60 * 1e3;
+var ONE_YEAR_SECONDS = 365 * 24 * 3600;
+var TON_DECIMALS = 9;
+var TAC_DECIMALS = 18;
+var FIVE_MINUTES = 5 * 60 * 1e3;
+var MINUTE = 60 * 1e3;
+var TON_BURN_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
+var DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRY_MAX_COUNT = 5;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+var DEFAULT_RETRY_MAX_DELAY_MS = 3e4;
+var DEFAULT_RETRY_BACKOFF_MULTIPLIER = 3;
+var DEFAULT_WAIT_TIMEOUT_MS = 3e5;
+var DEFAULT_WAIT_MAX_ATTEMPTS = 30;
+var DEFAULT_WAIT_DELAY_MS = 1e4;
+var DEFAULT_FIND_TX_LIMIT = 100;
+var DEFAULT_MAX_SCANNED_TRANSACTIONS = 100;
+var DEFAULT_FIND_TX_MAX_DEPTH = 10;
+var DEFAULT_RETRY_ON_NOT_FOUND = true;
+var DEFAULT_RETRY_ON_NOT_FOUND_RETRIES = 10;
+var DEFAULT_RETRY_ON_NOT_FOUND_DELAY_MS = 5e3;
+var IGNORE_MSG_VALUE_1_NANO = 1n;
+var CROSS_CHAIN_MESSAGE_VERSION_V1 = 1n;
+var NFT_BRIDGE_AMOUNT = 1n;
+var DEFAULT_EIP1559_PRIORITY_FEE = 0n;
+var IGNORE_OPCODE = [
+  3576854235
+  // Excess
+];
+var HTTP_NOT_FOUND_STATUS_CODE = 404;
+
+// src/structs/Struct.ts
+var SimplifiedStatuses = /* @__PURE__ */ ((SimplifiedStatuses2) => {
+  SimplifiedStatuses2["PENDING"] = "PENDING";
+  SimplifiedStatuses2["FAILED"] = "FAILED";
+  SimplifiedStatuses2["SUCCESSFUL"] = "SUCCESSFUL";
+  SimplifiedStatuses2["OPERATION_ID_NOT_FOUND"] = "OPERATION_ID_NOT_FOUND";
+  return SimplifiedStatuses2;
+})(SimplifiedStatuses || {});
+var Network = /* @__PURE__ */ ((Network2) => {
+  Network2["TESTNET"] = "testnet";
+  Network2["MAINNET"] = "mainnet";
+  Network2["DEV"] = "dev";
+  return Network2;
+})(Network || {});
+var BlockchainType = /* @__PURE__ */ ((BlockchainType2) => {
+  BlockchainType2["TAC"] = "TAC";
+  BlockchainType2["TON"] = "TON";
+  return BlockchainType2;
+})(BlockchainType || {});
+var CurrencyType = /* @__PURE__ */ ((CurrencyType2) => {
+  CurrencyType2["TAC"] = "TAC";
+  CurrencyType2["TON"] = "TON";
+  return CurrencyType2;
+})(CurrencyType || {});
+var OperationType = /* @__PURE__ */ ((OperationType2) => {
+  OperationType2["PENDING"] = "PENDING";
+  OperationType2["TON_TAC_TON"] = "TON-TAC-TON";
+  OperationType2["ROLLBACK"] = "ROLLBACK";
+  OperationType2["TON_TAC"] = "TON-TAC";
+  OperationType2["TAC_TON"] = "TAC-TON";
+  OperationType2["UNKNOWN"] = "UNKNOWN";
+  return OperationType2;
+})(OperationType || {});
+var OperationExecutionStatus = /* @__PURE__ */ ((OperationExecutionStatus2) => {
+  OperationExecutionStatus2["SUCCESS"] = "success";
+  OperationExecutionStatus2["FAILED"] = "failed";
+  return OperationExecutionStatus2;
+})(OperationExecutionStatus || {});
+var AssetType = /* @__PURE__ */ ((AssetType2) => {
+  AssetType2["NFT"] = "NFT";
+  AssetType2["FT"] = "FT";
+  return AssetType2;
+})(AssetType || {});
+var NFTAddressType = /* @__PURE__ */ ((NFTAddressType2) => {
+  NFTAddressType2["ITEM"] = "ITEM";
+  NFTAddressType2["COLLECTION"] = "COLLECTION";
+  return NFTAddressType2;
+})(NFTAddressType || {});
+var StageName = /* @__PURE__ */ ((StageName2) => {
+  StageName2["COLLECTED_IN_TAC"] = "collectedInTAC";
+  StageName2["INCLUDED_IN_TAC_CONSENSUS"] = "includedInTACConsensus";
+  StageName2["EXECUTED_IN_TAC"] = "executedInTAC";
+  StageName2["COLLECTED_IN_TON"] = "collectedInTON";
+  StageName2["INCLUDED_IN_TON_CONSENSUS"] = "includedInTONConsensus";
+  StageName2["EXECUTED_IN_TON"] = "executedInTON";
+  return StageName2;
+})(StageName || {});
+var TokenSymbol = /* @__PURE__ */ ((TokenSymbol2) => {
+  TokenSymbol2["TAC_SYMBOL"] = "TAC";
+  TokenSymbol2["TON_SYMBOL"] = "TON";
+  return TokenSymbol2;
+})(TokenSymbol || {});
+var defaultWaitOptions = {
+  timeout: DEFAULT_WAIT_TIMEOUT_MS,
+  maxAttempts: DEFAULT_WAIT_MAX_ATTEMPTS,
+  delay: DEFAULT_WAIT_DELAY_MS
+};
+var Origin = /* @__PURE__ */ ((Origin2) => {
+  Origin2["TON"] = "TON";
+  Origin2["TAC"] = "TAC";
+  return Origin2;
+})(Origin || {});
+var AssetFeeMode = /* @__PURE__ */ ((AssetFeeMode2) => {
+  AssetFeeMode2["TAC_ORIGINAL"] = "TAC_ORIGINAL";
+  AssetFeeMode2["LEGACY"] = "LEGACY";
+  AssetFeeMode2["DYNAMIC"] = "DYNAMIC";
+  return AssetFeeMode2;
+})(AssetFeeMode || {});
+var TransactionTreeDirection = /* @__PURE__ */ ((TransactionTreeDirection2) => {
+  TransactionTreeDirection2["FORWARD"] = "forward";
+  TransactionTreeDirection2["BACKWARD"] = "backward";
+  TransactionTreeDirection2["BOTH"] = "both";
+  return TransactionTreeDirection2;
+})(TransactionTreeDirection || {});
+
+// src/accountAbstraction/networks.ts
+var AA_NETWORKS = {
+  ["testnet" /* TESTNET */]: {
+    chainId: 2391,
+    entryPoint: "0x239DBD98defbad1c369034a2897bD5b8b57b468A",
+    accountFactory: "0x7879c3237811A86092E89AD94837163Ae71d6669",
+    // paymaster for token USD₮ (0xbA7E…9220, 6-dec); the fee token is read on-chain
+    paymaster: "0xD41B5AC8803bd9371c0bdB44CB95B8b1879F8865",
+    permit2: "0x36d6565DcdE4674115bBd1d86E511bebB1C425b9"
+    // bundlerUrl: undefined — provide it via TacAccountSdk.create({ bundlerUrl })
+  }
+  // MAINNET: account abstraction not deployed yet
+};
+
+// src/accountAbstraction/PaymasterAPI.ts
+var PaymasterAPI = class {
+  /** Temporary values to put into the paymaster fields (used for gas estimation). */
+  async getTemporaryPaymasterData() {
+    return await this.getPaymasterData();
+  }
+  /** Final paymaster parameters (after gas estimation). */
+  async getPaymasterData() {
+    return null;
+  }
+};
+
+// src/accountAbstraction/Permit2.ts
+import { AbiCoder as AbiCoder2, concat as concat4, keccak256 } from "ethers";
+var abiCoder2 = AbiCoder2.defaultAbiCoder();
+var PERMIT_TUPLE_TYPE = "tuple(tuple(address,uint256)[],uint256,uint256,uint256,address)";
+function buildPermitMessage(input) {
+  const permit = [
+    input.permitted.map((p) => [p.token, p.amount]),
+    input.nonce,
+    input.deadline,
+    input.chainId,
+    input.verifyingContract
+  ];
+  const messageHex = abiCoder2.encode([PERMIT_TUPLE_TYPE], [permit]);
+  const permitHash = keccak256(messageHex);
+  return { permit, messageHex, permitHash };
+}
+function packPermitData(permit, signatureBlob) {
+  return abiCoder2.encode([PERMIT_TUPLE_TYPE, "bytes"], [permit, signatureBlob]);
+}
+function packPermitPaymasterData(permit, signatureBlob) {
+  return concat4(["0x01", packPermitData(permit, signatureBlob)]);
+}
+
+// src/accountAbstraction/PermitFlow.ts
+import { concat as concat6, Contract as Contract2 } from "ethers";
+
+// src/accountAbstraction/TacERC20PaymasterAPI.ts
+import { concat as concat5, toBeHex as toBeHex2, zeroPadValue as zeroPadValue3 } from "ethers";
+var TacPaymasterMode = /* @__PURE__ */ ((TacPaymasterMode2) => {
+  TacPaymasterMode2[TacPaymasterMode2["TRANSFER_FROM_REQUESTOR"] = 0] = "TRANSFER_FROM_REQUESTOR";
+  TacPaymasterMode2[TacPaymasterMode2["TRANSFER_VIA_PERMIT"] = 1] = "TRANSFER_VIA_PERMIT";
+  TacPaymasterMode2[TacPaymasterMode2["INTERNAL_BALANCE"] = 2] = "INTERNAL_BALANCE";
+  return TacPaymasterMode2;
+})(TacPaymasterMode || {});
+var DEFAULT_PM_VERIFICATION_GAS_LIMIT = 1e5;
+var DEFAULT_PM_POST_OP_GAS_LIMIT = 1e5;
+var TacERC20PaymasterAPI = class extends PaymasterAPI {
+  constructor(params) {
+    super();
+    this.paymaster = params.paymaster;
+    this.mode = params.mode;
+    this.paymasterVerificationGasLimit = params.paymasterVerificationGasLimit ?? DEFAULT_PM_VERIFICATION_GAS_LIMIT;
+    this.paymasterPostOpGasLimit = params.paymasterPostOpGasLimit ?? DEFAULT_PM_POST_OP_GAS_LIMIT;
+  }
+  async getTemporaryPaymasterData() {
+    return await this.getPaymasterData();
+  }
+  async getPaymasterData() {
+    return {
+      paymaster: this.paymaster,
+      paymasterVerificationGasLimit: this.paymasterVerificationGasLimit,
+      paymasterPostOpGasLimit: this.paymasterPostOpGasLimit,
+      paymasterData: this._buildPaymasterData()
+    };
+  }
+  _buildPaymasterData() {
+    switch (this.mode) {
+      case 0 /* TRANSFER_FROM_REQUESTOR */:
+      case 2 /* INTERNAL_BALANCE */:
+        return packModeByte(this.mode);
+      case 1 /* TRANSFER_VIA_PERMIT */:
+        throw new Error(
+          "TacPaymasterMode.TRANSFER_VIA_PERMIT requires the double-signing flow. Use buildSignedUserOpWithPermit(...) instead of composing this PaymasterAPI into a TacAccountAPI."
+        );
+      default:
+        throw new Error(`unknown TacPaymasterMode: ${this.mode}`);
+    }
+  }
+};
+function packModeByte(mode) {
+  return zeroPadValue3(toBeHex2(mode), 1);
+}
+function packPaymasterAndData(params) {
+  return concat5([
+    params.paymaster,
+    zeroPadValue3(toBeHex2(params.paymasterVerificationGasLimit), 16),
+    zeroPadValue3(toBeHex2(params.paymasterPostOpGasLimit), 16),
+    params.paymasterData
+  ]);
+}
+
+// src/accountAbstraction/PermitFlow.ts
+var DEFAULT_PM_GAS = 1e5;
+var PLACEHOLDER_INNER_SIG = "0x" + "00".repeat(96);
+async function buildSignedUserOpWithPermit(input) {
+  const { accountAPI, paymaster, permitInput, ed25519Signer, txDetails } = input;
+  const pmVerifGas = input.paymasterVerificationGasLimit ?? DEFAULT_PM_GAS;
+  const pmPostOpGas = input.paymasterPostOpGasLimit ?? DEFAULT_PM_GAS;
+  const entryPoint = new Contract2(accountAPI.entryPointAddress, IEntryPointABI, accountAPI.provider);
+  const { permit, permitHash } = buildPermitMessage(permitInput);
+  const userOp = await accountAPI.createUnsignedUserOp(txDetails);
+  userOp.paymaster = paymaster;
+  userOp.paymasterVerificationGasLimit = pmVerifGas;
+  userOp.paymasterPostOpGasLimit = pmPostOpGas;
+  userOp.paymasterData = concat6([
+    packModeByte(1 /* TRANSFER_VIA_PERMIT */),
+    packPermitData(permit, PLACEHOLDER_INNER_SIG)
+  ]);
+  const userOpHashR1 = await entryPoint.getUserOpHash.staticCall(packUserOp(userOp));
+  const sigR1 = await ed25519Signer(buildPermitBinding(userOpHashR1, permitHash));
+  const innerSig = packPermit2InnerSignature(sigR1, userOpHashR1);
+  userOp.paymasterData = concat6([packModeByte(1 /* TRANSFER_VIA_PERMIT */), packPermitData(permit, innerSig)]);
+  const userOpHashR2 = await entryPoint.getUserOpHash.staticCall(packUserOp(userOp));
+  const sigR2 = await ed25519Signer(buildPermitBinding(userOpHashR2, permitHash));
+  userOp.signature = packPermitBoundUserOpSignature(sigR2, permitHash);
+  return userOp;
+}
+async function buildSignedUserOpWithPermitTonConnect(input) {
+  const { accountAPI, paymaster, permitInput, tonConnectSigner, txDetails } = input;
+  const pmVerifGas = input.paymasterVerificationGasLimit ?? DEFAULT_PM_GAS;
+  const pmPostOpGas = input.paymasterPostOpGasLimit ?? DEFAULT_PM_GAS;
+  const entryPoint = new Contract2(accountAPI.entryPointAddress, IEntryPointABI, accountAPI.provider);
+  const { permit, permitHash } = buildPermitMessage(permitInput);
+  const userOp = await accountAPI.createUnsignedUserOp(txDetails);
+  userOp.paymaster = paymaster;
+  userOp.paymasterVerificationGasLimit = pmVerifGas;
+  userOp.paymasterPostOpGasLimit = pmPostOpGas;
+  userOp.paymasterData = concat6([
+    packModeByte(1 /* TRANSFER_VIA_PERMIT */),
+    packPermitData(permit, PLACEHOLDER_INNER_SIG)
+  ]);
+  const userOpHashR1 = await entryPoint.getUserOpHash.staticCall(packUserOp(userOp));
+  const partsR1 = await tonConnectSigner(buildPermitBinding(userOpHashR1, permitHash));
+  const innerSig = packTonConnectPermit2InnerSignature(partsR1, userOpHashR1);
+  userOp.paymasterData = concat6([packModeByte(1 /* TRANSFER_VIA_PERMIT */), packPermitData(permit, innerSig)]);
+  const userOpHashR2 = await entryPoint.getUserOpHash.staticCall(packUserOp(userOp));
+  const partsR2 = await tonConnectSigner(buildPermitBinding(userOpHashR2, permitHash));
+  userOp.signature = packTonConnectUserOpSignature(partsR2, permitHash);
+  return userOp;
+}
+
+// src/accountAbstraction/signer.ts
+import { mnemonicToWalletKey, sign } from "ton-crypto";
+async function aaSignerFromMnemonic(mnemonic) {
+  const keypair = await mnemonicToWalletKey(mnemonic.trim().split(/\s+/));
+  const signer = ed25519SignerFromSecretKey(
+    keypair.secretKey,
+    (message, secretKey) => sign(Buffer.from(message), Buffer.from(secretKey))
+  );
+  return { publicKey: "0x" + keypair.publicKey.toString("hex"), signer };
+}
+
+// src/accountAbstraction/TacAccountAPI.ts
+import { Contract as Contract3 } from "ethers";
+var ZERO_HASH2 = "0x" + "00".repeat(32);
+var TacAccountAPI = class extends BaseAccountAPI {
+  constructor(params) {
+    super(params);
+    if (params.signer == null === (params.tonConnectSigner == null)) {
+      throw new Error("TacAccountAPI requires exactly one of `signer` or `tonConnectSigner`");
+    }
+    this.publicKey = params.publicKey;
+    this.signer = params.signer;
+    this.tonConnectSigner = params.tonConnectSigner;
+    this.factoryAddress = params.factoryAddress;
+  }
+  async _getAccountContract() {
+    if (this.accountContract == null) {
+      const addr = await this.getAccountAddress();
+      this.accountContract = new Contract3(addr, TacAccountABI, this.provider);
+    }
+    return this.accountContract;
+  }
+  _getFactory() {
+    if (this.factoryContract == null) {
+      this.factoryContract = new Contract3(this.factoryAddress, TacAccountFactoryABI, this.provider);
+    }
+    return this.factoryContract;
+  }
+  /** Derive the deterministic account address directly from the factory's view. */
+  async getCounterFactualAddress() {
+    return await this._getFactory().getAccountAddress.staticCall(this.publicKey);
+  }
+  /** initCode for an undeployed account: factory + `getOrCreateAccount(publicKey)` calldata. */
+  async getFactoryData() {
+    const factory = this._getFactory();
+    return {
+      factory: this.factoryAddress,
+      factoryData: factory.interface.encodeFunctionData("getOrCreateAccount", [this.publicKey])
+    };
+  }
+  /** Sequential nonce from the deployed account, or 0 if still phantom. */
+  async getNonce() {
+    if (await this.checkAccountPhantom()) {
+      return 0n;
+    }
+    const accountContract = await this._getAccountContract();
+    return await accountContract.getFunction("getNonce()").staticCall();
+  }
+  /** Encode a single call as `TacBaseAccount.execute(target, value, data)` calldata. */
+  async encodeExecute(target, value, data) {
+    const accountContract = await this._getAccountContract();
+    return accountContract.interface.encodeFunctionData("execute", [target, value, data]);
+  }
+  /**
+   * Sign userOpHash with the configured signer (64-byte raw, or TonConnect with
+   * `permitHash = 0`). For paymaster Mode 1 use {@link buildSignedUserOpWithPermit}.
+   */
+  async signUserOpHash(userOpHash) {
+    if (this.signer != null) {
+      const sig = await this.signer(userOpHash);
+      return packRawEd25519Signature(sig);
+    }
+    if (this.tonConnectSigner != null) {
+      const binding = buildPermitBinding(userOpHash, ZERO_HASH2);
+      const parts = await this.tonConnectSigner(binding);
+      return packTonConnectUserOpSignature(parts, ZERO_HASH2);
+    }
+    throw new Error("TacAccountAPI: no signer configured");
+  }
+};
+
+// src/accountAbstraction/TacAccountSdk.ts
+import { Contract as Contract4, getDefaultProvider, MaxUint256, parseUnits } from "ethers";
+
+// src/sdk/Artifacts.ts
+function getArtifacts(network) {
+  switch (network) {
+    case "mainnet" /* MAINNET */:
+      return mainnet_exports;
+    case "testnet" /* TESTNET */:
+      return testnet_exports;
+    case "dev" /* DEV */:
+      return dev_exports;
+    default:
+      throw new Error(`Unsupported network: ${network}`);
+  }
+}
+
+// src/accountAbstraction/TacAccountSdk.ts
+var TacAccountSdk = class _TacAccountSdk {
+  constructor(network, provider, addresses, chainId, bundlerUrl, publicKey, signer) {
+    this.network = network;
+    this.provider = provider;
+    this.addresses = addresses;
+    this.chainId = chainId;
+    this.bundlerUrl = bundlerUrl;
+    this._permitCounter = 0;
+    this._publicKey = publicKey;
+    this._signer = signer;
+    this.account = new TacAccountAPI({
+      provider,
+      entryPointAddress: addresses.entryPoint,
+      factoryAddress: addresses.accountFactory,
+      publicKey,
+      signer
+    });
+  }
+  static async create(params) {
+    const cfg = AA_NETWORKS[params.network];
+    if (cfg == null) {
+      throw new Error(`account abstraction is not available on network "${params.network}" yet`);
+    }
+    let provider = params.provider;
+    if (provider == null) {
+      const rpc = getArtifacts(params.network).TAC_RPC_ENDPOINT;
+      if (rpc == null) {
+        throw new Error(`no default TAC RPC for network "${params.network}"; pass a custom provider`);
+      }
+      provider = getDefaultProvider(rpc);
+    }
+    const addresses = {
+      entryPoint: params.addresses?.entryPoint ?? cfg.entryPoint,
+      accountFactory: params.addresses?.accountFactory ?? cfg.accountFactory,
+      paymaster: params.addresses?.paymaster ?? cfg.paymaster,
+      permit2: params.addresses?.permit2 ?? cfg.permit2
+    };
+    const { publicKey, signer } = await aaSignerFromMnemonic(params.mnemonic);
+    return new _TacAccountSdk(
+      params.network,
+      provider,
+      addresses,
+      cfg.chainId,
+      params.bundlerUrl ?? cfg.bundlerUrl,
+      publicKey,
+      signer
+    );
+  }
+  /** The deterministic smart-account address (derived from the TON public key). */
+  async getAccountAddress() {
+    this._address ?? (this._address = await this.account.getAccountAddress());
+    return this._address;
+  }
+  /** Send a call paying gas natively (account must hold TAC). */
+  async sendUserOp(tx) {
+    const op = await this.account.createSignedUserOp(this._txDetails(tx));
+    return await this._submit(op);
+  }
+  /** Send a call paying gas in an ERC-20 via the paymaster (Mode 1 — Permit2). */
+  async sendUserOpWithPermit(tx) {
+    const token = await this._tokenInfoResolved();
+    const op = await buildSignedUserOpWithPermit({
+      accountAPI: this.account,
+      paymaster: this.addresses.paymaster,
+      paymasterVerificationGasLimit: tx.paymasterVerificationGasLimit ?? 5e5,
+      paymasterPostOpGasLimit: tx.paymasterPostOpGasLimit ?? 15e4,
+      permitInput: {
+        permitted: [{ token: tx.feeToken ?? token.address, amount: tx.maxFee ?? parseUnits("1000", token.decimals) }],
+        nonce: this._newPermitNonce(),
+        deadline: tx.deadline ?? MaxUint256,
+        chainId: this.chainId,
+        verifyingContract: this.addresses.permit2
+      },
+      ed25519Signer: this._signer,
+      txDetails: this._txDetails(tx)
+    });
+    return await this._submit(op);
+  }
+  /** Send a call paying gas from the account's pre-credited internal balance (Mode 2). */
+  async sendUserOpViaInternalBalance(tx) {
+    return await this._sendViaMode(tx, 2 /* INTERNAL_BALANCE */);
+  }
+  /** Send a call where the paymaster pulls the fee token via a pre-set allowance (Mode 0). */
+  async sendUserOpViaAllowance(tx) {
+    return await this._sendViaMode(tx, 0 /* TRANSFER_FROM_REQUESTOR */);
+  }
+  /** Poll the bundler for a UserOperation receipt. */
+  async waitForReceipt(userOpHash, opts) {
+    const client = this._bundlerClient();
+    const end = Date.now() + (opts?.timeoutMs ?? 12e4);
+    while (Date.now() < end) {
+      const r = await client.getUserOperationReceipt(userOpHash);
+      if (r != null) {
+        return r;
+      }
+      await new Promise((res) => setTimeout(res, opts?.intervalMs ?? 3e3));
+    }
+    throw new Error(`userOp ${userOpHash} not mined within timeout`);
+  }
+  /** The bundler client (throws if no bundler URL was configured). */
+  bundler() {
+    return this._bundlerClient();
+  }
+  // ── internals ──────────────────────────────────────────────────────────────
+  _bundlerClient() {
+    if (this.bundlerUrl == null || this.bundlerUrl === "") {
+      throw new Error("no bundler URL configured \u2014 pass `bundlerUrl` to TacAccountSdk.create({ ... })");
+    }
+    this._bundler ?? (this._bundler = new HttpRpcClient(this.bundlerUrl, this.addresses.entryPoint, this.chainId));
+    return this._bundler;
+  }
+  _txDetails(tx) {
+    return { target: tx.target, value: tx.value ?? 0, data: tx.data, gasLimit: tx.gasLimit ?? 1e6 };
+  }
+  async _sendViaMode(tx, mode) {
+    const paymasterAPI = new TacERC20PaymasterAPI({ paymaster: this.addresses.paymaster, mode });
+    const account = new TacAccountAPI({
+      provider: this.provider,
+      entryPointAddress: this.addresses.entryPoint,
+      factoryAddress: this.addresses.accountFactory,
+      publicKey: this._publicKey,
+      signer: this._signer,
+      accountAddress: await this.getAccountAddress(),
+      paymasterAPI
+    });
+    const op = await account.createSignedUserOp(this._txDetails(tx));
+    return await this._submit(op);
+  }
+  async _submit(op) {
+    const userOpHash = await this._bundlerClient().sendUserOpToBundler(op);
+    const receipt = await this.waitForReceipt(userOpHash);
+    return { userOpHash, receipt };
+  }
+  async _tokenInfoResolved() {
+    if (this._tokenInfo == null) {
+      const pm = new Contract4(this.addresses.paymaster, ["function token() view returns (address)"], this.provider);
+      const address3 = await pm.token();
+      const erc20 = new Contract4(address3, ["function decimals() view returns (uint8)"], this.provider);
+      const decimals = Number(await erc20.decimals());
+      this._tokenInfo = { address: address3, decimals };
+    }
+    return this._tokenInfo;
+  }
+  /** Unique permit nonce (Permit2 replay protection): timestamp-ms high bits + a counter. */
+  _newPermitNonce() {
+    return BigInt(Date.now()) << 16n | BigInt(this._permitCounter++ & 65535);
+  }
+};
+
 // src/adapters/BaseContractOpener.ts
 import {
   Address as Address6,
@@ -305,157 +1213,11 @@ var tonIndexerRequiredForTonTransactionBocError = new SettingError(
 );
 var invalidAmountError = (reason) => new FormatError(`Invalid amount: ${reason}`, 144);
 
-// src/sdk/Consts.ts
-import { toNano } from "@ton/ton";
-var JETTON_TRANSFER_FORWARD_TON_AMOUNT = toNano(0.2);
-var NFT_TRANSFER_FORWARD_TON_AMOUNT = toNano(0.3);
-var LEGACY_FORWARD_FEE_ESTIMATE_NUMERATOR = 3n;
-var LEGACY_FORWARD_FEE_ESTIMATE_DENOMINATOR = 2n;
-var LEGACY_STRICTLY_GREATER_THAN_FEE_EPSILON = 1n;
-var LEGACY_JETTON_WALLET_MIN_TONS_FOR_STORAGE = 10000000n;
-var LEGACY_JETTON_WALLET_GAS_CONSUMPTION = 15000000n;
-var LEGACY_JETTON_WALLET_GAS_CONSUMPTION_COUNT = 2n;
-var LEGACY_JETTON_TRANSFER_BASE_OUTBOUND_MESSAGE_COUNT = 1n;
-var LEGACY_JETTON_TRANSFER_WITH_FORWARD_OUTBOUND_MESSAGE_COUNT = 2n;
-var LEGACY_JETTON_WALLET_TRANSFER_GAS_AND_STORAGE = LEGACY_JETTON_WALLET_GAS_CONSUMPTION_COUNT * LEGACY_JETTON_WALLET_GAS_CONSUMPTION + LEGACY_JETTON_WALLET_MIN_TONS_FOR_STORAGE;
-var LEGACY_NFT_ITEM_MIN_TONS_FOR_STORAGE = 50000000n;
-var LEGACY_NFT_TRANSFER_BASE_OUTBOUND_MESSAGE_COUNT = 1n;
-var LEGACY_NFT_TRANSFER_WITH_FORWARD_OUTBOUND_MESSAGE_COUNT = 2n;
-var USDT_JETTON_WALLET_CODE_HASH = "89468f02c78e570802e39979c8516fc38df07ea76a48357e0536f2ba7b3ee37b";
-var DYNAMIC_JETTON_WALLET_CODE_HASHES = [USDT_JETTON_WALLET_CODE_HASH];
-var FIXED_POINT_SHIFT = 2 ** 16;
-var MAX_ITERATION_COUNT = 120;
-var DEFAULT_DELAY = 0;
-var SOLIDITY_SIGNATURE_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*(\((bytes,bytes)\))?$/;
-var SOLIDITY_METHOD_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var MAX_EXT_MSG_SIZE = 65535;
-var MAX_HIGHLOAD_GROUP_MSG_NUM = 254;
-var MAX_MSG_DEPTH = 512;
-var TON_SYMBOL = "TON";
-var TAC_SYMBOL = "TAC";
-var TON_MAINNET_GLOBAL_ID = -239;
-var TON_TESTNET_GLOBAL_ID = -3;
-var FIFTEEN_MINUTES = 15 * 60 * 1e3;
-var ONE_YEAR_SECONDS = 365 * 24 * 3600;
-var TON_DECIMALS = 9;
-var TAC_DECIMALS = 18;
-var FIVE_MINUTES = 5 * 60 * 1e3;
-var MINUTE = 60 * 1e3;
-var TON_BURN_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
-var DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 3e4;
-var DEFAULT_RETRY_MAX_COUNT = 5;
-var DEFAULT_RETRY_DELAY_MS = 1e3;
-var DEFAULT_RETRY_MAX_DELAY_MS = 3e4;
-var DEFAULT_RETRY_BACKOFF_MULTIPLIER = 3;
-var DEFAULT_WAIT_TIMEOUT_MS = 3e5;
-var DEFAULT_WAIT_MAX_ATTEMPTS = 30;
-var DEFAULT_WAIT_DELAY_MS = 1e4;
-var DEFAULT_FIND_TX_LIMIT = 100;
-var DEFAULT_MAX_SCANNED_TRANSACTIONS = 100;
-var DEFAULT_FIND_TX_MAX_DEPTH = 10;
-var DEFAULT_RETRY_ON_NOT_FOUND = true;
-var DEFAULT_RETRY_ON_NOT_FOUND_RETRIES = 10;
-var DEFAULT_RETRY_ON_NOT_FOUND_DELAY_MS = 5e3;
-var IGNORE_MSG_VALUE_1_NANO = 1n;
-var CROSS_CHAIN_MESSAGE_VERSION_V1 = 1n;
-var NFT_BRIDGE_AMOUNT = 1n;
-var DEFAULT_EIP1559_PRIORITY_FEE = 0n;
-var IGNORE_OPCODE = [
-  3576854235
-  // Excess
-];
-var HTTP_NOT_FOUND_STATUS_CODE = 404;
-
 // src/sdk/Utils.ts
 import { Address as Address5, beginCell as beginCell5, storeMessage, storeStateInit } from "@ton/ton";
-import { getCreate2Address, keccak256, solidityPacked } from "ethers";
+import { getCreate2Address, keccak256 as keccak2562, solidityPacked } from "ethers";
 import { sha256_sync } from "ton-crypto";
 
-// src/structs/Struct.ts
-var SimplifiedStatuses = /* @__PURE__ */ ((SimplifiedStatuses2) => {
-  SimplifiedStatuses2["PENDING"] = "PENDING";
-  SimplifiedStatuses2["FAILED"] = "FAILED";
-  SimplifiedStatuses2["SUCCESSFUL"] = "SUCCESSFUL";
-  SimplifiedStatuses2["OPERATION_ID_NOT_FOUND"] = "OPERATION_ID_NOT_FOUND";
-  return SimplifiedStatuses2;
-})(SimplifiedStatuses || {});
-var Network = /* @__PURE__ */ ((Network2) => {
-  Network2["TESTNET"] = "testnet";
-  Network2["MAINNET"] = "mainnet";
-  Network2["DEV"] = "dev";
-  return Network2;
-})(Network || {});
-var BlockchainType = /* @__PURE__ */ ((BlockchainType2) => {
-  BlockchainType2["TAC"] = "TAC";
-  BlockchainType2["TON"] = "TON";
-  return BlockchainType2;
-})(BlockchainType || {});
-var CurrencyType = /* @__PURE__ */ ((CurrencyType2) => {
-  CurrencyType2["TAC"] = "TAC";
-  CurrencyType2["TON"] = "TON";
-  return CurrencyType2;
-})(CurrencyType || {});
-var OperationType = /* @__PURE__ */ ((OperationType2) => {
-  OperationType2["PENDING"] = "PENDING";
-  OperationType2["TON_TAC_TON"] = "TON-TAC-TON";
-  OperationType2["ROLLBACK"] = "ROLLBACK";
-  OperationType2["TON_TAC"] = "TON-TAC";
-  OperationType2["TAC_TON"] = "TAC-TON";
-  OperationType2["UNKNOWN"] = "UNKNOWN";
-  return OperationType2;
-})(OperationType || {});
-var OperationExecutionStatus = /* @__PURE__ */ ((OperationExecutionStatus2) => {
-  OperationExecutionStatus2["SUCCESS"] = "success";
-  OperationExecutionStatus2["FAILED"] = "failed";
-  return OperationExecutionStatus2;
-})(OperationExecutionStatus || {});
-var AssetType = /* @__PURE__ */ ((AssetType2) => {
-  AssetType2["NFT"] = "NFT";
-  AssetType2["FT"] = "FT";
-  return AssetType2;
-})(AssetType || {});
-var NFTAddressType = /* @__PURE__ */ ((NFTAddressType2) => {
-  NFTAddressType2["ITEM"] = "ITEM";
-  NFTAddressType2["COLLECTION"] = "COLLECTION";
-  return NFTAddressType2;
-})(NFTAddressType || {});
-var StageName = /* @__PURE__ */ ((StageName2) => {
-  StageName2["COLLECTED_IN_TAC"] = "collectedInTAC";
-  StageName2["INCLUDED_IN_TAC_CONSENSUS"] = "includedInTACConsensus";
-  StageName2["EXECUTED_IN_TAC"] = "executedInTAC";
-  StageName2["COLLECTED_IN_TON"] = "collectedInTON";
-  StageName2["INCLUDED_IN_TON_CONSENSUS"] = "includedInTONConsensus";
-  StageName2["EXECUTED_IN_TON"] = "executedInTON";
-  return StageName2;
-})(StageName || {});
-var TokenSymbol = /* @__PURE__ */ ((TokenSymbol2) => {
-  TokenSymbol2["TAC_SYMBOL"] = "TAC";
-  TokenSymbol2["TON_SYMBOL"] = "TON";
-  return TokenSymbol2;
-})(TokenSymbol || {});
-var defaultWaitOptions = {
-  timeout: DEFAULT_WAIT_TIMEOUT_MS,
-  maxAttempts: DEFAULT_WAIT_MAX_ATTEMPTS,
-  delay: DEFAULT_WAIT_DELAY_MS
-};
-var Origin = /* @__PURE__ */ ((Origin2) => {
-  Origin2["TON"] = "TON";
-  Origin2["TAC"] = "TAC";
-  return Origin2;
-})(Origin || {});
-var AssetFeeMode = /* @__PURE__ */ ((AssetFeeMode2) => {
-  AssetFeeMode2["TAC_ORIGINAL"] = "TAC_ORIGINAL";
-  AssetFeeMode2["LEGACY"] = "LEGACY";
-  AssetFeeMode2["DYNAMIC"] = "DYNAMIC";
-  return AssetFeeMode2;
-})(AssetFeeMode || {});
-var TransactionTreeDirection = /* @__PURE__ */ ((TransactionTreeDirection2) => {
-  TransactionTreeDirection2["FORWARD"] = "forward";
-  TransactionTreeDirection2["BACKWARD"] = "backward";
-  TransactionTreeDirection2["BOTH"] = "both";
-  return TransactionTreeDirection2;
-})(TransactionTreeDirection || {});
-
 // src/assets/AssetCache.ts
 var AssetCache = class {
   /**
@@ -498,8 +1260,8 @@ var AssetCache = class {
 AssetCache.cache = /* @__PURE__ */ new WeakMap();
 
 // src/assets/FT.ts
-import { Address as Address2, beginCell as beginCell2, Cell as Cell2 } from "@ton/ton";
-import { Contract, isAddress as isEthereumAddress2 } from "ethers";
+import { Address as Address2, beginCell as beginCell2, Cell as Cell2, ComputeError } from "@ton/ton";
+import { Contract as Contract5, isAddress as isEthereumAddress2 } from "ethers";
 
 // src/sdk/Validator.ts
 import { Address } from "@ton/ton";
@@ -820,11 +1582,9 @@ var FT = class _FT {
     const result = await this.getOriginAndData(configuration, address3);
     return result.origin;
   }
-  static async getOriginAndData(configuration, address3) {
+  static async getOriginAndData(configuration, address3, contractState) {
     const { jettonMinterCode, crossChainLayerAddress, jettonWalletCode } = configuration.TONParams;
-    const { code: thisCodeBOC } = await configuration.TONParams.contractOpener.getContractState(
-      Address2.parse(address3)
-    );
+    const { code: thisCodeBOC } = contractState ?? await configuration.TONParams.contractOpener.getContractState(Address2.parse(address3));
     if (!thisCodeBOC) {
       throw emptyContractError;
     }
@@ -852,7 +1612,7 @@ var FT = class _FT {
     const fromTVM = await configuration.TACParams.tokenUtils["exists(address)"](address3);
     if (fromTVM) {
       const cclErc20Abi = configuration.artifacts.tac.compilationArtifacts.ICrossChainLayerERC20.abi;
-      const erc20Token = new Contract(address3, cclErc20Abi, configuration.TACParams.provider);
+      const erc20Token = new Contract5(address3, cclErc20Abi, configuration.TACParams.provider);
       const info = await erc20Token.getInfo();
       return info.tvmAddress;
     }
@@ -901,7 +1661,7 @@ var FT = class _FT {
       return TAC_DECIMALS;
     }
     const erc20TokenAbi = configuration.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi;
-    const erc20Token = new Contract(
+    const erc20Token = new Contract5(
       evmAddress,
       erc20TokenAbi,
       configuration.TACParams.provider
@@ -910,12 +1670,13 @@ var FT = class _FT {
   }
   static async fromAddress(configuration, address3) {
     const tvmAddress = isEthereumAddress2(address3) ? await this.getTVMAddress(configuration, address3) : address3;
+    const contractState = await configuration.TONParams.contractOpener.getContractState(Address2.parse(tvmAddress));
     const {
       origin,
       jettonMinter,
       evmAddress: cachedEvmAddress,
       jettonData
-    } = await this.getOriginAndData(configuration, tvmAddress).catch((e) => {
+    } = await this.getOriginAndData(configuration, tvmAddress, contractState).catch((e) => {
       if (e instanceof ContractError) {
         const jettonMinter2 = configuration.TONParams.contractOpener.open(
           configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(Address2.parse(tvmAddress))
@@ -946,7 +1707,9 @@ var FT = class _FT {
     if (finalEvmAddress || isEthereumAddress2(address3)) {
       token._evmAddress = finalEvmAddress || address3;
     }
-    await token.refreshDisplayMultiplier();
+    if (contractState.state !== "uninitialized") {
+      await token.refreshDisplayMultiplier();
+    }
     return token;
   }
   get rawAmount() {
@@ -958,6 +1721,7 @@ var FT = class _FT {
     ft._evmAddress = this._evmAddress;
     ft._displayMultiplierNumerator = this._displayMultiplierNumerator;
     ft._displayMultiplierDenominator = this._displayMultiplierDenominator;
+    ft._hasDisplayMultiplier = this._hasDisplayMultiplier;
     ft._displayMultiplierFetchedAt = this._displayMultiplierFetchedAt;
     ft._displayMultiplierCacheDuration = this._displayMultiplierCacheDuration;
     return ft;
@@ -995,17 +1759,26 @@ var FT = class _FT {
   async getDecimals() {
     return this._decimals;
   }
-  async refreshDisplayMultiplier() {
+  async getDisplayMultiplier() {
     try {
       const multiplier = await this._jettonMinter.getDisplayMultiplier();
-      this._displayMultiplierNumerator = multiplier.numerator;
-      this._displayMultiplierDenominator = multiplier.denominator;
-      this._displayMultiplierFetchedAt = Date.now();
-    } catch {
-      this._displayMultiplierNumerator = 1n;
-      this._displayMultiplierDenominator = 1n;
-      this._displayMultiplierFetchedAt = Date.now();
+      return { hasDisplayMultiplier: true, ...multiplier };
+    } catch (error) {
+      if (this._hasDisplayMultiplier || !(error instanceof ComputeError) || error.exitCode !== 11) {
+        throw error;
+      }
+      return { hasDisplayMultiplier: false, numerator: 1n, denominator: 1n };
+    }
+  }
+  async refreshDisplayMultiplier() {
+    if (this._hasDisplayMultiplier === false) {
+      return;
     }
+    const multiplier = await this.getDisplayMultiplier();
+    this._hasDisplayMultiplier = multiplier.hasDisplayMultiplier;
+    this._displayMultiplierNumerator = multiplier.numerator;
+    this._displayMultiplierDenominator = multiplier.denominator;
+    this._displayMultiplierFetchedAt = Date.now();
   }
   async ensureFreshDisplayMultiplier() {
     const age = Date.now() - this._displayMultiplierFetchedAt;
@@ -1092,11 +1865,11 @@ var FT = class _FT {
     return BigInt(await wallet.getJettonBalance());
   }
   async getUserBalanceExtended(userAddress) {
-    await this.ensureFreshDisplayMultiplier();
     const masterState = await this._configuration.TONParams.contractOpener.getContractState(this._tvmAddress);
     if (masterState.state !== "active") {
       return { exists: false };
     }
+    await this.ensureFreshDisplayMultiplier();
     const wallet = await this.getWallet(userAddress);
     const rawAmount = await wallet.getJettonBalance();
     const decimals = await this.getDecimals();
@@ -1129,7 +1902,7 @@ var FT = class _FT {
     if (evmAddress === nativeTACAddress) {
       return this._configuration.TACParams.provider.getBalance(userAddress);
     }
-    const erc20Token = new Contract(
+    const erc20Token = new Contract5(
       evmAddress,
       this._configuration.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi,
       this._configuration.TACParams.provider
@@ -1164,7 +1937,7 @@ var FT = class _FT {
 
 // src/assets/NFT.ts
 import { Address as Address3, address, beginCell as beginCell3, Cell as Cell3, fromNano } from "@ton/ton";
-import { Contract as Contract2, isAddress as isEthereumAddress3 } from "ethers";
+import { Contract as Contract6, isAddress as isEthereumAddress3 } from "ethers";
 var NFT = class _NFT {
   constructor(nftAddress, origin, configuration, feeMode = _NFT.resolveFeeMode(origin)) {
     this.type = "NFT" /* NFT */;
@@ -1278,7 +2051,7 @@ var NFT = class _NFT {
     const exists = await configuration.TACParams.tokenUtils["exists(address)"](collectionAddress);
     if (exists) {
       const cclErc721TokenAbi = configuration.artifacts.tac.compilationArtifacts.ICrossChainLayerERC721.abi;
-      const cclErc721Token = new Contract2(
+      const cclErc721Token = new Contract6(
         collectionAddress,
         cclErc721TokenAbi,
         configuration.TACParams.provider
@@ -1411,7 +2184,7 @@ var NFT = class _NFT {
       return await this.isOwnedBy(userAddress) ? 1n : 0n;
     }
     Validator.validateEVMAddress(userAddress);
-    const nft = new Contract2(
+    const nft = new Contract6(
       await this.getEVMAddress(),
       this._configuration.artifacts.tac.compilationArtifacts.IERC721.abi,
       this._configuration.TACParams.provider
@@ -1508,7 +2281,7 @@ var TAC = class _TAC {
 
 // src/assets/TON.ts
 import { Address as Address4, beginCell as beginCell4 } from "@ton/ton";
-import { Contract as Contract3 } from "ethers";
+import { Contract as Contract7 } from "ethers";
 var TON = class _TON {
   constructor(config) {
     this.type = "FT" /* FT */;
@@ -1595,7 +2368,7 @@ var TON = class _TON {
       return this.getUserBalance(userAddress);
     }
     Validator.validateEVMAddress(userAddress);
-    const token = new Contract3(
+    const token = new Contract7(
       await this.getEVMAddress(),
       this._config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi,
       this._config.TACParams.provider
@@ -2479,7 +3252,16 @@ var BaseContractOpener = class {
 };
 
 // src/adapters/LiteClientOpener.ts
-import { beginCell as beginCell7, Cell as Cell6, loadTransaction } from "@ton/ton";
+import {
+  beginCell as beginCell7,
+  Cell as Cell6,
+  ComputeError as ComputeError2,
+  loadTransaction,
+  openContract,
+  parseTuple,
+  serializeTuple,
+  TupleReader
+} from "@ton/ton";
 import { LiteClient, LiteRoundRobinEngine, LiteSingleEngine } from "@tonappchain/ton-lite-client";
 function intToIP(int) {
   const part1 = int & 255;
@@ -2518,7 +3300,23 @@ var LiteClientOpener = class _LiteClientOpener extends BaseContractOpener {
     return new _LiteClientOpener(client, engine, logger, engines);
   }
   open(contract) {
-    return this.client.open(contract);
+    return openContract(contract, ({ address: address3, init }) => ({
+      ...this.client.provider(address3, init),
+      open: (src) => this.open(src),
+      get: async (name, args) => {
+        const block = await this.client.getMasterchainInfo();
+        const result = await this.client.runMethod(
+          address3,
+          name.toString(),
+          serializeTuple(args).toBoc({ idx: false, crc32: false }),
+          block.last
+        );
+        if (result.exitCode !== 0 && result.exitCode !== 1) {
+          throw new ComputeError2(`Exit code: ${result.exitCode}`, result.exitCode);
+        }
+        return { stack: new TupleReader(result.result ? parseTuple(Cell6.fromBase64(result.result)) : []) };
+      }
+    }));
   }
   disableReconnect(singleEngine) {
     const engine = singleEngine;
@@ -2790,6 +3588,8 @@ import { Address as Address11 } from "@ton/ton";
 import { getHttpEndpoint as getHttpEndpoint2 } from "@orbs-network/ton-access";
 import {
   beginCell as beginCell8,
+  ComputeError as ComputeError4,
+  openContract as openContract3,
   storeMessage as storeMessage3,
   TonClient,
   TonClient4 as TonClient42
@@ -2797,7 +3597,7 @@ import {
 
 // src/adapters/TonClient4Opener.ts
 import { getHttpV4Endpoint as getHttpV4Endpoint2 } from "@orbs-network/ton-access";
-import { TonClient4 } from "@ton/ton";
+import { ComputeError as ComputeError3, openContract as openContract2, TonClient4 } from "@ton/ton";
 var TonClient4Opener = class _TonClient4Opener extends BaseContractOpener {
   constructor(client4, logger) {
     super(logger);
@@ -2808,7 +3608,21 @@ var TonClient4Opener = class _TonClient4Opener extends BaseContractOpener {
     return new _TonClient4Opener(client4, logger);
   }
   open(contract) {
-    return this.client4.open(contract);
+    return openContract2(contract, ({ address: address3, init }) => ({
+      ...this.client4.provider(address3, init),
+      open: (src) => this.open(src),
+      get: async (name, args) => {
+        if (typeof name !== "string") {
+          throw new Error("Method name must be a string for TonClient4 provider");
+        }
+        const block = await this.client4.getLastBlock();
+        const result = await this.client4.runMethod(block.last.seqno, address3, name, args);
+        if (result.exitCode !== 0 && result.exitCode !== 1) {
+          throw new ComputeError3(`Exit code: ${result.exitCode}`, result.exitCode);
+        }
+        return { stack: result.reader };
+      }
+    }));
   }
   async getContractState(address3) {
     const latestBlock = await this.client4.getLastBlock();
@@ -2884,7 +3698,23 @@ var TonClientOpener = class _TonClientOpener extends BaseContractOpener {
     return new _TonClientOpener(client, logger);
   }
   open(contract) {
-    return this.client.open(contract);
+    return openContract3(contract, ({ address: address3, init }) => ({
+      ...this.client.provider(address3, init),
+      open: (src) => this.open(src),
+      get: async (name, args) => {
+        if (typeof name !== "string") {
+          throw new Error("Method name must be a string for TonClient provider");
+        }
+        const result = await this.client.runMethodWithError(address3, name, args);
+        if (result.exit_code !== 0 && result.exit_code !== 1) {
+          throw new ComputeError4(
+            `Unable to execute get method. Got exit_code: ${result.exit_code}`,
+            result.exit_code
+          );
+        }
+        return { stack: result.stack };
+      }
+    }));
   }
   async getContractState(address3) {
     return this.client.getContractState(address3);
@@ -3399,13 +4229,30 @@ async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetr
 }
 
 // src/adapters/SandboxOpener.ts
+import { ComputeError as ComputeError5 } from "@ton/ton";
 var SandboxOpener = class extends BaseContractOpener {
   constructor(blockchain) {
     super();
     this.blockchain = blockchain;
   }
   open(contract) {
-    return this.blockchain.openContract(contract);
+    return new Proxy(this.blockchain.openContract(contract), {
+      get: (target, prop) => {
+        const value = Reflect.get(target, prop);
+        if (typeof prop !== "string" || !prop.startsWith("get") || typeof value !== "function") return value;
+        return (...args) => {
+          const result = value.apply(target, args);
+          if (!(result instanceof Promise)) return result;
+          return result.catch((error) => {
+            if (error instanceof Error && "exitCode" in error && typeof error.exitCode === "number") {
+              const { vmLogs, debugLogs } = error;
+              throw new ComputeError5(error.message, error.exitCode, { logs: vmLogs, debugLogs });
+            }
+            throw error;
+          });
+        };
+      }
+    });
   }
   async getContractState(address3) {
     const state = await this.blockchain.provider(address3).getState();
@@ -3542,7 +4389,7 @@ var AbiHandler = class {
 };
 
 // src/agnosticSdk/DebugHelpers.ts
-import { AbiCoder as AbiCoder2, formatEther } from "ethers";
+import { AbiCoder as AbiCoder4, formatEther } from "ethers";
 
 // src/agnosticSdk/AgnosticStructs.ts
 var AgnosticStructs_exports = {};
@@ -3589,14 +4436,14 @@ var DebugHelpers = class {
     try {
       switch (hook.hookType) {
         case 0 /* Custom */:
-          return AbiCoder2.defaultAbiCoder().decode(
+          return AbiCoder4.defaultAbiCoder().decode(
             ["tuple(bool,address,uint256,bytes,bytes)"],
             hook.hookData
           )[0];
         case 1 /* FullBalanceApprove */:
-          return AbiCoder2.defaultAbiCoder().decode(["tuple(address,address,bool)"], hook.hookData)[0];
+          return AbiCoder4.defaultAbiCoder().decode(["tuple(address,address,bool)"], hook.hookData)[0];
         case 2 /* FullBalanceTransfer */:
-          return AbiCoder2.defaultAbiCoder().decode(["tuple(address,address,bool)"], hook.hookData)[0];
+          return AbiCoder4.defaultAbiCoder().decode(["tuple(address,address,bool)"], hook.hookData)[0];
         default:
           throw new Error(`Unknown hook type: ${hook.hookType}`);
       }
@@ -3816,7 +4663,7 @@ ${stepNumber}. ${this._describeHook(hook, contractInterfaces)}`);
    * @returns The encoded zap call that can be used as calldata in tac sdk
    */
   encodeZapCall(zapCall) {
-    return AbiCoder2.defaultAbiCoder().encode(
+    return AbiCoder4.defaultAbiCoder().encode(
       [
         "tuple(tuple(uint8,bytes)[],tuple(address[],tuple(address,uint256,uint256)[],bool))"
       ],
@@ -3835,7 +4682,7 @@ ${stepNumber}. ${this._describeHook(hook, contractInterfaces)}`);
 };
 
 // src/agnosticSdk/HooksHandler.ts
-import { AbiCoder as AbiCoder3, getAddress } from "ethers";
+import { AbiCoder as AbiCoder5, getAddress } from "ethers";
 var HooksHandler = class {
   /**
    * Create a custom hook with optional dynamic value replacement
@@ -3855,11 +4702,11 @@ var HooksHandler = class {
     let improvedMissionInfo = "0x";
     if (dynamicReplacements && dynamicReplacements.length > 0) {
       const replacement = dynamicReplacements[0];
-      const replacementData = AbiCoder3.defaultAbiCoder().encode(
+      const replacementData = AbiCoder5.defaultAbiCoder().encode(
         ["tuple(uint16,uint16,address,address)"],
         [[replacement.position, replacement.len, replacement.token, replacement.balanceAddress]]
       );
-      improvedMissionInfo = AbiCoder3.defaultAbiCoder().encode(
+      improvedMissionInfo = AbiCoder5.defaultAbiCoder().encode(
         ["uint8", "bytes"],
         [0 /* Amount */, replacementData]
       );
@@ -3872,7 +4719,7 @@ var HooksHandler = class {
       data,
       improvedMissionInfo
     };
-    const encodedHookData = AbiCoder3.defaultAbiCoder().encode(
+    const encodedHookData = AbiCoder5.defaultAbiCoder().encode(
       ["tuple(bool,address,uint256,bytes,bytes)"],
       [
         [
@@ -3902,7 +4749,7 @@ var HooksHandler = class {
       to,
       isFromSAPerspective
     };
-    const encodedHookData = AbiCoder3.defaultAbiCoder().encode(
+    const encodedHookData = AbiCoder5.defaultAbiCoder().encode(
       ["tuple(address,address,bool)"],
       [[approveHookData.token, approveHookData.to, approveHookData.isFromSAPerspective]]
     );
@@ -3924,7 +4771,7 @@ var HooksHandler = class {
       to,
       isFromSAPerspective
     };
-    const encodedHookData = AbiCoder3.defaultAbiCoder().encode(
+    const encodedHookData = AbiCoder5.defaultAbiCoder().encode(
       ["tuple(address,address,bool)"],
       [[transferHookData.token, transferHookData.to, transferHookData.isFromSAPerspective]]
     );
@@ -4381,23 +5228,9 @@ var AgnosticProxySDK = class {
   }
 };
 
-// src/sdk/Artifacts.ts
-function getArtifacts(network) {
-  switch (network) {
-    case "mainnet" /* MAINNET */:
-      return mainnet_exports;
-    case "testnet" /* TESTNET */:
-      return testnet_exports;
-    case "dev" /* DEV */:
-      return dev_exports;
-    default:
-      throw new Error(`Unsupported network: ${network}`);
-  }
-}
-
 // src/sdk/Configuration.ts
-import { Address as Address13, Dictionary as Dictionary2, loadConfigParamsAsSlice, parseFullConfig } from "@ton/ton";
-import { AbiCoder as AbiCoder4, Contract as Contract9, getDefaultProvider, id, keccak256 as keccak2562, toUtf8Bytes } from "ethers";
+import { Address as Address14, Dictionary as Dictionary2, loadConfigParamsAsSlice, parseFullConfig } from "@ton/ton";
+import { AbiCoder as AbiCoder6, Contract as Contract14, getDefaultProvider as getDefaultProvider2, id, keccak256 as keccak2563, toUtf8Bytes } from "ethers";
 
 // src/sdk/Fees.ts
 var DEFAULT_CONTRACT_FEE_USAGE_PARAMS = {
@@ -4671,7 +5504,7 @@ var Configuration = class _Configuration {
       contractOpener.setLogger(logger);
     }
     const settings = contractOpener.open(
-      artifacts.ton.wrappers.Settings.createFromAddress(Address13.parse(settingsAddress))
+      artifacts.ton.wrappers.Settings.createFromAddress(Address14.parse(settingsAddress))
     );
     const allSettingsSlice = (await settings.getAll()).beginParse();
     const allSettings = allSettingsSlice.loadDictDirect(Dictionary2.Keys.BigUint(256), Dictionary2.Values.Cell());
@@ -4726,13 +5559,13 @@ var Configuration = class _Configuration {
       }
       saFactoryAddress = TACParams2.saFactoryAddress;
     } else {
-      provider = TACParams2?.provider ?? getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
+      provider = TACParams2?.provider ?? getDefaultProvider2(artifacts.TAC_RPC_ENDPOINT);
       settingsAddress = TACParams2?.settingsAddress ?? artifacts.TAC_SETTINGS_ADDRESS;
       saFactoryAddress = TACParams2?.saFactoryAddress ?? artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS;
     }
     Validator.validateEVMAddress(settingsAddress);
     const settingsAbi = artifacts.tac.compilationArtifacts.ISettings.abi;
-    const settings = new Contract9(settingsAddress, settingsAbi, provider);
+    const settings = new Contract14(settingsAddress, settingsAbi, provider);
     const loaded = await this.loadTACSettingsViaMulticall(network, provider, settingsAddress);
     let crossChainLayerAddress;
     let tokenUtilsAddress;
@@ -4744,21 +5577,21 @@ var Configuration = class _Configuration {
       trustedTACExecutors = loaded.trustedTACExecutors;
       trustedTONExecutors = loaded.trustedTONExecutors;
     } else {
-      crossChainLayerAddress = await settings.getAddressSetting(keccak2562(toUtf8Bytes("CrossChainLayerAddress")));
-      tokenUtilsAddress = await settings.getAddressSetting(keccak2562(toUtf8Bytes("TokenUtilsAddress")));
+      crossChainLayerAddress = await settings.getAddressSetting(keccak2563(toUtf8Bytes("CrossChainLayerAddress")));
+      tokenUtilsAddress = await settings.getAddressSetting(keccak2563(toUtf8Bytes("TokenUtilsAddress")));
       trustedTACExecutors = await settings.getTrustedEVMExecutors();
       trustedTONExecutors = await settings.getTrustedTVMExecutors();
     }
     const crossChainLayerAbi = artifacts.tac.compilationArtifacts.ICrossChainLayer.abi;
-    const crossChainLayer = new Contract9(
+    const crossChainLayer = new Contract14(
       crossChainLayerAddress,
       crossChainLayerAbi,
       provider
     );
     const tokenUtilsAbi = artifacts.tac.compilationArtifacts.ITokenUtils.abi;
-    const tokenUtils = new Contract9(tokenUtilsAddress, tokenUtilsAbi, provider);
+    const tokenUtils = new Contract14(tokenUtilsAddress, tokenUtilsAbi, provider);
     const TacSAFactoryAbi = artifacts.tac.compilationArtifacts.ISAFactory.abi;
-    const smartAccountFactory = new Contract9(
+    const smartAccountFactory = new Contract14(
       saFactoryAddress,
       TacSAFactoryAbi,
       provider
@@ -4771,7 +5604,7 @@ var Configuration = class _Configuration {
       crossChainLayer,
       trustedTACExecutors,
       trustedTONExecutors,
-      abiCoder: new AbiCoder4()
+      abiCoder: new AbiCoder6()
     };
   }
   static async loadTACSettingsViaMulticall(network, provider, settingsAddress) {
@@ -4783,14 +5616,14 @@ var Configuration = class _Configuration {
     const multicallAbi = artifacts.tac.multicall.MULTICALL_ABI_ETHERS;
     try {
       Validator.validateEVMAddress(multicallAddress);
-      const multicall = new Contract9(multicallAddress, multicallAbi, provider);
-      const abiCoder = new AbiCoder4();
+      const multicall = new Contract14(multicallAddress, multicallAbi, provider);
+      const abiCoder3 = new AbiCoder6();
       const selectorGetAddressSetting = id("getAddressSetting(bytes32)").slice(0, 10);
       const selectorGetTrustedEVMExecutors = id("getTrustedEVMExecutors()").slice(0, 10);
       const selectorGetTrustedTVMExecutors = id("getTrustedTVMExecutors()").slice(0, 10);
-      const crossChainLayerKey = keccak2562(toUtf8Bytes("CrossChainLayerAddress"));
-      const tokenUtilsKey = keccak2562(toUtf8Bytes("TokenUtilsAddress"));
-      const encodeGetAddressSetting = (key) => selectorGetAddressSetting + abiCoder.encode(["bytes32"], [key]).slice(2);
+      const crossChainLayerKey = keccak2563(toUtf8Bytes("CrossChainLayerAddress"));
+      const tokenUtilsKey = keccak2563(toUtf8Bytes("TokenUtilsAddress"));
+      const encodeGetAddressSetting = (key) => selectorGetAddressSetting + abiCoder3.encode(["bytes32"], [key]).slice(2);
       const calls = [
         { target: settingsAddress, allowFailure: false, callData: encodeGetAddressSetting(crossChainLayerKey) },
         { target: settingsAddress, allowFailure: false, callData: encodeGetAddressSetting(tokenUtilsKey) },
@@ -4800,10 +5633,10 @@ var Configuration = class _Configuration {
       const results = await multicall.aggregate3.staticCall(calls);
       if (results.some((result) => !result.success)) return null;
       return {
-        crossChainLayerAddress: abiCoder.decode(["address"], results[0].returnData)[0],
-        tokenUtilsAddress: abiCoder.decode(["address"], results[1].returnData)[0],
-        trustedTACExecutors: abiCoder.decode(["address[]"], results[2].returnData)[0],
-        trustedTONExecutors: abiCoder.decode(["string[]"], results[3].returnData)[0]
+        crossChainLayerAddress: abiCoder3.decode(["address"], results[0].returnData)[0],
+        tokenUtilsAddress: abiCoder3.decode(["address"], results[1].returnData)[0],
+        trustedTACExecutors: abiCoder3.decode(["address[]"], results[2].returnData)[0],
+        trustedTONExecutors: abiCoder3.decode(["string[]"], results[3].returnData)[0]
       };
     } catch {
       return null;
@@ -4825,7 +5658,7 @@ var Configuration = class _Configuration {
     return this.TONParams.contractOpener.closeConnections?.();
   }
   async isContractDeployedOnTVM(address3) {
-    return (await this.TONParams.contractOpener.getContractState(Address13.parse(address3))).state === "active";
+    return (await this.TONParams.contractOpener.getContractState(Address14.parse(address3))).state === "active";
   }
   static async retrieveTONFeesParams(contractOpener) {
     try {
@@ -5156,7 +5989,7 @@ var LiteSequencerClient = class {
 };
 
 // src/sdk/OperationTracker.ts
-import { Address as Address14, Cell as Cell7, loadMessage } from "@ton/ton";
+import { Address as Address15, Cell as Cell7, loadMessage } from "@ton/ton";
 var DefaultLiteSequencerClientFactory = class {
   createClients(endpoints) {
     return endpoints.map((endpoint) => new LiteSequencerClient(endpoint));
@@ -5227,7 +6060,7 @@ var OperationTracker = class {
     if (message.info.type !== "external-in") {
       throw externalInMessageRequiredError(message.info.type);
     }
-    const destination = Address14.parse(message.info.dest.toString());
+    const destination = Address15.parse(message.info.dest.toString());
     const messageHash = getNormalizedExtMessageHash(message);
     return this.getOperationIdByTonTransaction(
       async () => {
@@ -5557,7 +6390,7 @@ var OperationTracker = class {
 };
 
 // src/sdk/Simulator.ts
-import { Address as Address15, toNano as toNano2 } from "@ton/ton";
+import { Address as Address16, toNano as toNano2 } from "@ton/ton";
 var Simulator = class {
   constructor(config, operationTracker, logger = new NoopLogger()) {
     this.config = config;
@@ -5607,7 +6440,7 @@ var Simulator = class {
     const isRoundTrip = options.isRoundTrip ?? (assets.length !== 0 || simulation.outMessages?.length !== 0);
     const CrossChainLayerC = this.config.artifacts.ton.wrappers.CrossChainLayer;
     const crossChainLayer = this.config.TONParams.contractOpener.open(
-      CrossChainLayerC.createFromAddress(Address15.parse(this.config.TONParams.crossChainLayerAddress))
+      CrossChainLayerC.createFromAddress(Address16.parse(this.config.TONParams.crossChainLayerAddress))
     );
     const fullStateCCL = await crossChainLayer.getFullData();
     const feeParams = {
@@ -6023,7 +6856,7 @@ var TacExplorerClient = class {
 };
 
 // src/sdk/TACTransactionManager.ts
-import { Contract as Contract10 } from "ethers";
+import { Contract as Contract15 } from "ethers";
 var TACTransactionManager = class {
   constructor(config, operationTracker, logger = new NoopLogger()) {
     this.config = config;
@@ -6091,7 +6924,7 @@ var TACTransactionManager = class {
     const hasTransactionParams = Object.keys(transactionParams).length > 0;
     if (asset.type === "FT" /* FT */) {
       this.logger.debug(`Approving FT ${evmAddress} for ${spenderAddress}`);
-      const contract = new Contract10(
+      const contract = new Contract15(
         evmAddress,
         this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi,
         this.config.TACParams.provider
@@ -6100,7 +6933,7 @@ var TACTransactionManager = class {
       await tx.wait();
     } else {
       this.logger.debug(`Approving NFT ${evmAddress} for ${spenderAddress}`);
-      const contract = new Contract10(
+      const contract = new Contract15(
         evmAddress,
         this.config.artifacts.tac.compilationArtifacts.IERC721.abi,
         this.config.TACParams.provider
@@ -6113,14 +6946,14 @@ var TACTransactionManager = class {
   async estimateApprovalGas(asset, signer, spenderAddress, transactionParams = {}) {
     const evmAddress = await asset.getEVMAddress();
     if (asset.type === "FT" /* FT */) {
-      const contract2 = new Contract10(
+      const contract2 = new Contract15(
         evmAddress,
         this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi,
         this.config.TACParams.provider
       );
       return contract2.connect(signer).approve.estimateGas(spenderAddress, asset.rawAmount, transactionParams);
     }
-    const contract = new Contract10(
+    const contract = new Contract15(
       evmAddress,
       this.config.artifacts.tac.compilationArtifacts.IERC721.abi,
       this.config.TACParams.provider
@@ -6291,7 +7124,7 @@ import {
   storeOutList,
   toNano as toNano3
 } from "@ton/ton";
-import { sign } from "ton-crypto";
+import { sign as sign2 } from "ton-crypto";
 
 // src/wrappers/HighloadQueryId.ts
 var HIGHLOAD_QUERY_ID_BIT_NUMBER_SIZE = 10n;
@@ -6436,7 +7269,7 @@ var HighloadWalletV3 = class _HighloadWalletV3 {
     }
     const queryId = opts.queryId instanceof HighloadQueryId ? opts.queryId.getQueryId() : opts.queryId;
     const messageInner = beginCell9().storeUint(opts.subwalletId, 32).storeRef(messageCell).storeUint(opts.mode, 8).storeUint(queryId, 23).storeUint(opts.createdAt, TIMESTAMP_SIZE).storeUint(opts.timeout, TIMEOUT_SIZE).endCell();
-    const externalMessage = beginCell9().storeBuffer(sign(messageInner.hash(), secretKey)).storeRef(messageInner).endCell();
+    const externalMessage = beginCell9().storeBuffer(sign2(messageInner.hash(), secretKey)).storeRef(messageInner).endCell();
     await provider.external(externalMessage);
     return externalMessage.toBoc().toString("base64");
   }
@@ -6698,7 +7531,7 @@ import {
   WalletContractV4,
   WalletContractV5R1
 } from "@ton/ton";
-import { mnemonicToWalletKey } from "ton-crypto";
+import { mnemonicToWalletKey as mnemonicToWalletKey2 } from "ton-crypto";
 
 // src/sender/RawSender.ts
 import { beginCell as beginCell10, external, fromNano as fromNano3, internal as internal2, storeMessage as storeMessage4 } from "@ton/ton";
@@ -6922,7 +7755,7 @@ var SenderFactory = class {
     if (!(params.version in wallets)) {
       throw unknownWalletError(params.version);
     }
-    const keypair = await mnemonicToWalletKey(params.mnemonic.split(" "));
+    const keypair = await mnemonicToWalletKey2(params.mnemonic.split(" "));
     const config = {
       workchain: 0,
       publicKey: keypair.publicKey,
@@ -7605,6 +8438,7 @@ var TonTxFinalizer = class {
   }
 };
 export {
+  AA_NETWORKS,
   AddressError,
   AgnosticProxySDK,
   AgnosticStructs_exports as AgnosticStructs,
@@ -7612,6 +8446,7 @@ export {
   AssetFeeMode,
   AssetType,
   AxiosHttpClient,
+  BaseAccountAPI,
   BaseContractOpener,
   BatchSender,
   BitError,
@@ -7630,6 +8465,7 @@ export {
   HIGHLOAD_QUERY_ID_INVALID_BIT_NUMBER,
   HighloadQueryId,
   HighloadWalletV3,
+  HttpRpcClient,
   KeyError,
   LiteClientOpener,
   LiteSequencerClient,
@@ -7645,6 +8481,7 @@ export {
   OperationTracker,
   OperationType,
   Origin,
+  PaymasterAPI,
   RetryableContractOpener,
   SandboxOpener,
   SenderFactory,
@@ -7658,7 +8495,14 @@ export {
   TIMESTAMP_SIZE,
   TON,
   TONTransactionManager,
+  TacAccountABI,
+  TacAccountAPI,
+  TacAccountFactoryABI,
+  TacAccountSdk,
+  TacERC20PaymasterABI,
+  TacERC20PaymasterAPI,
   TacExplorerClient,
+  TacPaymasterMode,
   TacSdk,
   TokenError,
   TokenSymbol,
@@ -7670,14 +8514,20 @@ export {
   TransactionError,
   TransactionTreeDirection,
   WalletError,
+  aaSignerFromMnemonic,
   allEndpointsFailedError,
   blockGasLimitFetchError,
   buildJettonOffChainMetadata,
   buildJettonOnchainMetadata,
   buildNFTOffChainMetadata,
   buildNFTOnchainMetadata,
+  buildPermitBinding,
+  buildPermitMessage,
+  buildSignedUserOpWithPermit,
+  buildSignedUserOpWithPermitTonConnect,
   createDefaultRetryableOpener,
   defaultWaitOptions,
+  ed25519SignerFromSecretKey,
   emptyArrayError,
   emptyContractError,
   emptySettingError,
@@ -7710,6 +8560,15 @@ export {
   operationIdRequiredForFinalizationError,
   orbsOpener,
   orbsOpener4,
+  packModeByte,
+  packPaymasterAndData,
+  packPermit2InnerSignature,
+  packPermitBoundUserOpSignature,
+  packPermitData,
+  packPermitPaymasterData,
+  packRawEd25519Signature,
+  packTonConnectPermit2InnerSignature,
+  packTonConnectUserOpSignature,
   prefixError,
   printExecutionStagesTable,
   profilingFetchError,