docs: def send(self, wallet_id, passcode, address, amount, message='', fee=None, fan_unspend=10):
          """
          Send bitcoins to address
  
          :param wallet_id: bitgo wallet id
          :param address: bitcoin address
          :param amount: btc amount in satoshis
          :param split: create new outputs if needed
          :return: boolean
          """
          MINIMAL_FEE = 20000
          MINIMAL_SPLIT = 10000000
  
          wallet = self.get_wallet(wallet_id)
  
          if not wallet['spendingAccount']:
              raise NotSpendableWallet()
  
          if not wallet['isActive']:
              raise NotActiveWallet()
  
          if amount < 10000:
              raise Exception('amount to small')
  
          if wallet['confirmedBalance'] < amount:
              raise NotEnoughFunds('Not enough funds: balance %s amount %s' %
                                   (wallet['confirmedBalance'], amount)
              )
  
          change_address = self.create_address(wallet_id, chain=1)
          usableKeychain = False
          spendables = []
          chain_paths = []
          p2sh = []
          payables = [(address, amount)]
          keychain_path = ""
  
          for keychain in wallet['private']['keychains']:
              keychain_path = keychain['path'][1:]
              keychain = self.get_keychain(keychain['xpub'])
              if 'encryptedXprv' not in keychain:
                  continue
              usableKeychain = True
              break
  
          if not usableKeychain:
              raise BitGoError("didn't found a spendable keychain")
  
          data = json.loads(keychain['encryptedXprv'])
          #add base64 paddings
          for k in ['iv', 'salt', 'ct']:
              data[k] = data[k] + "=="
          cipher = sjcl.SJCL()
          xprv = cipher.decrypt(data, passcode)
  
          unspents = self.get_unspents(wallet_id)
          unspents = filter(lambda u: u['confirmations'] > 0, unspents['unspents'][::-1])
  
          total_value = 0
          for d in unspents:
              path = keychain_path + d['chainPath']
              chain_paths.append(path)
              p2sh.append(h2b(d["redeemScript"]))
              spendables.append(Spendable(d["value"],
                                    h2b(d["script"]),
                                    h2b_rev(d["tx_hash"]),
                                    d["tx_output_n"]))
  
              total_value += d['value']
              if total_value > amount:
                  break
  
          # make many outputs?
          if len(unspents) < 5 and (total_value > (amount + MINIMAL_SPLIT)) and fan_unspend > 0:
              fee = self.calculate_fee(len(spendables), fan_unspend)
              value = (total_value - amount - fee) / fan_unspend
              for i in range(fan_unspend):
                  payables.append((change_address, value))
          elif total_value > (amount + MINIMAL_FEE):
              # add a change address
              if fee is None:
                  fee = self.calculate_fee(len(spendables), 2)
              value = total_value - amount - fee
              if value > 10000: #avoid dust
                  payables.append((change_address, value))
  
          p2sh_lookup = build_p2sh_lookup(p2sh)
  
          spendable_keys = []
  
          priv_key = BIP32Node.from_hwif(xprv)
  
          spendable_keys = [priv_key.subkey_for_path(path) for path in chain_paths]
  
          hash160_lookup = build_hash160_lookup([key.secret_exponent() for key in spendable_keys])
  
          tx = create_tx(spendables, payables)
  
          tx.sign(hash160_lookup=hash160_lookup, p2sh_lookup=p2sh_lookup)
  
          r = requests.post(self.url + '/tx/send', {
                  'tx': tx.as_hex(),
                  'message': message
              }, headers={
                  'Authorization': 'Bearer %s' % self.access_token,
              })
  
          return r.json()