refactor: move all remaining files to orig/ directory

Completed clean root directory structure:
- Root now contains only: .git, .env, docs/, orig/
- Moved all remaining files and directories to orig/:
  - Config files (.claude, .dockerignore, .drone.yml, etc.)
  - All .env variants (except active .env)
  - Git config (.gitconfig, .github, .gitignore, etc.)
  - Tool configs (.golangci.yml, .revive.toml, etc.)
  - Documentation (*.md files, @prompts)
  - Build files (Dockerfiles, Makefile, go.mod, go.sum)
  - Docker compose files
  - All source directories (scripts, tests, tools, etc.)
  - Runtime directories (logs, monitoring, reports)
  - Dependency files (node_modules, lib, cache)
  - Special files (--delete)

- Removed empty runtime directories (bin/, data/)

V2 structure is now clean:
- docs/planning/ - V2 planning documents
- orig/ - Complete V1 codebase preserved
- .env - Active environment config (not in git)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

orig/bindings/contracts/dexmath.go

@@ -0,0 +1,181 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package contracts
+
+import (
+	"errors"
+	"math/big"
+	"strings"
+
+	ethereum "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+	_ = abi.ConvertType
+)
+
+// DEXMathMetaData contains all meta data concerning the DEXMath contract.
+var DEXMathMetaData = &bind.MetaData{
+	ABI: "[{\"type\":\"error\",\"name\":\"ArithmeticOverflow\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientLiquidity\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidFee\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnsupportedDEXType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ZeroAmount\",\"inputs\":[]}]",
+}
+
+// DEXMathABI is the input ABI used to generate the binding from.
+// Deprecated: Use DEXMathMetaData.ABI instead.
+var DEXMathABI = DEXMathMetaData.ABI
+
+// DEXMath is an auto generated Go binding around an Ethereum contract.
+type DEXMath struct {
+	DEXMathCaller     // Read-only binding to the contract
+	DEXMathTransactor // Write-only binding to the contract
+	DEXMathFilterer   // Log filterer for contract events
+}
+
+// DEXMathCaller is an auto generated read-only Go binding around an Ethereum contract.
+type DEXMathCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DEXMathTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type DEXMathTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DEXMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type DEXMathFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DEXMathSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type DEXMathSession struct {
+	Contract     *DEXMath          // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts     // Call options to use throughout this session
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// DEXMathCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type DEXMathCallerSession struct {
+	Contract *DEXMathCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// DEXMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type DEXMathTransactorSession struct {
+	Contract     *DEXMathTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// DEXMathRaw is an auto generated low-level Go binding around an Ethereum contract.
+type DEXMathRaw struct {
+	Contract *DEXMath // Generic contract binding to access the raw methods on
+}
+
+// DEXMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type DEXMathCallerRaw struct {
+	Contract *DEXMathCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// DEXMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type DEXMathTransactorRaw struct {
+	Contract *DEXMathTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewDEXMath creates a new instance of DEXMath, bound to a specific deployed contract.
+func NewDEXMath(address common.Address, backend bind.ContractBackend) (*DEXMath, error) {
+	contract, err := bindDEXMath(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &DEXMath{DEXMathCaller: DEXMathCaller{contract: contract}, DEXMathTransactor: DEXMathTransactor{contract: contract}, DEXMathFilterer: DEXMathFilterer{contract: contract}}, nil
+}
+
+// NewDEXMathCaller creates a new read-only instance of DEXMath, bound to a specific deployed contract.
+func NewDEXMathCaller(address common.Address, caller bind.ContractCaller) (*DEXMathCaller, error) {
+	contract, err := bindDEXMath(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DEXMathCaller{contract: contract}, nil
+}
+
+// NewDEXMathTransactor creates a new write-only instance of DEXMath, bound to a specific deployed contract.
+func NewDEXMathTransactor(address common.Address, transactor bind.ContractTransactor) (*DEXMathTransactor, error) {
+	contract, err := bindDEXMath(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DEXMathTransactor{contract: contract}, nil
+}
+
+// NewDEXMathFilterer creates a new log filterer instance of DEXMath, bound to a specific deployed contract.
+func NewDEXMathFilterer(address common.Address, filterer bind.ContractFilterer) (*DEXMathFilterer, error) {
+	contract, err := bindDEXMath(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &DEXMathFilterer{contract: contract}, nil
+}
+
+// bindDEXMath binds a generic wrapper to an already deployed contract.
+func bindDEXMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := DEXMathMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_DEXMath *DEXMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DEXMath.Contract.DEXMathCaller.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_DEXMath *DEXMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DEXMath.Contract.DEXMathTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DEXMath *DEXMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DEXMath.Contract.DEXMathTransactor.contract.Transact(opts, method, params...)
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_DEXMath *DEXMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DEXMath.Contract.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_DEXMath *DEXMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DEXMath.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DEXMath *DEXMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DEXMath.Contract.contract.Transact(opts, method, params...)
+}