polymarket 0.1.0

//! ERC1155 token operations for Conditional Token Framework (CTF)

use alloy::network::TransactionBuilder;
use alloy::primitives::{Address, Bytes, U256};
use alloy::providers::{Provider, ProviderBuilder};

use crate::onchain::{
    contracts::IERC1155, wallet::OnchainClient, OnchainError, PositionId, Result,
    TransactionOptions,
};

/// ERC1155 (CTF token) operations
impl OnchainClient {
    /// Get CTF token balance for a specific position
    ///
    /// # Arguments
    /// * `position_id` - The position ID (token ID in ERC1155)
    ///
    /// # Example
    /// ```no_run
    /// # use polymarket_sdk::onchain::OnchainClientBuilder;
    /// # use alloy::primitives::U256;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let client = OnchainClientBuilder::new()
    ///     .mainnet()
    ///     .private_key("0x1234...")?
    ///     .build()?;
    ///
    /// let position_id = U256::from(12345);
    /// let balance = client.get_ctf_balance(position_id).await?;
    /// println!("Position balance: {}", balance);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn get_ctf_balance(&self, position_id: PositionId) -> Result<U256> {
        self.get_ctf_balance_of(self.address(), position_id).await
    }

    /// Get CTF token balance for a specific address and position
    ///
    /// # Arguments
    /// * `owner` - The address to check balance for
    /// * `position_id` - The position ID (token ID in ERC1155)
    pub async fn get_ctf_balance_of(
        &self,
        owner: Address,
        position_id: PositionId,
    ) -> Result<U256> {
        let contract = IERC1155::new(self.addresses().ctf, self.provider().provider());

        let balance = contract
            .balanceOf(owner, position_id)
            .call()
            .await
            .map_err(|e| {
                OnchainError::ContractError(format!("Failed to get CTF balance: {}", e))
            })?;

        Ok(balance)
    }

    /// Get batch balances for multiple positions
    ///
    /// # Arguments
    /// * `owners` - Array of owner addresses
    /// * `position_ids` - Array of position IDs (must match owners length)
    ///
    /// Returns a vector of balances corresponding to each (owner, position_id) pair
    pub async fn get_ctf_batch_balances(
        &self,
        owners: Vec<Address>,
        position_ids: Vec<PositionId>,
    ) -> Result<Vec<U256>> {
        if owners.len() != position_ids.len() {
            return Err(OnchainError::InvalidAmount(
                "Owners and position_ids must have the same length".to_string(),
            ));
        }

        let contract = IERC1155::new(self.addresses().ctf, self.provider().provider());

        let balances = contract
            .balanceOfBatch(owners.clone(), position_ids.clone())
            .call()
            .await
            .map_err(|e| {
                OnchainError::ContractError(format!("Failed to get batch balances: {}", e))
            })?;

        Ok(balances)
    }

    /// Check if an operator is approved for all CTF tokens
    ///
    /// # Arguments
    /// * `operator` - The operator address (e.g., Exchange contract)
    pub async fn is_ctf_approved_for_all(&self, operator: Address) -> Result<bool> {
        self.is_ctf_approved_for_all_by(self.address(), operator)
            .await
    }

    /// Check if an operator is approved for all CTF tokens for a specific owner
    ///
    /// # Arguments
    /// * `owner` - The token owner address
    /// * `operator` - The operator address
    pub async fn is_ctf_approved_for_all_by(
        &self,
        owner: Address,
        operator: Address,
    ) -> Result<bool> {
        let contract = IERC1155::new(self.addresses().ctf, self.provider().provider());

        let approved = contract
            .isApprovedForAll(owner, operator)
            .call()
            .await
            .map_err(|e| {
                OnchainError::ContractError(format!("Failed to check approval: {}", e))
            })?;

        Ok(approved)
    }

    /// Set approval for all CTF tokens
    ///
    /// Grants or revokes permission for an operator to manage all CTF tokens
    ///
    /// # Arguments
    /// * `operator` - The operator address (e.g., Exchange contract)
    /// * `approved` - True to grant approval, false to revoke
    /// * `options` - Transaction options (gas, confirmations, etc.)
    ///
    /// # Example
    /// ```no_run
    /// # use polymarket_sdk::onchain::OnchainClientBuilder;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let client = OnchainClientBuilder::new()
    ///     .mainnet()
    ///     .private_key("0x1234...")?
    ///     .build()?;
    ///
    /// // Approve exchange to trade CTF tokens
    /// client.set_ctf_approval_for_all(
    ///     client.addresses().exchange,
    ///     true,
    ///     None,
    /// ).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn set_ctf_approval_for_all(
        &self,
        operator: Address,
        approved: bool,
        options: Option<TransactionOptions>,
    ) -> Result<alloy::primitives::TxHash> {
        let wallet = self.ethereum_wallet();

        // Build the provider with wallet
        let url = self.network().rpc_url.parse().map_err(|e| {
            OnchainError::NetworkError(format!("Invalid RPC URL: {}", e))
        })?;

        let provider = ProviderBuilder::new()
            .wallet(wallet)
            .connect_http(url);

        let contract = IERC1155::new(self.addresses().ctf, &provider);

        let call = contract.setApprovalForAll(operator, approved);

        // Apply transaction options if provided
        let tx = if let Some(opts) = options {
            let mut builder = call.into_transaction_request();

            if let Some(gas_price) = opts.gas_price {
                builder = builder.with_gas_price(gas_price.to::<u128>());
            }

            if let Some(gas_limit) = opts.gas_limit {
                builder = builder.with_gas_limit(gas_limit.to::<u64>());
            }

            // Send the transaction
            let pending = provider
                .send_transaction(builder)
                .await
                .map_err(|e| OnchainError::TransactionFailed(format!("Failed to send: {}", e)))?;

            if opts.wait_for_confirmation {
                let receipt = pending
                    .with_required_confirmations(opts.confirmations.unwrap_or(1))
                    .get_receipt()
                    .await
                    .map_err(|e| {
                        OnchainError::TransactionFailed(format!("Failed to confirm: {}", e))
                    })?;

                receipt.transaction_hash
            } else {
                *pending.tx_hash()
            }
        } else {
            // Send without custom options
            let pending = call
                .send()
                .await
                .map_err(|e| OnchainError::TransactionFailed(format!("Failed to send: {}", e)))?;

            *pending.tx_hash()
        };

        Ok(tx)
    }

    /// Transfer a single CTF token to another address
    ///
    /// # Arguments
    /// * `to` - The recipient address
    /// * `position_id` - The position ID to transfer
    /// * `amount` - The amount to transfer
    /// * `data` - Additional data (usually empty)
    /// * `options` - Transaction options (gas, confirmations, etc.)
    pub async fn transfer_ctf(
        &self,
        to: Address,
        position_id: PositionId,
        amount: U256,
        data: Option<Bytes>,
        options: Option<TransactionOptions>,
    ) -> Result<alloy::primitives::TxHash> {
        let wallet = self.ethereum_wallet();

        // Build the provider with wallet
        let url = self.network().rpc_url.parse().map_err(|e| {
            OnchainError::NetworkError(format!("Invalid RPC URL: {}", e))
        })?;

        let provider = ProviderBuilder::new()
            .wallet(wallet)
            .connect_http(url);

        let contract = IERC1155::new(self.addresses().ctf, &provider);

        let data = data.unwrap_or_default();
        let call = contract.safeTransferFrom(self.address(), to, position_id, amount, data);

        // Apply transaction options if provided
        let tx = if let Some(opts) = options {
            let mut builder = call.into_transaction_request();

            if let Some(gas_price) = opts.gas_price {
                builder = builder.with_gas_price(gas_price.to::<u128>());
            }

            if let Some(gas_limit) = opts.gas_limit {
                builder = builder.with_gas_limit(gas_limit.to::<u64>());
            }

            // Send the transaction
            let pending = provider
                .send_transaction(builder)
                .await
                .map_err(|e| OnchainError::TransactionFailed(format!("Failed to send: {}", e)))?;

            if opts.wait_for_confirmation {
                let receipt = pending
                    .with_required_confirmations(opts.confirmations.unwrap_or(1))
                    .get_receipt()
                    .await
                    .map_err(|e| {
                        OnchainError::TransactionFailed(format!("Failed to confirm: {}", e))
                    })?;

                receipt.transaction_hash
            } else {
                *pending.tx_hash()
            }
        } else {
            // Send without custom options
            let pending = call
                .send()
                .await
                .map_err(|e| OnchainError::TransactionFailed(format!("Failed to send: {}", e)))?;

            *pending.tx_hash()
        };

        Ok(tx)
    }

    /// Transfer multiple CTF tokens in a single transaction
    ///
    /// # Arguments
    /// * `to` - The recipient address
    /// * `position_ids` - Array of position IDs to transfer
    /// * `amounts` - Array of amounts (must match position_ids length)
    /// * `data` - Additional data (usually empty)
    /// * `options` - Transaction options (gas, confirmations, etc.)
    pub async fn transfer_ctf_batch(
        &self,
        to: Address,
        position_ids: Vec<PositionId>,
        amounts: Vec<U256>,
        data: Option<Bytes>,
        options: Option<TransactionOptions>,
    ) -> Result<alloy::primitives::TxHash> {
        if position_ids.len() != amounts.len() {
            return Err(OnchainError::InvalidAmount(
                "Position IDs and amounts must have the same length".to_string(),
            ));
        }

        let wallet = self.ethereum_wallet();

        // Build the provider with wallet
        let url = self.network().rpc_url.parse().map_err(|e| {
            OnchainError::NetworkError(format!("Invalid RPC URL: {}", e))
        })?;

        let provider = ProviderBuilder::new()
            .wallet(wallet)
            .connect_http(url);

        let contract = IERC1155::new(self.addresses().ctf, &provider);

        let data = data.unwrap_or_default();
        let call = contract.safeBatchTransferFrom(
            self.address(),
            to,
            position_ids,
            amounts,
            data,
        );

        // Apply transaction options if provided
        let tx = if let Some(opts) = options {
            let mut builder = call.into_transaction_request();

            if let Some(gas_price) = opts.gas_price {
                builder = builder.with_gas_price(gas_price.to::<u128>());
            }

            if let Some(gas_limit) = opts.gas_limit {
                builder = builder.with_gas_limit(gas_limit.to::<u64>());
            }

            // Send the transaction
            let pending = provider
                .send_transaction(builder)
                .await
                .map_err(|e| OnchainError::TransactionFailed(format!("Failed to send: {}", e)))?;

            if opts.wait_for_confirmation {
                let receipt = pending
                    .with_required_confirmations(opts.confirmations.unwrap_or(1))
                    .get_receipt()
                    .await
                    .map_err(|e| {
                        OnchainError::TransactionFailed(format!("Failed to confirm: {}", e))
                    })?;

                receipt.transaction_hash
            } else {
                *pending.tx_hash()
            }
        } else {
            // Send without custom options
            let pending = call
                .send()
                .await
                .map_err(|e| OnchainError::TransactionFailed(format!("Failed to send: {}", e)))?;

            *pending.tx_hash()
        };

        Ok(tx)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::onchain::{NetworkConfig, OnchainProvider, OnchainSigner};
    use alloy::network::AnyNetwork;
    use alloy::providers::{ProviderBuilder, Provider};

    const TEST_PRIVATE_KEY: &str =
        "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";

    fn create_test_client() -> OnchainClient {
        let network = NetworkConfig::polygon_mainnet();
        let provider = OnchainProvider {
            provider: ProviderBuilder::new()
                .network::<AnyNetwork>()
                .connect_http(network.rpc_url.parse().unwrap())
                .erased(),
            network: network.clone(),
        };
        let signer = OnchainSigner::from_private_key(TEST_PRIVATE_KEY).unwrap();

        OnchainClient::new(provider, signer)
    }

    #[test]
    fn test_batch_validation() {
        let client = create_test_client();

        // Test mismatched lengths
        let owners = vec![Address::ZERO];
        let position_ids = vec![U256::ZERO, U256::from(1)];

        let result = tokio::runtime::Runtime::new()
            .unwrap()
            .block_on(client.get_ctf_batch_balances(owners, position_ids));

        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("must have the same length"));
    }

    #[test]
    fn test_transfer_batch_validation() {
        let client = create_test_client();

        // Test mismatched lengths
        let position_ids = vec![U256::ZERO];
        let amounts = vec![U256::from(1), U256::from(2)];

        let result = tokio::runtime::Runtime::new().unwrap().block_on(
            client.transfer_ctf_batch(Address::ZERO, position_ids, amounts, None, None),
        );

        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("must have the same length"));
    }
}