Recognizing Crypto Scams

Go: open a terminal in a folder you can write to, e.g. cd ~/Desktop (Windows: cd %USERPROFILE%\Desktop).

Do: save this as compound.py and run python3 compound.py. One per cent a day is the most common figure in these offers, precisely because it sounds modest.

stake = 1_000
rate = 0.01                      # "1% per day, guaranteed"

for day in (30, 90, 365):
    value = stake * (1 + rate) ** day
    print(f"after {day:>3} days: {value:>28,.0f} dollars")

world_gdp = 100_000_000_000_000   # roughly the size of the whole world economy
days = 0
value = stake
while value < world_gdp:
    value *= 1 + rate
    days += 1
print(f"\nit passes the entire world economy after {days} days -- {days / 365:.1f} years")

You should see: a modest-looking first month, then the impossibility:

after  30 days:                        1,348 dollars
after  90 days:                        2,449 dollars
after 365 days:                       37,783 dollars

it passes the entire world economy after 2546 days -- 7.0 years

That is the test in one line. If a return can be compounded, and compounding it makes one thousand dollars larger than every economy on earth inside a decade, then the return is not available to anyone — because if it were, its owner would already have all the money there is. The exact size you compare against barely matters; the conclusion survives being wrong by a factor of ten.

If not: if the loop never ends, the multiplication line is value * 1 + rate instead of value *= 1 + rate, so the value is not being kept. OverflowError means rate was typed as 1 rather than 0.01.

Go: same folder. These are sold as “community”, “staking pools” or “referral rewards”; the mechanism is always this.

Do: save this as scheme.py and run it. Payouts come from new deposits and nowhere else, and recruitment grows until the pool of possible members runs out.

POPULATION = 100_000             # everyone who could ever be recruited
DEPOSIT = 1_000
PAYOUT = 0.10                    # 10% of your deposit, paid every month

joiners, members, pot, month = 100, 0, 0, 0
while True:
    month += 1
    joiners = min(int(joiners * 1.6), POPULATION - members)
    members += joiners
    pot += joiners * DEPOSIT
    owed = members * DEPOSIT * PAYOUT
    if owed > pot:
        break
    pot -= owed

print(f"the scheme collapses in month {month}")
print(f"people who joined      : {members:,}")
print(f"they paid in           : {members * DEPOSIT:,}")
print(f"left in the pot        : {pot:,.0f}")

You should see: a scheme that works perfectly for twenty months and then does not:

the scheme collapses in month 21
people who joined      : 100,000
they paid in           : 100,000,000
left in the pot        : 436,300

Nothing went wrong. Nobody stole anything in this model, no promise was broken, and the payouts were made in full every single month until the month they could not be. The collapse is not a risk of the design; it is the design. That is why testimonials from happy members prove nothing — in month 20 every member is a happy member.

If not: if it never breaks, the growth factor is high enough that deposits always outpace payouts — check that joiners is capped by POPULATION - members, which is the finite world these schemes forget.

Go: same folder. “My friend made money” is the strongest argument these schemes have. Test it.

Do: save this as who.py and run it. At 10% a month, a member needs ten months of payouts to get their deposit back.

POPULATION, DEPOSIT, PAYOUT = 100_000, 1_000, 0.10

joiners, members, pot, month = 100, 0, 0, 0
cohorts = []                      # (month joined, how many joined)
while True:
    month += 1
    joiners = min(int(joiners * 1.6), POPULATION - members)
    members += joiners
    cohorts.append((month, joiners))
    pot += joiners * DEPOSIT
    owed = members * DEPOSIT * PAYOUT
    if owed > pot:
        break
    pot -= owed

collapse = month
winners = sum(n for m, n in cohorts if (collapse - m) * PAYOUT > 1)
print(f"collapsed in month {collapse}")
print(f"joined and got their money back or more: {winners:,}")
print(f"joined and lost money                  : {members - winners:,}")
print(f"that is {(members - winners) / members:.1%} of everyone who joined")

You should see: the majority losing, by construction:

collapsed in month 21
joined and got their money back or more: 28,962
joined and lost money                  : 71,038
that is 71.0% of everyone who joined

Your friend who made money is real. So are the seventy-one thousand who did not, and they are quieter, because losing money to something you recommended is not a story people tell. Growth is what makes this inevitable: the later cohorts are always the biggest, so most members are always among the newest.

If not: if winners equals the total, the break-even test is inverted — a member profits only when (collapse - joined) * PAYOUT exceeds 1, meaning more than ten payouts.

Go: same folder. These arrive as a livestream with a famous face, a pinned reply, or a message from a hacked account.

Do: save this as giveaway.py and run it.

# "Send 1 coin to this address and we will send 2 back."
sent = [0.5, 1.0, 2.0, 1.0, 5.0, 0.2, 1.0, 3.0]
promised_back = [x * 2 for x in sent]

print(f"victims          : {len(sent)}")
print(f"coins they sent  : {sum(sent)}")
print(f"coins promised   : {sum(promised_back)}")
print(f"coins returned   : 0")
print()
print("for the promise to be real the giver would need to fund",
      f"{sum(promised_back)} coins to receive {sum(sent)} --",
      f"a loss of {sum(promised_back) - sum(sent)} coins for no reason")

You should see: the offer stated from the other side of the table:

victims          : 8
coins they sent  : 13.7
coins promised   : 27.4
coins returned   : 0

for the promise to be real the giver would need to fund 27.4 coins to receive 13.7 -- a loss of 13.7 coins for no reason

Ask of any offer: what does the other side get? A giveaway that doubles your money is a person volunteering to lose exactly as much as you gain, to a stranger, at scale. Genuine promotions ask you to sign up, follow or hold — they never ask you to send cryptocurrency first, because a real giver does not need your coins to give you theirs.

If not: if the sums print as long decimals like 13.700000000000001, that is ordinary floating-point rounding and does not affect the point — add round(..., 2) if it bothers you.

Go: same folder. This one arrives days after a loss, from a “recovery specialist” who found your post in a support group.

Do: save this as recovery.py and run it.

lost = 5_000
fees = [("release fee", 300), ("tax clearance", 750), ("wallet activation", 1_200),
        ("final anti-money-laundering deposit", 2_500)]

paid = 0
for name, amount in fees:
    paid += amount
    print(f"pay the {name:36s} {amount:>6,}   (total paid {paid:>6,})")

print(f"\nrecovered: 0")
print(f"you were down {lost:,}. You are now down {lost + paid:,}.")

You should see: the loss roughly doubling:

pay the release fee                             300   (total paid    300)
pay the tax clearance                           750   (total paid  1,050)
pay the wallet activation                     1,200   (total paid  2,250)
pay the final anti-money-laundering deposit   2,500   (total paid  4,750)

recovered: 0
you were down 5,000. You are now down 9,750.

Look at the shape: each fee is small compared with what is supposedly about to be returned, and each one is the last. That is deliberate, and it is why victims keep paying long past the point where they suspect. The rule that ends it: nobody who can genuinely recover funds needs money from you in advance. Real routes — the police, your bank, the exchange’s compliance team — are paid by someone else or not at all.

If not: ValueError: Invalid format specifier means the :>6, was mistyped — greater-than, six, comma. The list must stay a list of pairs, so each line needs its brackets.