O LogiChain é uma solução revolucionária que utiliza tecnologia blockchain para criar um sistema de delivery verdadeiramente descentralizado e justo. Nossa plataforma elimina intermediários, garante transparência total e assegura remuneração justa para entregadores através de smart contracts imutáveis e auditáveis.
Problema: Entregadores recebem em média R$ 8,70/h, com custos operacionais de R$ 0,90/km, resultando em prejuízo.
Solução LogiChain: Smart contracts calculam automaticamente a remuneração considerando:
contract DeliveryPayment {
struct Costs {
uint256 fuelPrice; // Preço atual do combustível
uint256 maintenance; // Custo de manutenção/km
uint256 depreciation; // Taxa de depreciação/km
uint256 taxes; // Tributos aplicáveis
}
function calculateFare(
uint256 minutes,
uint256 distance,
uint256 waitTime,
Costs memory costs
) public view returns (uint256) {
// Cálculo transparente e auditável
return baseTime * minutes +
baseDistance * distance +
waitTime * waitRate +
(costs.fuelPrice + costs.maintenance +
costs.depreciation) * distance +
costs.taxes;
}
}
Problema: Uma única empresa detém 84,7% do mercado, impondo regras unilaterais.
Solução LogiChain:
Problema: Ausência de direitos, jornadas excessivas e riscos não compensados.
Solução LogiChain:
| Aspecto | Modelo Atual | LogiChain |
|---|---|---|
| Remuneração Base | R$ 8,70/h (prejuízo) | ≥ R$ 18,00/h (lucro real) |
| Custos Operacionais | Não cobertos | 100% cobertos + depreciação |
| Transparência | Algoritmo fechado | Smart contracts públicos |
| Proteção Social | Inexistente | Fundo DAO + Seguros |
Ganho real projetado
Auditabilidade
Fundo DAO
O LogiChain representa uma revolução completa no mercado de entregas, resolvendo os problemas estruturais do modelo atual através da tecnologia blockchain. Nossa solução garante remuneração justa, transparência total, proteção social e governança participativa, criando um ecossistema verdadeiramente sustentável para todos os participantes.
Brasil (2023)
Brasil (2025)
Mercado (2024)
| País | Gasolina | Custo/km | Custos Totais |
|---|---|---|---|
| Brasil | R$ 6,28/L | R$ 0,15-0,20/km | R$ 0,80-0,90/km |
| Portugal | € 1,68/L | € 0,04-0,06/km | Proporcional |
| Reino Unido | £ 1,32/L | £ 0,04-0,06/km | Proporcional |
Combustível: R$ 300,00 Manutenção: R$ 200,00 Seguro: R$ 120,00 Depreciação: R$ 200,00 Tributos: R$ 70,00 -------------------------------- Total: R$ 890,00 (~1000 km)
| Item | Atual | Reivindicado |
|---|---|---|
| Taxa mínima/entrega | Variável | R$ 10,00 |
| Quilometragem | R$ 1,50/km | R$ 2,50/km |
| Limite bicicleta | Não definido | 3 km |
Tarifa = A·(minutos) + B·(km) + C·(custo_operacional/km) + D·(depreciação/km) + tributo Onde: A = Taxa por tempo B = Taxa por distância C = Custo operacional real (combustível, manutenção) D = Taxa de depreciação do veículo Tributo = Percentual para cobertura fiscal/previdenciária
Aumento Projetado
Via Smart Contract
Peer-to-Peer
O arquivo blockchain/core/pod.py implementa o Proof of Delivery, que garante o registro imutável de tempo, distância e custos de cada entrega.
class ProofOfDelivery:
def __init__(self, delivery_id: str, driver_id: str):
self.delivery_id = delivery_id
self.driver_id = driver_id
self.checkpoints: List[GeoPoint] = []
self.start_time: Optional[int] = None
self.end_time: Optional[int] = None
self.costs = DeliveryCosts()
def add_checkpoint(self, point: GeoPoint) -> None:
"""Adiciona checkpoint com validação de GPS"""
if point.accuracy and point.accuracy > PoDConfig.MIN_ACCURACY:
raise ValueError("Precisão GPS insuficiente")
self.checkpoints.append(point)
def calculate_compensation(self) -> Decimal:
"""Calcula compensação total incluindo custos operacionais"""
distance = self.calculate_total_distance()
duration = self.calculate_duration()
wait_time = self.calculate_wait_time()
return (
self.costs.base_rate +
(self.costs.per_km * distance) +
(self.costs.per_minute * duration) +
(self.costs.wait_rate * wait_time) +
self.calculate_risk_bonus()
)
O arquivo blockchain/core/costs.py implementa o sistema de custos operacionais com oráculos para preços atualizados.
class DeliveryCosts:
def __init__(self):
self.oracle = PriceOracle()
self.update_costs()
def update_costs(self) -> None:
"""Atualiza custos via oráculos"""
fuel_price = self.oracle.get_fuel_price()
maintenance = self.oracle.get_maintenance_cost()
depreciation = self.calculate_depreciation()
self.per_km = (
(fuel_price / AVG_CONSUMPTION) + # Combustível
maintenance + # Manutenção
depreciation + # Depreciação
INSURANCE_COST_PER_KM # Seguro
)
# Adiciona margem de segurança
self.per_km *= Decimal('1.1')
+------------------+ +----------------------+ +------------------+
| Entregas | | Reputação | | LogiTokens |
| | | | | |
| [Avaliação] | | {Score} | | (Nativo) |
| ↓ | | ↓ | | ↓ |
| [Feedback]-------|---->| {Cálculo}-----------|---->| (Mint) |
| ↓ | | ↓ | | ↓ |
| [Histórico] | | {Ranking} | | (Staking) |
+------------------+ +----------------------+ +------------------+
| País | Fonte | Data | Preço Gasolina |
|---|---|---|---|
| Brasil | GlobalPetrolPrices | 26-Mai-2025 | BRL 6,28/L (US$1,12/L) |
| Portugal | GlobalPetrolPrices | 26-Mai-2025 | EUR 1,68/L (US$1,92/L) |
| Reino Unido | GlobalPetrolPrices | 26-Mai-2025 | GBP 1,32/L (US$1,79/L) |
| Indicador | Valor | Fonte/Ano |
|---|---|---|
| Concentração de Mercado (iFood) | 84,7% | UFPR (2024) |
| Ganho Médio Apps | R$ 8,70/h | IBGE (2023) |
| Ganho Médio Externos | R$ 11,90/h | IBGE (2023) |
| Queda Real Ganhos 10 Anos | -72% | Sindicatos (2024) |
| Aumento Salarial Formalizados | +99% | Sindicatos (2024) |
Este relatório técnico foi elaborado com base em:
O arquivo blockchain/social/insurance.py implementa o sistema de seguro automático.
class DeliveryInsurance:
def __init__(self, driver_id: str):
self.driver_id = driver_id
self.fund = InsuranceFund()
self.claims = ClaimRegistry()
async def create_coverage(self, delivery: Delivery) -> None:
"""Cria cobertura automática para entrega"""
premium = self.calculate_premium(delivery)
# Deduz premium do pagamento
await self.fund.collect_premium(
delivery_id=delivery.id,
amount=premium
)
# Registra cobertura
coverage = Coverage(
delivery_id=delivery.id,
driver_id=self.driver_id,
amount=delivery.value * 2, # 200% cobertura
premium=premium
)
await self.register_coverage(coverage)
O arquivo blockchain/social/fund.py implementa o fundo social descentralizado.
class SocialFund:
def __init__(self):
self.dao = LogiChainDAO()
self.treasury = Treasury()
async def distribute_benefits(self) -> None:
"""Distribui benefícios sociais"""
eligible = await self.dao.get_eligible_drivers()
for driver in eligible:
# Calcula benefícios
health = await self.calculate_health_benefit(driver)
retirement = await self.calculate_retirement(driver)
# Distribui via smart contract
await self.treasury.distribute(
address=driver.address,
health_benefit=health,
retirement_benefit=retirement
)
O arquivo blockchain/governance/dao.py implementa o sistema de governança descentralizada.
class LogiChainDAO:
def __init__(self):
self.token = GovernanceToken()
self.proposals = ProposalRegistry()
async def submit_proposal(
self,
proposer: str,
description: str,
changes: Dict[str, Any]
) -> str:
"""Submete proposta de mudança"""
if not await self.token.has_proposal_rights(proposer):
raise PermissionError("Tokens insuficientes")
proposal_id = await self.proposals.create(
proposer=proposer,
description=description,
changes=changes,
voting_period=VOTING_PERIOD
)
await self.token.lock_voting_tokens(proposer)
return proposal_id
O arquivo blockchain/governance/voting.py implementa o sistema de votação.
class VotingSystem:
def __init__(self):
self.dao = LogiChainDAO()
self.token = GovernanceToken()
async def cast_vote(
self,
voter: str,
proposal_id: str,
support: bool
) -> None:
"""Registra voto em proposta"""
voting_power = await self.token.get_voting_power(voter)
if voting_power == 0:
raise ValueError("Sem poder de voto")
await self.proposals.vote(
proposal_id=proposal_id,
voter=voter,
support=support,
weight=voting_power
)
O arquivo blockchain/payments/processor.py implementa o processamento automático de pagamentos.
class PaymentProcessor:
def __init__(self):
self.treasury = Treasury()
self.tax = TaxSystem()
async def process_payment(
self,
delivery: Delivery,
amount: Decimal
) -> None:
"""Processa pagamento com tributos"""
# Calcula tributos
taxes = self.tax.calculate_taxes(amount)
net_amount = amount - taxes
# Distribui pagamento
await self.treasury.distribute_payment(
driver_id=delivery.driver_id,
amount=net_amount,
taxes=taxes,
proof=delivery.pod.generate_proof()
)
# Registra para fins fiscais
await self.tax.register_transaction(
delivery_id=delivery.id,
gross_amount=amount,
taxes=taxes,
timestamp=int(time.time())
)
O arquivo blockchain/payments/tax.py implementa o sistema tributário automático.
class TaxSystem:
def __init__(self):
self.rates = TaxRates()
self.registry = TaxRegistry()
def calculate_taxes(self, amount: Decimal) -> Decimal:
"""Calcula tributos aplicáveis"""
return (
amount * self.rates.income_tax +
amount * self.rates.social_security +
amount * self.rates.municipal_tax
)
async def generate_tax_report(
self,
driver_id: str,
period: str
) -> TaxReport:
"""Gera relatório fiscal do período"""
transactions = await self.registry.get_transactions(
driver_id=driver_id,
period=period
)
return TaxReport(
driver_id=driver_id,
period=period,
transactions=transactions,
total_income=sum(t.amount for t in transactions),
total_taxes=sum(t.taxes for t in transactions)
)
blockchain/
├── core/
│ ├── __init__.py
│ ├── pod.py # Proof of Delivery
│ ├── costs.py # Sistema de Custos
│ ├── chain.py # Blockchain Core
│ └── config.py # Configurações
│
├── reputation/
│ ├── __init__.py
│ ├── system.py # Sistema de Reputação
│ ├── token.py # Token ERC-20
│ └── storage.py # Armazenamento de Ratings
│
├── social/
│ ├── __init__.py
│ ├── insurance.py # Sistema de Seguros
│ ├── fund.py # Fundo Social
│ └── benefits.py # Cálculo de Benefícios
│
├── governance/
│ ├── __init__.py
│ ├── dao.py # Governança DAO
│ ├── voting.py # Sistema de Votação
│ └── proposals.py # Gestão de Propostas
│
├── payments/
│ ├── __init__.py
│ ├── processor.py # Processador de Pagamentos
│ ├── tax.py # Sistema Tributário
│ └── treasury.py # Tesouraria
│
├── network/
│ ├── __init__.py
│ ├── p2p.py # Rede P2P
│ ├── consensus.py # Consenso PoD
│ └── sync.py # Sincronização
│
└── api/
├── __init__.py
├── rest.py # API REST
├── websocket.py # WebSocket Server
└── routes.py # Rotas da API
+------------------+ +----------------------+ +------------------+
| GPS Tracking | | Proof of Work | | Smart Contract |
| | | | | |
| [Localização] | | {Validação} | | (Pagamento) |
| ↓ | | ↓ | | ↓ |
| [Distância]------|---->| {Proof}-------------|---->| (Cálculo) |
| ↓ | | ↓ | | ↓ |
| [Tempo] | | {Hash} | | (Execução) |
+------------------+ +----------------------+ +------------------+
↓ ↓ ↓
+------------------+ +----------------------+ +------------------+
| Oráculos | | Custos | | Blockchain |
| | | | | (Registro) |
| [Combustível] | | {Manutenção} | | ↓ |
| ↓ | | ↓ | | (Imutável) |
| [Preços]---------|---->| {Depreciação}-------|---->| (Confirmação) |
| ↓ | | ↓ | | (Imutável) |
| [Manutenção] | | {Total} | | (Imutável) |
+------------------+ +----------------------+ +------------------+
+------------------+ +----------------------+ +------------------+
| Entregas | | Reputação | | LogiTokens |
| | | | | |
| [Avaliação] | | {Score} | | (Nativo) |
| ↓ | | ↓ | | ↓ |
| [Feedback]-------|---->| {Cálculo}-----------|---->| (Mint) |
| ↓ | | ↓ | | ↓ |
| [Histórico] | | {Ranking} | | (Staking) |
+------------------+ +----------------------+ +------------------+
+------------------+ +----------------------+ +------------------+
| Seguros | | Fundo Social | | Benefícios |
| | | | | (Saúde) |
| [Cobertura] | | {Contribuições} | | (Previdência) |
| ↓ | | ↓ | | ↓ |
| [Prêmio]---------|---->| {Gestão}------------|---->| (Previdência) |
| ↓ | | ↓ | | ↓ |
| [Sinistros] | | {Distribuição} | | (Auxílios) |
+------------------+ +----------------------+ +------------------+
↓ ↓ ↓
+------------------+ +----------------------+ +------------------+
| Oráculos | | Smart Contract | | DAO |
| | | | | (Governança) |
| [Riscos] | | {Automação} | | (Aprovação) |
| ↓ | | ↓ | | ↓ |
| [Preços]---------|---->| {Execução}----------|---->| (Ajustes) |
| ↓ | | ↓ | | ↓ |
| [Estatísticas] | | {Registro} | | (Ajustes) |
+------------------+ +----------------------+ +------------------+
+------------------+ +----------------------+ +------------------+
| Propostas | | Votação | | Execução |
| | | | | |
| [Submissão] | | {Token Weight} | | (Smart Contract)|
| ↓ | | ↓ | | ↓ |
| [Discussão]------|---->| {Quorum}------------|---->| (Implementação) |
| ↓ | | ↓ | | ↓ |
| [Revisão] | | {Resultado} | | (Atualização) |
+------------------+ +----------------------+ +------------------+
↓ ↓ ↓
+------------------+ +----------------------+ +------------------+
| Tokens | | Parâmetros | | Registro |
| | | | | (Blockchain) |
| [Staking] | | {Sistema} | | (Imutável) |
| ↓ | | ↓ | | ↓ |
| [Poder]----------|---->| {Ajustes}-----------|---->| (Imutável) |
| ↓ | | ↓ | | ↓ |
| [Bloqueio] | | {Limites} | | (Auditável) |
+------------------+ +----------------------+ +------------------+
+------------------+ +----------------------+ +------------------+
| Nós | | Consenso | | Blocos |
| | | | | |
| [Validador] | | {PoD} | | (Transações) |
| ↓ | | ↓ | | ↓ |
| [Minerador]------|---->| {Verificação}-------|---->| (Hash) |
| ↓ | | ↓ | | ↓ |
| [Full Node] | | {Finalização} | | (Merkle) |
+------------------+ +----------------------+ +------------------+
↓ ↓ ↓
+------------------+ +----------------------+ +------------------+
| P2P | | Sincronização | | Estado |
| | | | | |
| [Descoberta] | | {Blocos} | | (Mempool) |
| ↓ | | ↓ | | ↓ |
| [Conexão]--------|---->| {Estado}------------|---->| (UTXO) |
| ↓ | | ↓ | | ↓ |
| [Propagação] | | {Validação} | | (Storage) |
+------------------+ +----------------------+ +------------------+
[Cliente] ----Pedido----> [Smart Contract] ----Matching----> [Entregador] ↓ ↓ ↓ [Pagamento] <---Escrow---- [Contrato] ----Tracking GPS----> [Coleta] ↓ ↓ ↓ [Confirmação] <--Liberação-- [PoD] <----Checkpoints----- [Transporte] ↓ ↓ ↓ [Avaliação] ----Rating----> [Reputação] <---Entrega----- [Finalização] ↓ ↓ ↓ [Feedback] ----Métricas---> [Sistema] ----Recompensa----> [Pagamento] +------------------+ +----------------------+ +------------------+ | Processo | | Validação | | Resultado | | | | | | | | 1. Pedido | | - GPS Check | | → Pagamento | | 2. Matching | | - Tempo Check | | → Reputação | | 3. Coleta | | - Distância Check | | → Benefícios | | 4. Transporte | | - Custos Check | | → Seguros | | 5. Entrega | | - Proof Check | | → Métricas | | 6. Confirmação | | - Rating Check | | → Histórico | +------------------+ +----------------------+ +------------------+
Ganho real projetado
Auditabilidade
Fundo DAO