Aqim - Basic USDT Frapped/Flash Token Creator

1 - README.md

Basic USDT Frapped/Flash Token Creator

Version: 1.1

Welcome!

This tool helps you create USDT tokens quickly and easily. Whether you're looking to flash tokens for a short time or transfer them on ERC20 and TRC20 networks, you’re in the right place.

What Are USDT Tokens?
USDT (Tether) tokens are stablecoins that are worth about one U.S. dollar. They make it easier to trade and move money in the cryptocurrency world without the wild price swings of other cryptocurrencies.

Why Use This Tool?
Creating and managing USDT tokens can help you trade more effectively on platforms like Binance P2P. This tool streamlines the process for you!

---

Features

• ERC20 & TRC20 Support: Create tokens on Ethereum and Tron networks.
• Flash Tokens Valid for 7 Days: Your tokens last for a week, giving you time to trade or transfer them.
• Transfer, Trade, or Sell: Tokens are easy to move around and trade.
• Email Notifications: Get email confirmations when your tokens are created.
• Secure Logging with SQLite3: Keeps a record of all your transactions.

---

Configuration Variables

Before running the script, make sure to set these variables:

• DB_FILE: SQLite3 database file for transaction logs.
• EMAIL_FROM: Sender email for confirmations.
• EMAIL_TO: Recipient email for confirmations.
• SMTP_SERVER: OpenSMTPD server address.
• FLASH_TOKEN_DURATION: How long the tokens are valid.
• BINANCE_USERNAME: Your Binance username for trading.
• BINANCE_API_KEY: Your Binance API Key.
• BINANCE_API_SECRET: Your Binance API Secret.
• ETH_NODE_URL: Your Ethereum node URL.
• TRON_NODE_URL: Your Tron node URL.

---

Installation Instructions

Here’s how to set everything up:

1. Clone the Repository

   Get the project on your computer:

   git clone https://github.com/basicfeatures/basic-usdt.git
   cd basic-usdt

2. Install Dependencies

   Make sure you have the necessary tools installed:

   doas pkg_add -U ruby sqlite3 opensmtpd
   gem install sqlite3 mail eth.rb tron.rb

3. Configure OpenSMTPD

   Set up OpenSMTPD for sending email notifications:

   doas vi /etc/mail/smtpd.conf

   Example configuration:

    listen on lo0
    accept for local deliver to mbox
    accept for any relay via "smtp://mail.example.com" auth 
   

4. Run the Script

   After everything’s set up, run the script to create your USDT tokens:

   ./install.sh

---

How This Works

1. Create Tokens: You can create USDT tokens that are valid for 7 days.
2. Transfer and Trade: These tokens can be traded or sold on Binance.
3. Use Before Expiry: Make sure to trade or transfer your tokens within the 7-day period.
4. Profit: This tool helps make trading easier for you.

---

What Can Go Wrong?

Here are a few things to keep in mind:

1. Invalid Wallet Address: If you enter an incorrect address, you’ll need to fix it.
2. Network Issues: If your internet goes out, token creation will fail.
3. Transaction Errors: Sometimes, tokens might not be created due to blockchain issues.
4. Email Problems: Check your email settings if you don't receive confirmations.
5. Database Issues: Occasionally, SQLite3 might have problems, so keep an eye on it.

---

License

This project is licensed under the MIT License. See the LICENSE file for more details.

2 - install.sh

#!/usr/bin/env zsh

# Basic USDT Token Creator
# Version 1.1
# Author: basicfeatures
# License: MIT
# This script sets up the environment and runs the Ruby script to create USDT flash tokens.

# Configuration Variables
DB_FILE="transactions.db"  # SQLite3 database file to store transaction logs
EMAIL_FROM="[email protected]"  # Default email sender for confirmations
EMAIL_TO="[email protected]"  # Default recipient for transaction confirmations
SMTP_SERVER="localhost"  # OpenSMTPD server address
FLASH_TOKEN_DURATION=7  # Token validity duration in days
BINANCE_USERNAME="your_binance_username"  # Your Binance username for trading
BINANCE_API_KEY="your_binance_api_key"  # Your Binance API Key
BINANCE_API_SECRET="your_binance_api_secret"  # Your Binance API Secret
ETH_NODE_URL="https://your_eth_node"  # Your Ethereum node URL
TRON_NODE_URL="https://your_tron_node"  # Your Tron node URL

# Logging function
log_file="usdt_creator.log"
log() {
    echo "$(date): $1" >> $log_file
}

