@gitmyabi/xai 1.0.1 → 1.0.2

package/contracts/XAI_json.ts

@@ -37,38 +37,6 @@ export const XAI_jsonAbi = [
     "name": "Approval",
     "type": "event"
   },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "_maxTxAmount",
-        "type": "uint256"
-      }
-    ],
-    "name": "MaxTxAmountUpdated",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": true,
-        "internalType": "address",
-        "name": "previousOwner",
-        "type": "address"
-      },
-      {
-        "indexed": true,
-        "internalType": "address",
-        "name": "newOwner",
-        "type": "address"
-      }
-    ],
-    "name": "OwnershipTransferred",
-    "type": "event"
-  },
   {
     "anonymous": false,
     "inputs": [
@@ -94,64 +62,6 @@ export const XAI_jsonAbi = [
     "name": "Transfer",
     "type": "event"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "_buyMap",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "_maxTxAmount",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "_maxWalletSize",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "_swapTokensAtAmount",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [
       {
@@ -222,12 +132,12 @@ export const XAI_jsonAbi = [
   {
     "inputs": [
       {
-        "internalType": "address[]",
-        "name": "bots_",
-        "type": "address[]"
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
       }
     ],
-    "name": "blockBots",
+    "name": "burn",
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
@@ -236,19 +146,18 @@ export const XAI_jsonAbi = [
     "inputs": [
       {
         "internalType": "address",
-        "name": "",
+        "name": "account",
         "type": "address"
-      }
-    ],
-    "name": "bots",
-    "outputs": [
+      },
       {
-        "internalType": "bool",
-        "name": "",
-        "type": "bool"
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
       }
     ],
-    "stateMutability": "view",
+    "name": "burnFrom",
+    "outputs": [],
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
@@ -261,157 +170,60 @@ export const XAI_jsonAbi = [
         "type": "uint8"
       }
     ],
-    "stateMutability": "pure",
+    "stateMutability": "view",
     "type": "function"
   },
   {
     "inputs": [
-      {
-        "internalType": "address[]",
-        "name": "accounts",
-        "type": "address[]"
-      },
-      {
-        "internalType": "bool",
-        "name": "excluded",
-        "type": "bool"
-      }
-    ],
-    "name": "excludeMultipleAccountsFromFees",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "manualsend",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "manualswap",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "name",
-    "outputs": [
-      {
-        "internalType": "string",
-        "name": "",
-        "type": "string"
-      }
-    ],
-    "stateMutability": "pure",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "owner",
-    "outputs": [
       {
         "internalType": "address",
-        "name": "",
+        "name": "spender",
         "type": "address"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "renounceOwnership",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "uint256",
-        "name": "redisFeeOnBuy",
-        "type": "uint256"
-      },
-      {
-        "internalType": "uint256",
-        "name": "redisFeeOnSell",
-        "type": "uint256"
-      },
-      {
-        "internalType": "uint256",
-        "name": "taxFeeOnBuy",
-        "type": "uint256"
       },
       {
         "internalType": "uint256",
-        "name": "taxFeeOnSell",
+        "name": "subtractedValue",
         "type": "uint256"
       }
     ],
-    "name": "setFee",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
+    "name": "decreaseAllowance",
+    "outputs": [
       {
-        "internalType": "uint256",
-        "name": "maxTxAmount",
-        "type": "uint256"
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
       }
     ],
-    "name": "setMaxTxnAmount",
-    "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
       {
-        "internalType": "uint256",
-        "name": "maxWalletSize",
-        "type": "uint256"
-      }
-    ],
-    "name": "setMaxWalletSize",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
       {
         "internalType": "uint256",
-        "name": "swapTokensAtAmount",
+        "name": "addedValue",
         "type": "uint256"
       }
     ],
-    "name": "setMinSwapTokensThreshold",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
+    "name": "increaseAllowance",
+    "outputs": [
       {
         "internalType": "bool",
-        "name": "_tradingOpen",
+        "name": "",
         "type": "bool"
       }
     ],
-    "name": "setTrading",
-    "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [],
-    "name": "symbol",
+    "name": "name",
     "outputs": [
       {
         "internalType": "string",
@@ -419,20 +231,20 @@ export const XAI_jsonAbi = [
         "type": "string"
       }
     ],
-    "stateMutability": "pure",
+    "stateMutability": "view",
     "type": "function"
   },
   {
-    "inputs": [
+    "inputs": [],
+    "name": "symbol",
+    "outputs": [
       {
-        "internalType": "bool",
-        "name": "_swapEnabled",
-        "type": "bool"
+        "internalType": "string",
+        "name": "",
+        "type": "string"
       }
     ],
-    "name": "toggleSwap",
-    "outputs": [],
-    "stateMutability": "nonpayable",
+    "stateMutability": "view",
     "type": "function"
   },
   {
@@ -445,7 +257,7 @@ export const XAI_jsonAbi = [
         "type": "uint256"
       }
     ],
-    "stateMutability": "pure",
+    "stateMutability": "view",
     "type": "function"
   },
   {
@@ -500,62 +312,6 @@ export const XAI_jsonAbi = [
     ],
     "stateMutability": "nonpayable",
     "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "newOwner",
-        "type": "address"
-      }
-    ],
-    "name": "transferOwnership",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "notbot",
-        "type": "address"
-      }
-    ],
-    "name": "unblockBot",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "uniswapV2Pair",
-    "outputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "uniswapV2Router",
-    "outputs": [
-      {
-        "internalType": "contract IUniswapV2Router02",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "stateMutability": "payable",
-    "type": "receive"
   }
 ] as const satisfies Abi;
 
@@ -641,38 +397,6 @@ export class XAI_json {
     return this.contract;
   }
 
-  /**
-   * _buyMap
-   * view
-   */
-  async _buyMap(arg0: `0x${string}`): Promise<bigint> {
-    return this.contract.read._buyMap([arg0] as const) as Promise<bigint>;
-  }
-
-  /**
-   * _maxTxAmount
-   * view
-   */
-  async _maxTxAmount(): Promise<bigint> {
-    return this.contract.read._maxTxAmount() as Promise<bigint>;
-  }
-
-  /**
-   * _maxWalletSize
-   * view
-   */
-  async _maxWalletSize(): Promise<bigint> {
-    return this.contract.read._maxWalletSize() as Promise<bigint>;
-  }
-
-  /**
-   * _swapTokensAtAmount
-   * view
-   */
-  async _swapTokensAtAmount(): Promise<bigint> {
-    return this.contract.read._swapTokensAtAmount() as Promise<bigint>;
-  }
-
   /**
    * allowance
    * view
@@ -689,283 +413,44 @@ export class XAI_json {
     return this.contract.read.balanceOf([account] as const) as Promise<bigint>;
   }
 
-  /**
-   * bots
-   * view
-   */
-  async bots(arg0: `0x${string}`): Promise<boolean> {
-    return this.contract.read.bots([arg0] as const) as Promise<boolean>;
-  }
-
   /**
    * decimals
-   * pure
-   */
-  async decimals(): Promise<bigint> {
-    return this.contract.read.decimals() as Promise<bigint>;
-  }
-
-  /**
-   * name
-   * pure
-   */
-  async name(): Promise<string> {
-    return this.contract.read.name() as Promise<string>;
-  }
-
-  /**
-   * owner
-   * view
-   */
-  async owner(): Promise<`0x${string}`> {
-    return this.contract.read.owner() as Promise<`0x${string}`>;
-  }
-
-  /**
-   * symbol
-   * pure
-   */
-  async symbol(): Promise<string> {
-    return this.contract.read.symbol() as Promise<string>;
-  }
-
-  /**
-   * totalSupply
-   * pure
-   */
-  async totalSupply(): Promise<bigint> {
-    return this.contract.read.totalSupply() as Promise<bigint>;
-  }
-
-  /**
-   * uniswapV2Pair
-   * view
-   */
-  async uniswapV2Pair(): Promise<`0x${string}`> {
-    return this.contract.read.uniswapV2Pair() as Promise<`0x${string}`>;
-  }
-
-  /**
-   * uniswapV2Router
    * view
    */
-  async uniswapV2Router(): Promise<`0x${string}`> {
-    return this.contract.read.uniswapV2Router() as Promise<`0x${string}`>;
-  }
-
-  /**
-   * approve
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
-   */
-  async approve(spender: `0x${string}`, amount: bigint, options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.approve([spender, amount] as const, options) as Promise<`0x${string}`>;
-  }
-
-  /**
-   * blockBots
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
-   */
-  async blockBots(bots_: `0x${string}`[], options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.blockBots([bots_] as const, options) as Promise<`0x${string}`>;
-  }
-
-  /**
-   * excludeMultipleAccountsFromFees
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
-   */
-  async excludeMultipleAccountsFromFees(accounts: `0x${string}`[], excluded: boolean, options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.excludeMultipleAccountsFromFees([accounts, excluded] as const, options) as Promise<`0x${string}`>;
-  }
-
-  /**
-   * manualsend
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
-   */
-  async manualsend(options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.manualsend(options) as Promise<`0x${string}`>;
-  }
-
-  /**
-   * manualswap
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
-   */
-  async manualswap(options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.manualswap(options) as Promise<`0x${string}`>;
-  }
-
-  /**
-   * renounceOwnership
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
-   */
-  async renounceOwnership(options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.renounceOwnership(options) as Promise<`0x${string}`>;
+  async decimals(): Promise<bigint> {
+    return this.contract.read.decimals() as Promise<bigint>;
   }
 
   /**
-   * setFee
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   * name
+   * view
    */
-  async setFee(redisFeeOnBuy: bigint, redisFeeOnSell: bigint, taxFeeOnBuy: bigint, taxFeeOnSell: bigint, options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.setFee([redisFeeOnBuy, redisFeeOnSell, taxFeeOnBuy, taxFeeOnSell] as const, options) as Promise<`0x${string}`>;
+  async name(): Promise<string> {
+    return this.contract.read.name() as Promise<string>;
   }
 
   /**
-   * setMaxTxnAmount
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   * symbol
+   * view
    */
-  async setMaxTxnAmount(maxTxAmount: bigint, options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.setMaxTxnAmount([maxTxAmount] as const, options) as Promise<`0x${string}`>;
+  async symbol(): Promise<string> {
+    return this.contract.read.symbol() as Promise<string>;
   }
 
   /**
-   * setMaxWalletSize
-   * nonpayable
-   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   * totalSupply
+   * view
    */
-  async setMaxWalletSize(maxWalletSize: bigint, options?: {
-    accessList?: import('viem').AccessList;
-    authorizationList?: import('viem').AuthorizationList;
-    chain?: import('viem').Chain | null;
-    dataSuffix?: `0x${string}`;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    nonce?: number;
-    value?: bigint;
-  }): Promise<`0x${string}`> {
-    if (!this.contract.write) {
-      throw new Error('Wallet client is required for write operations');
-    }
-    return this.contract.write.setMaxWalletSize([maxWalletSize] as const, options) as Promise<`0x${string}`>;
+  async totalSupply(): Promise<bigint> {
+    return this.contract.read.totalSupply() as Promise<bigint>;
   }
 
   /**
-   * setMinSwapTokensThreshold
+   * approve
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async setMinSwapTokensThreshold(swapTokensAtAmount: bigint, options?: {
+  async approve(spender: `0x${string}`, amount: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -980,15 +465,15 @@ export class XAI_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.setMinSwapTokensThreshold([swapTokensAtAmount] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.approve([spender, amount] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * setTrading
+   * burn
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async setTrading(_tradingOpen: boolean, options?: {
+  async burn(amount: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1003,15 +488,15 @@ export class XAI_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.setTrading([_tradingOpen] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.burn([amount] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * toggleSwap
+   * burnFrom
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async toggleSwap(_swapEnabled: boolean, options?: {
+  async burnFrom(account: `0x${string}`, amount: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1026,15 +511,15 @@ export class XAI_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.toggleSwap([_swapEnabled] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.burnFrom([account, amount] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * transfer
+   * decreaseAllowance
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async transfer(recipient: `0x${string}`, amount: bigint, options?: {
+  async decreaseAllowance(spender: `0x${string}`, subtractedValue: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1049,15 +534,15 @@ export class XAI_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.transfer([recipient, amount] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.decreaseAllowance([spender, subtractedValue] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * transferFrom
+   * increaseAllowance
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async transferFrom(sender: `0x${string}`, recipient: `0x${string}`, amount: bigint, options?: {
+  async increaseAllowance(spender: `0x${string}`, addedValue: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1072,15 +557,15 @@ export class XAI_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.transferFrom([sender, recipient, amount] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.increaseAllowance([spender, addedValue] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * transferOwnership
+   * transfer
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async transferOwnership(newOwner: `0x${string}`, options?: {
+  async transfer(recipient: `0x${string}`, amount: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1095,15 +580,15 @@ export class XAI_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.transferOwnership([newOwner] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.transfer([recipient, amount] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * unblockBot
+   * transferFrom
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async unblockBot(notbot: `0x${string}`, options?: {
+  async transferFrom(sender: `0x${string}`, recipient: `0x${string}`, amount: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1118,7 +603,7 @@ export class XAI_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.unblockBot([notbot] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.transferFrom([sender, recipient, amount] as const, options) as Promise<`0x${string}`>;
   }
 
 
@@ -1157,144 +642,11 @@ export class XAI_json {
         return contract.simulate.approve([spender, amount] as const, options) as Promise<boolean>;
       },
       /**
-       * Simulate blockBots
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async blockBots(bots_: `0x${string}`[], options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.blockBots([bots_] as const, options) as Promise<void>;
-      },
-      /**
-       * Simulate excludeMultipleAccountsFromFees
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async excludeMultipleAccountsFromFees(accounts: `0x${string}`[], excluded: boolean, options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.excludeMultipleAccountsFromFees([accounts, excluded] as const, options) as Promise<void>;
-      },
-      /**
-       * Simulate manualsend
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async manualsend(options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.manualsend(options) as Promise<void>;
-      },
-      /**
-       * Simulate manualswap
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async manualswap(options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.manualswap(options) as Promise<void>;
-      },
-      /**
-       * Simulate renounceOwnership
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async renounceOwnership(options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.renounceOwnership(options) as Promise<void>;
-      },
-      /**
-       * Simulate setFee
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async setFee(redisFeeOnBuy: bigint, redisFeeOnSell: bigint, taxFeeOnBuy: bigint, taxFeeOnSell: bigint, options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.setFee([redisFeeOnBuy, redisFeeOnSell, taxFeeOnBuy, taxFeeOnSell] as const, options) as Promise<void>;
-      },
-      /**
-       * Simulate setMaxTxnAmount
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async setMaxTxnAmount(maxTxAmount: bigint, options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.setMaxTxnAmount([maxTxAmount] as const, options) as Promise<void>;
-      },
-      /**
-       * Simulate setMaxWalletSize
+       * Simulate burn
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async setMaxWalletSize(maxWalletSize: bigint, options?: {
+      async burn(amount: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1306,14 +658,14 @@ export class XAI_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.setMaxWalletSize([maxWalletSize] as const, options) as Promise<void>;
+        return contract.simulate.burn([amount] as const, options) as Promise<void>;
       },
       /**
-       * Simulate setMinSwapTokensThreshold
+       * Simulate burnFrom
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async setMinSwapTokensThreshold(swapTokensAtAmount: bigint, options?: {
+      async burnFrom(account: `0x${string}`, amount: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1325,14 +677,14 @@ export class XAI_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.setMinSwapTokensThreshold([swapTokensAtAmount] as const, options) as Promise<void>;
+        return contract.simulate.burnFrom([account, amount] as const, options) as Promise<void>;
       },
       /**
-       * Simulate setTrading
+       * Simulate decreaseAllowance
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async setTrading(_tradingOpen: boolean, options?: {
+      async decreaseAllowance(spender: `0x${string}`, subtractedValue: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1343,15 +695,15 @@ export class XAI_json {
         maxPriorityFeePerGas?: bigint;
         nonce?: number;
         value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.setTrading([_tradingOpen] as const, options) as Promise<void>;
+      }): Promise<boolean> {
+        return contract.simulate.decreaseAllowance([spender, subtractedValue] as const, options) as Promise<boolean>;
       },
       /**
-       * Simulate toggleSwap
+       * Simulate increaseAllowance
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async toggleSwap(_swapEnabled: boolean, options?: {
+      async increaseAllowance(spender: `0x${string}`, addedValue: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1362,8 +714,8 @@ export class XAI_json {
         maxPriorityFeePerGas?: bigint;
         nonce?: number;
         value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.toggleSwap([_swapEnabled] as const, options) as Promise<void>;
+      }): Promise<boolean> {
+        return contract.simulate.increaseAllowance([spender, addedValue] as const, options) as Promise<boolean>;
       },
       /**
        * Simulate transfer
@@ -1402,44 +754,6 @@ export class XAI_json {
         value?: bigint;
       }): Promise<boolean> {
         return contract.simulate.transferFrom([sender, recipient, amount] as const, options) as Promise<boolean>;
-      },
-      /**
-       * Simulate transferOwnership
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async transferOwnership(newOwner: `0x${string}`, options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.transferOwnership([newOwner] as const, options) as Promise<void>;
-      },
-      /**
-       * Simulate unblockBot
-       * Returns gas estimate and result without sending transaction
-       * @param options Optional transaction parameters (value, gas, nonce, etc.)
-       */
-      async unblockBot(notbot: `0x${string}`, options?: {
-        accessList?: import('viem').AccessList;
-        authorizationList?: import('viem').AuthorizationList;
-        chain?: import('viem').Chain | null;
-        dataSuffix?: `0x${string}`;
-        gas?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        nonce?: number;
-        value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.unblockBot([notbot] as const, options) as Promise<void>;
       }
     };
   }
@@ -1477,44 +791,6 @@ export class XAI_json {
           },
         }) as () => void;
       },
-      /**
-       * Watch MaxTxAmountUpdated events
-       * @param callback Function to call when event is emitted
-       * @param filter Optional filter for indexed parameters
-       * @returns Unwatch function to stop listening
-       */
-      MaxTxAmountUpdated: (callback: (event: { _maxTxAmount: bigint }) => void) => {
-        return this.publicClient.watchContractEvent({
-          address: this.contractAddress,
-          abi: XAI_jsonAbi,
-          eventName: 'MaxTxAmountUpdated',
-          
-          onLogs: (logs: any[]) => {
-            logs.forEach((log: any) => {
-              callback(log.args as any);
-            });
-          },
-        }) as () => void;
-      },
-      /**
-       * Watch OwnershipTransferred events
-       * @param callback Function to call when event is emitted
-       * @param filter Optional filter for indexed parameters
-       * @returns Unwatch function to stop listening
-       */
-      OwnershipTransferred: (callback: (event: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => void, filter?: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => {
-        return this.publicClient.watchContractEvent({
-          address: this.contractAddress,
-          abi: XAI_jsonAbi,
-          eventName: 'OwnershipTransferred',
-          args: filter,
-          onLogs: (logs: any[]) => {
-            logs.forEach((log: any) => {
-              callback(log.args as any);
-            });
-          },
-        }) as () => void;
-      },
       /**
        * Watch Transfer events
        * @param callback Function to call when event is emitted