Pledging with fungible tokens

/// NEP-141 receiver: msg is the campaign id. Returns the amount NOT used.
pub fn ft_on_transfer(
    &mut self,
    sender_id: AccountId,
    amount: U128,
    msg: String,
) -> PromiseOrValue<U128> {
    let token = env::predecessor_account_id();
    let campaign_id: CampaignId = msg
        .parse()
        .unwrap_or_else(|_| env::panic_str("msg must be a campaign id"));
    let campaign = self.campaign(campaign_id);
    require!(campaign.token.as_ref() == Some(&token), "token not accepted by this campaign");

    let ended = env::block_timestamp_ms() >= campaign.deadline_ms;
    let registered = self.pledges.contains_key(&(campaign_id, sender_id.clone()));
    if ended || !registered {
        env::log_str("pledge not accepted: campaign ended or backer not registered");
        return PromiseOrValue::Value(amount); // every token goes back
    }

    self.add_pledge(campaign_id, &sender_id, amount.0);
    PromiseOrValue::Value(U128(0))
}

/// Pre-pay the storage for a backer record (needed before an FT pledge).
#[payable]
pub fn register_backer(&mut self, campaign_id: CampaignId) {
    let backer = env::predecessor_account_id();
    require!(
        env::block_timestamp_ms() < self.campaign(campaign_id).deadline_ms,
        "campaign has ended"
    );
    let cost = self.ensure_backer(campaign_id, &backer);
    refund_excess(&backer, cost);
}

use near_sdk::{
    env, ext_contract, near, require, AccountId, BorshStorageKey, Gas, NearToken, PanicOnDefault,
    Promise, PromiseError, PromiseOrValue,
};

const GAS_FT_TRANSFER: Gas = Gas::from_tgas(10);
const ONE_YOCTO: NearToken = NearToken::from_yoctonear(1);

#[ext_contract(ext_ft)]
pub trait FungibleToken {
    fn ft_transfer(&mut self, receiver_id: AccountId, amount: U128, memo: Option<String>);
}

/// Sends amount of the campaign currency: native NEAR or a NEP-141 token.
fn pay(token: &Option<AccountId>, to: AccountId, amount: u128) -> Promise {
    match token {
        None => Promise::new(to).transfer(NearToken::from_yoctonear(amount)),
        Some(token) => ext_ft::ext(token.clone())
            .with_attached_deposit(ONE_YOCTO)
            .with_static_gas(GAS_FT_TRANSFER)
            .ft_transfer(to, U128(amount), None),
    }
}

// in claim
campaign.claimed = true; // effects before the interaction
let payout = pay(&campaign.token, campaign.creator.clone(), campaign.raised);
payout.then(
    Self::ext(env::current_account_id())
        .with_static_gas(GAS_CALLBACK)
        .on_claim(campaign_id),
)

// in refund: copy the token out before the pledges write
let token = campaign.token.clone();
// ... checks, deduct first ...
pay(&token, backer.clone(), amount).then(
    Self::ext(env::current_account_id())
        .with_static_gas(GAS_CALLBACK)
        .on_refund(campaign_id, backer, U128(amount)),
)

# 0. once: our contract must be registered with the token to hold it.
#    check what registration costs, then pay it for the contract account
near contract call-function as-read-only your-token.testnet storage_balance_bounds \
  json-args '{}' network-config testnet now
near contract call-function as-transaction your-token.testnet storage_deposit \
  json-args '{"account_id": "crowdfund.you.testnet"}' \
  prepaid-gas '30 Tgas' attached-deposit '0.01 NEAR' \
  sign-as you.testnet network-config testnet sign-with-keychain send

# 1. the backer pays for their record in campaign 1 (excess is refunded)
near contract call-function as-transaction crowdfund.you.testnet register_backer \
  json-args '{"campaign_id": 1}' \
  prepaid-gas '30 Tgas' attached-deposit '0.01 NEAR' \
  sign-as alice.testnet network-config testnet sign-with-keychain send

# 2. pledge: call the TOKEN, with our contract as receiver and the campaign id as msg
near contract call-function as-transaction your-token.testnet ft_transfer_call \
  json-args '{"receiver_id": "crowdfund.you.testnet", "amount": "5000000", "msg": "1"}' \
  prepaid-gas '100 Tgas' attached-deposit '1 yoctoNEAR' \
  sign-as alice.testnet network-config testnet sign-with-keychain send