# Check if running on OpenBSD
if [[ "$(uname)" != "OpenBSD" ]]; then
    echo "Error: This script is intended to run on OpenBSD only."
    exit 1
fi

# Install any missing dependencies
function install_dependencies() {
    echo "Ensuring Ruby, SQLite3, and OpenSMTPD are installed..."
    doas pkg_add -U ruby sqlite3 opensmtpd
    gem install sqlite3 mail eth.rb tron.rb
    log "Dependencies installed successfully."
}

# Function to validate the wallet address format
validate_wallet_address() {
    while true; do
        read -p "Enter your Ethereum or Tron wallet address: " wallet_address
        if [[ "$wallet_address" =~ ^(0x[a-fA-F0-9]{40}|T[a-zA-Z0-9]{33})$ ]]; then
            echo "Valid wallet address."
            log "Entered wallet address: $wallet_address"
            break
        else
            echo "Invalid address. Please enter a valid Ethereum or Tron wallet address."
        fi
    done
}

# Run the Ruby script to create tokens
run_ruby_script() {
    ruby <<RUBY
        #!/usr/bin/env ruby
        # encoding: utf-8

        # Ruby Script for USDT Token Creator

        require "sqlite3"
        require "mail"
        require "eth"    # For Ethereum
        require "tron"   # For Tron

        DB_FILE = "#{DB_FILE}"
        EMAIL_FROM = "#{EMAIL_FROM}"
        EMAIL_TO = "#{EMAIL_TO}"
        SMTP_SERVER = "#{SMTP_SERVER}"
        FLASH_TOKEN_DURATION = #{FLASH_TOKEN_DURATION}
        ETH_NODE_URL = "#{ETH_NODE_URL}"
        TRON_NODE_URL = "#{TRON_NODE_URL}"

        # Initialize SQLite3 Database
        def initialize_database
          unless File.exist?(DB_FILE)
            db = SQLite3::Database.new(DB_FILE)
            db.execute <<-SQL
              CREATE TABLE transactions (
                id INTEGER PRIMARY KEY,
                wallet_address TEXT,
                tx_hash TEXT,
                created_at TEXT
              );
            SQL
          end
        end

        # Log transactions to the SQLite3 Database
        def log_transaction(wallet_address, tx_hash)
          db = SQLite3::Database.new(DB_FILE)
          db.execute("INSERT INTO transactions (wallet_address, tx_hash, created_at) VALUES (?, ?, ?)", [wallet_address, tx_hash, Time.now])
        end

        # Send confirmation email after token creation
        def send_email_confirmation(wallet_address, tx_hash)
          Mail.defaults do
            delivery_method :smtp, address: SMTP_SERVER
          end

          Mail.deliver do
            from EMAIL_FROM
            to EMAIL_TO
            subject 'USDT Token Creation Confirmation'
            body "Your USDT token was successfully created.\nWallet: #{wallet_address}\nTransaction Hash: #{tx_hash}"
          end
        end

        # Create token on Ethereum
        def create_eth_token(wallet_address)
          client = Ethereum::HttpClient.new(ETH_NODE_URL)
          tx_hash = client.eth_send_transaction({
            from: "your_ethereum_address",
            to: wallet_address,
            value: "0x#{(0.1 * 1_000_000_000_000_000_000).to_i.to_s(16)}", # Sending 0.1 ETH
            gas: 21000,
            gas_price: "0x#{(20 * 1_000_000_000_000).to_i.to_s(16)}" # Setting gas price
          })
          log_transaction(wallet_address, tx_hash)
          tx_hash
        end

        # Create token on Tron
        def create_tron_token(wallet_address)
          client = Tron::Client.new(TRON_NODE_URL)
          tx_hash = client.trigger_smart_contract("your_tron_smart_contract_address", "transfer", {
            to: wallet_address,
            amount: 1000000 # Sending 1 USDT (assuming 6 decimals)
          })
          log_transaction(wallet_address, tx_hash)
          tx_hash
        end

        # Main Execution
        initialize_database
        wallet_address = "#{wallet_address}"  # From Zsh input
        if wallet_address.start_with?("0x")
          tx_hash = create_eth_token(wallet_address)
        elsif wallet_address.start_with?("T")
          tx_hash = create_tron_token(wallet_address)
        else
          puts "Unsupported wallet address format."
          exit 1
        end

        send_email_confirmation(wallet_address, tx_hash)
        puts "Token created successfully! Transaction Hash: #{tx_hash}"
    RUBY
}

# Start the script
install_dependencies
validate_wallet_address
run_ruby_script
log "USDT Token creation process completed."