tusdt-sdk 0.1.0

package/dist/chunk-5HS7VSOA.js

@@ -0,0 +1,1844 @@
+import { Contract } from 'dedot/contracts';
+
+// src/contract/tusdt-contract.ts
+
+// src/core/constants.ts
+var U64_MAX = 18446744073709551615n;
+var ZERO_BALANCE = 0n;
+var ZERO_ADDRESS = "0x" + "00".repeat(32);
+
+// src/core/errors.ts
+var TusdtSdkError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TusdtSdkError";
+  }
+};
+var ValidationError = class extends TusdtSdkError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var ContractError = class extends TusdtSdkError {
+  contractErrorType;
+  constructor(message, contractErrorType) {
+    super(message);
+    this.name = "ContractError";
+    this.contractErrorType = contractErrorType;
+  }
+};
+var InsufficientBalanceError = class extends ContractError {
+  constructor(message) {
+    super(
+      message ?? "Insufficient token balance for this operation",
+      "InsufficientBalance"
+    );
+    this.name = "InsufficientBalanceError";
+  }
+};
+var InsufficientAllowanceError = class extends ContractError {
+  constructor(message) {
+    super(
+      message ?? "Insufficient allowance for this transfer",
+      "InsufficientAllowance"
+    );
+    this.name = "InsufficientAllowanceError";
+  }
+};
+var NotControllerError = class extends ContractError {
+  constructor(message) {
+    super(
+      message ?? "Only the controller can perform this operation",
+      "NotController"
+    );
+    this.name = "NotControllerError";
+  }
+};
+var DryRunError = class extends TusdtSdkError {
+  dispatchError;
+  constructor(message, dispatchError) {
+    super(message);
+    this.name = "DryRunError";
+    this.dispatchError = dispatchError;
+  }
+};
+var DispatchError = class extends TusdtSdkError {
+  dispatchError;
+  constructor(message, dispatchError) {
+    super(message);
+    this.name = "DispatchError";
+    this.dispatchError = dispatchError;
+  }
+};
+var ConnectionError = class extends TusdtSdkError {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionError";
+  }
+};
+var TimeoutError = class extends TusdtSdkError {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+function mapContractError(error) {
+  if (typeof error === "string") {
+    switch (error) {
+      case "InsufficientBalance":
+        return new InsufficientBalanceError();
+      case "InsufficientAllowance":
+        return new InsufficientAllowanceError();
+      case "NotController":
+        return new NotControllerError();
+    }
+    if (error.includes("InsufficientBalance"))
+      return new InsufficientBalanceError();
+    if (error.includes("InsufficientAllowance"))
+      return new InsufficientAllowanceError();
+    if (error.includes("NotController")) return new NotControllerError();
+  }
+  if (error && typeof error === "object" && "type" in error) {
+    const variant = error.type;
+    switch (variant) {
+      case "InsufficientBalance":
+        return new InsufficientBalanceError();
+      case "InsufficientAllowance":
+        return new InsufficientAllowanceError();
+      case "NotController":
+        return new NotControllerError();
+    }
+  }
+  return new ContractError(
+    `Contract rejected the call: ${JSON.stringify(error)}`,
+    "Unknown"
+  );
+}
+
+// src/core/validation.ts
+function validateBalance(value) {
+  if (typeof value !== "bigint") {
+    throw new ValidationError(
+      `Balance must be a bigint, received ${typeof value}`
+    );
+  }
+  if (value < 0n) {
+    throw new ValidationError("Balance cannot be negative");
+  }
+  if (value > U64_MAX) {
+    throw new ValidationError(
+      `Balance ${value} exceeds u64 maximum (${U64_MAX})`
+    );
+  }
+}
+function validateAddress(address) {
+  if (typeof address !== "string" || address.length === 0) {
+    throw new ValidationError("Address must be a non-empty string");
+  }
+  if (address.startsWith("0x")) {
+    if (address.length !== 66) {
+      throw new ValidationError(
+        `Invalid hex address length: expected 66 characters, got ${address.length}`
+      );
+    }
+  }
+}
+function validateOverflowSafe(recipientBalance, transferAmount) {
+  if (recipientBalance + transferAmount > U64_MAX) {
+    throw new ValidationError(
+      `Transfer would overflow recipient balance: ${recipientBalance} + ${transferAmount} > u64 max (${U64_MAX})`
+    );
+  }
+}
+function isKeyringPair(signer) {
+  return typeof signer === "object" && signer !== null && "address" in signer && "sign" in signer && typeof signer.sign === "function";
+}
+function getSignerAddress(signer) {
+  return signer.address;
+}
+
+// src/contract/queries.ts
+function accountIdToString(accountId) {
+  if (typeof accountId === "string") return accountId;
+  if (accountId && typeof accountId === "object") {
+    if ("address" in accountId && typeof accountId.address === "function") {
+      return accountId.address();
+    }
+    if ("toString" in accountId) {
+      return accountId.toString();
+    }
+  }
+  return String(accountId);
+}
+async function queryController(contract) {
+  try {
+    const result = await contract.query.controller();
+    return accountIdToString(result.data);
+  } catch (error) {
+    throw new DryRunError(
+      `Failed to query controller: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function queryTotalSupply(contract) {
+  try {
+    const result = await contract.query.totalSupply();
+    return BigInt(result.data);
+  } catch (error) {
+    throw new DryRunError(
+      `Failed to query total_supply: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function queryBalanceOf(contract, owner) {
+  validateAddress(owner);
+  try {
+    const result = await contract.query.balanceOf(owner);
+    return BigInt(result.data);
+  } catch (error) {
+    throw new DryRunError(
+      `Failed to query balance_of: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function queryAllowance(contract, owner, spender) {
+  validateAddress(owner);
+  validateAddress(spender);
+  try {
+    const result = await contract.query.allowance(owner, spender);
+    return BigInt(result.data);
+  } catch (error) {
+    throw new DryRunError(
+      `Failed to query allowance: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+function createDryRunContract(contract, callerAddress) {
+  const innerContract = contract;
+  return new Contract(
+    innerContract.client,
+    innerContract.metadata,
+    innerContract.address,
+    { defaultCaller: callerAddress }
+  );
+}
+async function signAndWait(txCall, signer, options) {
+  const waitFor = options?.waitFor ?? "bestChainBlockIncluded";
+  try {
+    let pendingTx;
+    if (isKeyringPair(signer)) {
+      pendingTx = txCall.signAndSend(signer);
+    } else {
+      pendingTx = txCall.signAndSend(signer.address, { signer: signer.signer });
+    }
+    let result;
+    if (waitFor === "finalized") {
+      result = await pendingTx.untilFinalized();
+    } else {
+      result = await pendingTx.untilBestChainBlockIncluded();
+    }
+    return {
+      events: result.events ?? [],
+      // Dedot's TxStatus is a discriminated union:
+      //   { type: 'BestChainBlockIncluded', value: { blockHash, blockNumber, txIndex } }
+      //   { type: 'Finalized', value: { blockHash, blockNumber, txIndex } }
+      blockHash: result.status?.value?.blockHash?.toString() ?? "",
+      txHash: result.txHash?.toString() ?? ""
+    };
+  } catch (error) {
+    if (error && typeof error === "object") {
+      const errorObj = error;
+      if (errorObj.dispatchError) {
+        throw new DispatchError(
+          `Transaction dispatch failed: ${String(error)}`,
+          errorObj.dispatchError
+        );
+      }
+    }
+    throw error;
+  }
+}
+function extractGasEstimate(rawResult) {
+  const gasRequired = rawResult?.gasRequired;
+  return {
+    refTime: BigInt(gasRequired?.refTime?.toString() ?? "0"),
+    proofSize: BigInt(gasRequired?.proofSize?.toString() ?? "0")
+  };
+}
+function decodeTransferEvents(contract, events, blockHash) {
+  try {
+    const transferEvents = contract.events.Transfer.filter(events);
+    return transferEvents.map((evt) => {
+      const data = evt.data ?? evt;
+      return {
+        from: data.from?.toString() ?? null,
+        to: data.to?.toString() ?? null,
+        value: BigInt(data.value ?? 0),
+        blockHash
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function decodeApprovalEvents(contract, events, blockHash) {
+  try {
+    const approvalEvents = contract.events.Approval.filter(events);
+    return approvalEvents.map((evt) => {
+      const data = evt.data ?? evt;
+      return {
+        owner: data.owner?.toString() ?? "",
+        spender: data.spender?.toString() ?? "",
+        value: BigInt(data.value ?? 0),
+        blockHash
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+async function dryRunMutation(contract, signerAddress, message, args) {
+  const dryRunContract = createDryRunContract(contract, signerAddress);
+  const queryFn = dryRunContract.query[message];
+  if (!queryFn) {
+    throw new DryRunError(`Unknown contract message: ${message}`);
+  }
+  let result;
+  try {
+    result = await queryFn(...args);
+  } catch (error) {
+    throw new DryRunError(
+      `Dry-run failed for ${message}: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+  const data = result.data;
+  if (data && typeof data === "object" && "isErr" in data && data.isErr) {
+    throw mapContractError(data.err);
+  }
+  return {
+    gasEstimate: extractGasEstimate(result.raw),
+    raw: result.raw
+  };
+}
+async function executeTransfer(contract, signer, to, value, options) {
+  const signerAddress = getSignerAddress(signer);
+  validateAddress(to);
+  validateBalance(value);
+  if (value > 0n && signerAddress !== to) {
+    const recipientBalance = await queryBalanceOf(contract, to);
+    validateOverflowSafe(recipientBalance, value);
+  }
+  const { gasEstimate, raw } = await dryRunMutation(
+    contract,
+    signerAddress,
+    "transfer",
+    [to, value]
+  );
+  const txCall = contract.tx.transfer(to, value, {
+    gasLimit: raw.gasRequired
+  });
+  const { events, blockHash, txHash } = await signAndWait(txCall, signer, options);
+  const transfers = decodeTransferEvents(contract, events, blockHash);
+  const approvals = decodeApprovalEvents(contract, events, blockHash);
+  return { blockHash, txHash, gasEstimate, transfers, approvals };
+}
+async function executeApprove(contract, signer, spender, value, options) {
+  const signerAddress = getSignerAddress(signer);
+  validateAddress(spender);
+  validateBalance(value);
+  const { gasEstimate, raw } = await dryRunMutation(
+    contract,
+    signerAddress,
+    "approve",
+    [spender, value]
+  );
+  const txCall = contract.tx.approve(spender, value, {
+    gasLimit: raw.gasRequired
+  });
+  const { events, blockHash, txHash } = await signAndWait(txCall, signer, options);
+  const transfers = decodeTransferEvents(contract, events, blockHash);
+  const approvals = decodeApprovalEvents(contract, events, blockHash);
+  return { blockHash, txHash, gasEstimate, transfers, approvals };
+}
+async function executeTransferFrom(contract, signer, from, to, value, options) {
+  const signerAddress = getSignerAddress(signer);
+  validateAddress(from);
+  validateAddress(to);
+  validateBalance(value);
+  if (value > 0n && from !== to) {
+    const recipientBalance = await queryBalanceOf(contract, to);
+    validateOverflowSafe(recipientBalance, value);
+  }
+  const { gasEstimate, raw } = await dryRunMutation(
+    contract,
+    signerAddress,
+    "transferFrom",
+    [from, to, value]
+  );
+  const txCall = contract.tx.transferFrom(from, to, value, {
+    gasLimit: raw.gasRequired
+  });
+  const { events, blockHash, txHash } = await signAndWait(txCall, signer, options);
+  const transfers = decodeTransferEvents(contract, events, blockHash);
+  const approvals = decodeApprovalEvents(contract, events, blockHash);
+  return { blockHash, txHash, gasEstimate, transfers, approvals };
+}
+
+// src/contract/events.ts
+async function subscribeTransfer(client, contract, callback, options) {
+  const unsub = await client.rpc.chain_subscribeNewHeads(async (header) => {
+    try {
+      const blockHash = header.hash?.toString() ?? header.parentHash?.toString() ?? "";
+      const events = await client.query.system.events.at(blockHash);
+      const transferEvents = contract.events.Transfer.filter(events);
+      for (const evt of transferEvents) {
+        const data = evt.data ?? evt;
+        callback({
+          from: data.from?.toString() ?? null,
+          to: data.to?.toString() ?? null,
+          value: BigInt(data.value ?? 0),
+          blockHash
+        });
+      }
+    } catch (error) {
+      if (options?.onError) {
+        options.onError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  });
+  return typeof unsub === "function" ? unsub : () => {
+  };
+}
+async function subscribeApproval(client, contract, callback, options) {
+  const unsub = await client.rpc.chain_subscribeNewHeads(async (header) => {
+    try {
+      const blockHash = header.hash?.toString() ?? header.parentHash?.toString() ?? "";
+      const events = await client.query.system.events.at(blockHash);
+      const approvalEvents = contract.events.Approval.filter(events);
+      for (const evt of approvalEvents) {
+        const data = evt.data ?? evt;
+        callback({
+          owner: data.owner?.toString() ?? "",
+          spender: data.spender?.toString() ?? "",
+          value: BigInt(data.value ?? 0),
+          blockHash
+        });
+      }
+    } catch (error) {
+      if (options?.onError) {
+        options.onError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  });
+  return typeof unsub === "function" ? unsub : () => {
+  };
+}
+async function subscribeTransferFrom(client, contract, account, callback, options) {
+  return subscribeTransfer(client, contract, (event) => {
+    if (event.from === account) {
+      callback(event);
+    }
+  }, options);
+}
+async function subscribeTransferTo(client, contract, account, callback, options) {
+  return subscribeTransfer(client, contract, (event) => {
+    if (event.to === account) {
+      callback(event);
+    }
+  }, options);
+}
+
+// src/contract/finalized-events.ts
+function parseBlockNumber(raw) {
+  if (typeof raw === "number") return raw;
+  return Number(String(raw ?? 0));
+}
+async function watchFinalizedTransfers(client, contract, callback, options) {
+  const unsub = await client.rpc.chain_subscribeFinalizedHeads(
+    async (header) => {
+      try {
+        const blockHash = header.hash?.toString() ?? header.parentHash?.toString() ?? "";
+        const blockNumber = parseBlockNumber(header.number);
+        const events = await client.query.system.events.at(blockHash);
+        const transferEvents = contract.events.Transfer.filter(events);
+        for (let i = 0; i < transferEvents.length; i++) {
+          const evt = transferEvents[i];
+          const data = evt.data ?? evt;
+          callback({
+            from: data.from?.toString() ?? null,
+            to: data.to?.toString() ?? null,
+            value: BigInt(data.value ?? 0),
+            blockHash,
+            blockNumber,
+            txIndex: i
+          });
+        }
+      } catch (error) {
+        if (options?.onError) {
+          options.onError(
+            error instanceof Error ? error : new Error(String(error))
+          );
+        }
+      }
+    }
+  );
+  return typeof unsub === "function" ? unsub : () => {
+  };
+}
+async function watchFinalizedTransfersTo(client, contract, account, callback, options) {
+  return watchFinalizedTransfers(
+    client,
+    contract,
+    (event) => {
+      if (event.to === account) callback(event);
+    },
+    options
+  );
+}
+
+// src/contract/helpers.ts
+async function safeApprove(contract, signer, spender, newValue, options) {
+  const signerAddress = getSignerAddress(signer);
+  const currentAllowance = await queryAllowance(
+    contract,
+    signerAddress,
+    spender
+  );
+  if (currentAllowance > ZERO_BALANCE && newValue > ZERO_BALANCE) {
+    await executeApprove(contract, signer, spender, ZERO_BALANCE, options);
+  }
+  return executeApprove(contract, signer, spender, newValue, options);
+}
+
+// metadata/tusdt_erc20.json
+var tusdt_erc20_default = {
+  source: {
+    hash: "0x5ad2ab290b4330dc0f70638c4f3d639b15e0c54808109021bb9dc80d0b914dbf",
+    language: "ink! 5.1.1",
+    compiler: "rustc 1.93.0",
+    build_info: {
+      build_mode: "Debug",
+      cargo_contract_version: "5.0.3",
+      rust_toolchain: "stable-x86_64-unknown-linux-gnu",
+      wasm_opt_settings: {
+        keep_debug_symbols: false,
+        optimization_passes: "Z"
+      }
+    }
+  },
+  contract: {
+    name: "tusdt-erc20",
+    version: "0.1.0",
+    authors: [
+      "tensorusd admin@tensorusd.com"
+    ]
+  },
+  image: null,
+  spec: {
+    constructors: [
+      {
+        args: [
+          {
+            label: "controller",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          "Initializes the token contract with the specified controller account."
+        ],
+        label: "new",
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink_primitives",
+            "ConstructorResult"
+          ],
+          type: 14
+        },
+        selector: "0x9bae9d5e"
+      }
+    ],
+    docs: [],
+    environment: {
+      accountId: {
+        displayName: [
+          "AccountId"
+        ],
+        type: 0
+      },
+      balance: {
+        displayName: [
+          "Balance"
+        ],
+        type: 3
+      },
+      blockNumber: {
+        displayName: [
+          "BlockNumber"
+        ],
+        type: 23
+      },
+      chainExtension: {
+        displayName: [
+          "ChainExtension"
+        ],
+        type: 24
+      },
+      hash: {
+        displayName: [
+          "Hash"
+        ],
+        type: 22
+      },
+      maxEventTopics: 4,
+      staticBufferSize: 16384,
+      timestamp: {
+        displayName: [
+          "Timestamp"
+        ],
+        type: 3
+      }
+    },
+    events: [
+      {
+        args: [
+          {
+            docs: [],
+            indexed: true,
+            label: "owner",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            docs: [],
+            indexed: true,
+            label: "spender",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            docs: [],
+            indexed: false,
+            label: "value",
+            type: {
+              displayName: [
+                "Balance"
+              ],
+              type: 3
+            }
+          }
+        ],
+        docs: [],
+        label: "Approval",
+        module_path: "tusdt_erc20::tusdt",
+        signature_topic: "0x1a35e726f5feffda199144f6097b2ba23713e549bfcbe090c0981e3bcdfbcc1d"
+      },
+      {
+        args: [
+          {
+            docs: [],
+            indexed: true,
+            label: "from",
+            type: {
+              displayName: [
+                "Option"
+              ],
+              type: 21
+            }
+          },
+          {
+            docs: [],
+            indexed: true,
+            label: "to",
+            type: {
+              displayName: [
+                "Option"
+              ],
+              type: 21
+            }
+          },
+          {
+            docs: [],
+            indexed: false,
+            label: "value",
+            type: {
+              displayName: [
+                "Balance"
+              ],
+              type: 3
+            }
+          }
+        ],
+        docs: [],
+        label: "Transfer",
+        module_path: "tusdt_erc20::tusdt",
+        signature_topic: "0xb5b61a3e6a21a16be4f044b517c28ac692492f73c5bfd3f60178ad98c767f4cb"
+      }
+    ],
+    lang_error: {
+      displayName: [
+        "ink",
+        "LangError"
+      ],
+      type: 15
+    },
+    messages: [
+      {
+        args: [],
+        default: false,
+        docs: [
+          " Returns the controller account ID."
+        ],
+        label: "controller",
+        mutates: false,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 16
+        },
+        selector: "0x7b3bfba9"
+      },
+      {
+        args: [],
+        default: false,
+        docs: [
+          " Returns the total supply of tokens in circulation."
+        ],
+        label: "total_supply",
+        mutates: false,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 17
+        },
+        selector: "0xdb6375a8"
+      },
+      {
+        args: [
+          {
+            label: "owner",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          " Returns the token balance of an account."
+        ],
+        label: "balance_of",
+        mutates: false,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 17
+        },
+        selector: "0x0f755a56"
+      },
+      {
+        args: [
+          {
+            label: "owner",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            label: "spender",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          " Returns the amount of tokens that a spender is allowed to transfer from an owner's account."
+        ],
+        label: "allowance",
+        mutates: false,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 17
+        },
+        selector: "0x6a00165e"
+      },
+      {
+        args: [
+          {
+            label: "to",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            label: "value",
+            type: {
+              displayName: [
+                "Balance"
+              ],
+              type: 3
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          " Transfers tokens from the caller to a recipient account."
+        ],
+        label: "transfer",
+        mutates: true,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 18
+        },
+        selector: "0x84a15da1"
+      },
+      {
+        args: [
+          {
+            label: "to",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            label: "value",
+            type: {
+              displayName: [
+                "Balance"
+              ],
+              type: 3
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          " Mints new tokens and adds them to an account's balance; only callable by controller."
+        ],
+        label: "mint",
+        mutates: true,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 18
+        },
+        selector: "0xcfdd9aa2"
+      },
+      {
+        args: [
+          {
+            label: "from",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            label: "value",
+            type: {
+              displayName: [
+                "Balance"
+              ],
+              type: 3
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          " Burns tokens from an account, reducing the total supply; only callable by controller."
+        ],
+        label: "burn",
+        mutates: true,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 18
+        },
+        selector: "0xb1efc17b"
+      },
+      {
+        args: [
+          {
+            label: "spender",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            label: "value",
+            type: {
+              displayName: [
+                "Balance"
+              ],
+              type: 3
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          " Approves a spender to transfer up to a specified amount of tokens on behalf of the caller."
+        ],
+        label: "approve",
+        mutates: true,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 18
+        },
+        selector: "0x681266a0"
+      },
+      {
+        args: [
+          {
+            label: "from",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            label: "to",
+            type: {
+              displayName: [
+                "AccountId"
+              ],
+              type: 0
+            }
+          },
+          {
+            label: "value",
+            type: {
+              displayName: [
+                "Balance"
+              ],
+              type: 3
+            }
+          }
+        ],
+        default: false,
+        docs: [
+          " Transfers tokens on behalf of an owner account to a recipient, using the caller's allowance."
+        ],
+        label: "transfer_from",
+        mutates: true,
+        payable: false,
+        returnType: {
+          displayName: [
+            "ink",
+            "MessageResult"
+          ],
+          type: 18
+        },
+        selector: "0x0b396f18"
+      }
+    ]
+  },
+  storage: {
+    root: {
+      layout: {
+        struct: {
+          fields: [
+            {
+              layout: {
+                leaf: {
+                  key: "0x00000000",
+                  ty: 0
+                }
+              },
+              name: "controller"
+            },
+            {
+              layout: {
+                leaf: {
+                  key: "0x00000000",
+                  ty: 3
+                }
+              },
+              name: "total_supply"
+            },
+            {
+              layout: {
+                root: {
+                  layout: {
+                    leaf: {
+                      key: "0xa49198b1",
+                      ty: 3
+                    }
+                  },
+                  root_key: "0xa49198b1",
+                  ty: 4
+                }
+              },
+              name: "balances"
+            },
+            {
+              layout: {
+                root: {
+                  layout: {
+                    leaf: {
+                      key: "0x1c6265af",
+                      ty: 3
+                    }
+                  },
+                  root_key: "0x1c6265af",
+                  ty: 9
+                }
+              },
+              name: "allowances"
+            }
+          ],
+          name: "TusdtErc20"
+        }
+      },
+      root_key: "0x00000000",
+      ty: 13
+    }
+  },
+  types: [
+    {
+      id: 0,
+      type: {
+        def: {
+          composite: {
+            fields: [
+              {
+                type: 1,
+                typeName: "[u8; 32]"
+              }
+            ]
+          }
+        },
+        path: [
+          "ink_primitives",
+          "types",
+          "AccountId"
+        ]
+      }
+    },
+    {
+      id: 1,
+      type: {
+        def: {
+          array: {
+            len: 32,
+            type: 2
+          }
+        }
+      }
+    },
+    {
+      id: 2,
+      type: {
+        def: {
+          primitive: "u8"
+        }
+      }
+    },
+    {
+      id: 3,
+      type: {
+        def: {
+          primitive: "u64"
+        }
+      }
+    },
+    {
+      id: 4,
+      type: {
+        def: {
+          composite: {}
+        },
+        params: [
+          {
+            name: "K",
+            type: 0
+          },
+          {
+            name: "V",
+            type: 3
+          },
+          {
+            name: "KeyType",
+            type: 5
+          }
+        ],
+        path: [
+          "ink_storage",
+          "lazy",
+          "mapping",
+          "Mapping"
+        ]
+      }
+    },
+    {
+      id: 5,
+      type: {
+        def: {
+          composite: {}
+        },
+        params: [
+          {
+            name: "L",
+            type: 6
+          },
+          {
+            name: "R",
+            type: 7
+          }
+        ],
+        path: [
+          "ink_storage_traits",
+          "impls",
+          "ResolverKey"
+        ]
+      }
+    },
+    {
+      id: 6,
+      type: {
+        def: {
+          composite: {}
+        },
+        path: [
+          "ink_storage_traits",
+          "impls",
+          "AutoKey"
+        ]
+      }
+    },
+    {
+      id: 7,
+      type: {
+        def: {
+          composite: {}
+        },
+        params: [
+          {
+            name: "ParentKey",
+            type: 8
+          }
+        ],
+        path: [
+          "ink_storage_traits",
+          "impls",
+          "ManualKey"
+        ]
+      }
+    },
+    {
+      id: 8,
+      type: {
+        def: {
+          tuple: []
+        }
+      }
+    },
+    {
+      id: 9,
+      type: {
+        def: {
+          composite: {}
+        },
+        params: [
+          {
+            name: "K",
+            type: 10
+          },
+          {
+            name: "V",
+            type: 3
+          },
+          {
+            name: "KeyType",
+            type: 11
+          }
+        ],
+        path: [
+          "ink_storage",
+          "lazy",
+          "mapping",
+          "Mapping"
+        ]
+      }
+    },
+    {
+      id: 10,
+      type: {
+        def: {
+          tuple: [
+            0,
+            0
+          ]
+        }
+      }
+    },
+    {
+      id: 11,
+      type: {
+        def: {
+          composite: {}
+        },
+        params: [
+          {
+            name: "L",
+            type: 6
+          },
+          {
+            name: "R",
+            type: 12
+          }
+        ],
+        path: [
+          "ink_storage_traits",
+          "impls",
+          "ResolverKey"
+        ]
+      }
+    },
+    {
+      id: 12,
+      type: {
+        def: {
+          composite: {}
+        },
+        params: [
+          {
+            name: "ParentKey",
+            type: 8
+          }
+        ],
+        path: [
+          "ink_storage_traits",
+          "impls",
+          "ManualKey"
+        ]
+      }
+    },
+    {
+      id: 13,
+      type: {
+        def: {
+          composite: {
+            fields: [
+              {
+                name: "controller",
+                type: 0,
+                typeName: "<AccountId as::ink::storage::traits::AutoStorableHint<::ink::\nstorage::traits::ManualKey<3589911795u32, ()>,>>::Type"
+              },
+              {
+                name: "total_supply",
+                type: 3,
+                typeName: "<Balance as::ink::storage::traits::AutoStorableHint<::ink::\nstorage::traits::ManualKey<2456737585u32, ()>,>>::Type"
+              },
+              {
+                name: "balances",
+                type: 4,
+                typeName: "<Mapping<AccountId, Balance> as::ink::storage::traits::\nAutoStorableHint<::ink::storage::traits::ManualKey<2979565988u32,\n()>,>>::Type"
+              },
+              {
+                name: "allowances",
+                type: 9,
+                typeName: "<Mapping<(AccountId, AccountId), Balance> as::ink::storage::traits\n::AutoStorableHint<::ink::storage::traits::ManualKey<\n2942657052u32, ()>,>>::Type"
+              }
+            ]
+          }
+        },
+        path: [
+          "tusdt_erc20",
+          "tusdt",
+          "TusdtErc20"
+        ]
+      }
+    },
+    {
+      id: 14,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                fields: [
+                  {
+                    type: 8
+                  }
+                ],
+                index: 0,
+                name: "Ok"
+              },
+              {
+                fields: [
+                  {
+                    type: 15
+                  }
+                ],
+                index: 1,
+                name: "Err"
+              }
+            ]
+          }
+        },
+        params: [
+          {
+            name: "T",
+            type: 8
+          },
+          {
+            name: "E",
+            type: 15
+          }
+        ],
+        path: [
+          "Result"
+        ]
+      }
+    },
+    {
+      id: 15,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                index: 1,
+                name: "CouldNotReadInput"
+              }
+            ]
+          }
+        },
+        path: [
+          "ink_primitives",
+          "LangError"
+        ]
+      }
+    },
+    {
+      id: 16,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                fields: [
+                  {
+                    type: 0
+                  }
+                ],
+                index: 0,
+                name: "Ok"
+              },
+              {
+                fields: [
+                  {
+                    type: 15
+                  }
+                ],
+                index: 1,
+                name: "Err"
+              }
+            ]
+          }
+        },
+        params: [
+          {
+            name: "T",
+            type: 0
+          },
+          {
+            name: "E",
+            type: 15
+          }
+        ],
+        path: [
+          "Result"
+        ]
+      }
+    },
+    {
+      id: 17,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                fields: [
+                  {
+                    type: 3
+                  }
+                ],
+                index: 0,
+                name: "Ok"
+              },
+              {
+                fields: [
+                  {
+                    type: 15
+                  }
+                ],
+                index: 1,
+                name: "Err"
+              }
+            ]
+          }
+        },
+        params: [
+          {
+            name: "T",
+            type: 3
+          },
+          {
+            name: "E",
+            type: 15
+          }
+        ],
+        path: [
+          "Result"
+        ]
+      }
+    },
+    {
+      id: 18,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                fields: [
+                  {
+                    type: 19
+                  }
+                ],
+                index: 0,
+                name: "Ok"
+              },
+              {
+                fields: [
+                  {
+                    type: 15
+                  }
+                ],
+                index: 1,
+                name: "Err"
+              }
+            ]
+          }
+        },
+        params: [
+          {
+            name: "T",
+            type: 19
+          },
+          {
+            name: "E",
+            type: 15
+          }
+        ],
+        path: [
+          "Result"
+        ]
+      }
+    },
+    {
+      id: 19,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                fields: [
+                  {
+                    type: 8
+                  }
+                ],
+                index: 0,
+                name: "Ok"
+              },
+              {
+                fields: [
+                  {
+                    type: 20
+                  }
+                ],
+                index: 1,
+                name: "Err"
+              }
+            ]
+          }
+        },
+        params: [
+          {
+            name: "T",
+            type: 8
+          },
+          {
+            name: "E",
+            type: 20
+          }
+        ],
+        path: [
+          "Result"
+        ]
+      }
+    },
+    {
+      id: 20,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                index: 0,
+                name: "InsufficientBalance"
+              },
+              {
+                index: 1,
+                name: "InsufficientAllowance"
+              },
+              {
+                index: 2,
+                name: "NotController"
+              }
+            ]
+          }
+        },
+        path: [
+          "tusdt_erc20",
+          "tusdt",
+          "Error"
+        ]
+      }
+    },
+    {
+      id: 21,
+      type: {
+        def: {
+          variant: {
+            variants: [
+              {
+                index: 0,
+                name: "None"
+              },
+              {
+                fields: [
+                  {
+                    type: 0
+                  }
+                ],
+                index: 1,
+                name: "Some"
+              }
+            ]
+          }
+        },
+        params: [
+          {
+            name: "T",
+            type: 0
+          }
+        ],
+        path: [
+          "Option"
+        ]
+      }
+    },
+    {
+      id: 22,
+      type: {
+        def: {
+          composite: {
+            fields: [
+              {
+                type: 1,
+                typeName: "[u8; 32]"
+              }
+            ]
+          }
+        },
+        path: [
+          "ink_primitives",
+          "types",
+          "Hash"
+        ]
+      }
+    },
+    {
+      id: 23,
+      type: {
+        def: {
+          primitive: "u32"
+        }
+      }
+    },
+    {
+      id: 24,
+      type: {
+        def: {
+          variant: {}
+        },
+        path: [
+          "tusdt_env",
+          "RuntimeReadWrite"
+        ]
+      }
+    }
+  ],
+  version: 5
+};
+
+// src/contract/tusdt-contract.ts
+var TusdtContract = class _TusdtContract {
+  /** The underlying Dedot typed contract instance */
+  contract;
+  /** The Dedot client (stored for event subscriptions) */
+  client;
+  /**
+   * Create a TusdtContract attached to a deployed TUSDT ERC20 contract.
+   *
+   * @param client - A connected Dedot client instance (DedotClient or LegacyClient).
+   *   For nodes using legacy JSON-RPC, create with `DedotClient.legacy(provider)`.
+   *   The user is responsible for creating and managing the client lifecycle.
+   * @param contractAddress - The SS58 address of the deployed contract.
+   * @param options - Optional configuration.
+   */
+  constructor(client, contractAddress, options) {
+    this.client = client;
+    this.contract = new Contract(
+      client,
+      tusdt_erc20_default,
+      contractAddress,
+      { defaultCaller: options?.defaultCaller ?? ZERO_ADDRESS }
+    );
+  }
+  /**
+   * Factory: create from user-provided metadata JSON.
+   *
+   * Use this when the metadata JSON is loaded externally (e.g., in browser builds
+   * where JSON import paths may differ, or when using a custom contract build).
+   */
+  static fromMetadata(client, contractAddress, metadata, options) {
+    const instance = Object.create(_TusdtContract.prototype);
+    instance.client = client;
+    instance.contract = new Contract(
+      client,
+      metadata,
+      contractAddress,
+      { defaultCaller: options?.defaultCaller ?? ZERO_ADDRESS }
+    );
+    return instance;
+  }
+  // ─── Read-Only Queries ────────────────────────────────────────
+  /**
+   * Returns the controller account address.
+   * The controller is authorized to mint/burn tokens.
+   */
+  controller() {
+    return queryController(this.contract);
+  }
+  /**
+   * Returns the total supply of tokens in circulation.
+   * Returns bigint (u64).
+   */
+  totalSupply() {
+    return queryTotalSupply(this.contract);
+  }
+  /**
+   * Returns the token balance of the specified account.
+   * Returns 0n if the account has no balance.
+   */
+  balanceOf(owner) {
+    return queryBalanceOf(this.contract, owner);
+  }
+  /**
+   * Returns the remaining allowance that spender can withdraw from owner.
+   * Returns 0n if no allowance has been set.
+   */
+  allowance(owner, spender) {
+    return queryAllowance(this.contract, owner, spender);
+  }
+  // ─── State-Changing Transactions ──────────────────────────────
+  /**
+   * Transfer tokens from the signer's account to a recipient.
+   *
+   * Performs a dry-run first to check for errors and estimate gas.
+   * Self-transfers and zero-value transfers are allowed.
+   *
+   * @throws InsufficientBalanceError if signer has insufficient balance
+   * @throws ValidationError if inputs are invalid or would cause overflow
+   */
+  transfer(signer, to, value, options) {
+    return executeTransfer(this.contract, signer, to, value, options);
+  }
+  /**
+   * Approve a spender to withdraw up to `value` tokens from the signer's account.
+   *
+   * WARNING: Uses set-overwrite pattern (standard ERC20). Subject to front-running attack.
+   * Use `safeApprove()` for safer approval changes.
+   *
+   * @throws ValidationError if inputs are invalid
+   */
+  approve(signer, spender, value, options) {
+    return executeApprove(this.contract, signer, spender, value, options);
+  }
+  /**
+   * Transfer tokens from one account to another using the signer's allowance.
+   *
+   * The signer must have been granted sufficient allowance by the `from` account.
+   * On success, the allowance is decreased by `value`.
+   * On failure (insufficient balance), the allowance is NOT decreased.
+   *
+   * @throws InsufficientAllowanceError if signer has insufficient allowance
+   * @throws InsufficientBalanceError if `from` has insufficient balance
+   * @throws ValidationError if inputs are invalid or would cause overflow
+   */
+  transferFrom(signer, from, to, value, options) {
+    return executeTransferFrom(this.contract, signer, from, to, value, options);
+  }
+  /**
+   * Safe approval that mitigates the ERC20 approve front-running attack.
+   *
+   * If the current allowance > 0 and newValue > 0, this first sets the
+   * allowance to 0, then sets it to the desired value.
+   *
+   * @throws ValidationError if inputs are invalid
+   */
+  safeApprove(signer, spender, newValue, options) {
+    return safeApprove(this.contract, signer, spender, newValue, options);
+  }
+  // ─── Event Subscriptions ──────────────────────────────────────
+  /**
+   * Subscribe to all Transfer events emitted by this contract.
+   * Includes mints (from=null), burns (to=null), and regular transfers.
+   *
+   * @param options - Optional. Pass `onError` to receive errors instead of silent skipping.
+   * @returns A function to unsubscribe from the event stream.
+   */
+  onTransfer(callback, options) {
+    return subscribeTransfer(this.client, this.contract, callback, options);
+  }
+  /**
+   * Subscribe to all Approval events emitted by this contract.
+   *
+   * @param options - Optional. Pass `onError` to receive errors instead of silent skipping.
+   * @returns A function to unsubscribe from the event stream.
+   */
+  onApproval(callback, options) {
+    return subscribeApproval(this.client, this.contract, callback, options);
+  }
+  /**
+   * Subscribe to Transfer events where a specific account is the sender.
+   *
+   * @param account - SS58 address of the sender to filter for
+   * @param options - Optional. Pass `onError` to receive errors instead of silent skipping.
+   * @returns A function to unsubscribe from the event stream.
+   */
+  onTransferFrom(account, callback, options) {
+    return subscribeTransferFrom(this.client, this.contract, account, callback, options);
+  }
+  /**
+   * Subscribe to Transfer events where a specific account is the recipient.
+   *
+   * @param account - SS58 address of the recipient to filter for
+   * @param options - Optional. Pass `onError` to receive errors instead of silent skipping.
+   * @returns A function to unsubscribe from the event stream.
+   */
+  onTransferTo(account, callback, options) {
+    return subscribeTransferTo(this.client, this.contract, account, callback, options);
+  }
+  // ─── Finalized Event Subscriptions ─────────────────────────────
+  /**
+   * Subscribe to all Transfer events on finalized blocks.
+   *
+   * Finalized blocks are immutable (no reorg risk), making this suitable for
+   * payment detection and reconciliation. Events include block number and
+   * event index within the block.
+   *
+   * For a full production payment listener with reconnection, deduplication,
+   * and address filtering, use `TusdtPaymentListener` from `tusdt-sdk/server`.
+   *
+   * @param options - Optional. Pass `onError` to receive errors instead of silent skipping.
+   * @returns A function to unsubscribe from the event stream.
+   */
+  onFinalizedTransfer(callback, options) {
+    return watchFinalizedTransfers(this.client, this.contract, callback, options);
+  }
+  /**
+   * Subscribe to Transfer events to a specific account on finalized blocks.
+   *
+   * @param account - SS58 address of the recipient to filter for
+   * @param options - Optional. Pass `onError` to receive errors instead of silent skipping.
+   * @returns A function to unsubscribe from the event stream.
+   */
+  onFinalizedTransferTo(account, callback, options) {
+    return watchFinalizedTransfersTo(this.client, this.contract, account, callback, options);
+  }
+};
+
+export { ConnectionError, ContractError, DispatchError, DryRunError, InsufficientAllowanceError, InsufficientBalanceError, NotControllerError, TimeoutError, TusdtContract, TusdtSdkError, U64_MAX, ValidationError, ZERO_ADDRESS, ZERO_BALANCE, executeApprove, executeTransfer, executeTransferFrom, getSignerAddress, isKeyringPair, mapContractError, queryAllowance, queryBalanceOf, queryController, queryTotalSupply, safeApprove, subscribeApproval, subscribeTransfer, subscribeTransferFrom, subscribeTransferTo, tusdt_erc20_default, validateAddress, validateBalance, validateOverflowSafe, watchFinalizedTransfers, watchFinalizedTransfersTo };
+//# sourceMappingURL=chunk-5HS7VSOA.js.map
+//# sourceMappingURL=chunk-5HS7VSOA.js.map