public function testCurrentUtilsConversions() { // float value to satoshis PHPUnit::assertEquals(12300000000, CurrencyUtil::valueToSatoshis(123)); PHPUnit::assertEquals(2100000000000000, CurrencyUtil::valueToSatoshis(21000000)); PHPUnit::assertEquals(12311111119, CurrencyUtil::valueToSatoshis(123.111111189)); // satoshis to float value PHPUnit::assertEquals(123, CurrencyUtil::satoshisToValue(12300000000)); PHPUnit::assertEquals(21000000, CurrencyUtil::satoshisToValue(2100000000000000)); PHPUnit::assertEquals(123.11111119, CurrencyUtil::satoshisToValue(12311111119)); // satoshisToFormattedString PHPUnit::assertEquals('123', CurrencyUtil::satoshisToFormattedString(12300000000)); PHPUnit::assertEquals('123.4', CurrencyUtil::satoshisToFormattedString(12340000000)); PHPUnit::assertEquals('1,235.6', CurrencyUtil::satoshisToFormattedString(123560000000)); // valueToFormattedString PHPUnit::assertEquals('1,234.5', CurrencyUtil::valueToFormattedString(1234.5)); }
public function buildTransactionData($txid) { $enhanced_bitcoind_transaction = $this->loadTransactionFromBitcoind($txid); // enhance vins $enhanced_vins = []; foreach ($enhanced_bitcoind_transaction['vin'] as $n => $vin) { $enhanced_vins[] = $this->enhanceVin($vin, $n); } $enhanced_bitcoind_transaction['vin'] = $enhanced_vins; // values in, out and fees $enhanced_bitcoind_transaction['valueIn'] = 0.0; $enhanced_bitcoind_transaction['valueInSat'] = $this->sumValuesIn($enhanced_vins); $enhanced_bitcoind_transaction['valueIn'] = CurrencyUtil::satoshisToValue($enhanced_bitcoind_transaction['valueInSat']); $enhanced_bitcoind_transaction['valueOut'] = $this->sumValuesOut($enhanced_bitcoind_transaction['vout']); $enhanced_bitcoind_transaction['valueOutSat'] = CurrencyUtil::valueToSatoshis($enhanced_bitcoind_transaction['valueOut']); $enhanced_bitcoind_transaction['fees'] = 0.0; $enhanced_bitcoind_transaction['feesSat'] = $enhanced_bitcoind_transaction['valueInSat'] - $enhanced_bitcoind_transaction['valueOutSat']; $enhanced_bitcoind_transaction['fees'] = CurrencyUtil::satoshisToValue($enhanced_bitcoind_transaction['feesSat']); return $enhanced_bitcoind_transaction; }
/** * Get all balances for an address * * @param int $id * @return Response */ public function show(Client $xcpd_client, BitcoinPayer $bitcoin_payer, Cache $asset_info_cache, $address) { if (!AddressValidator::isValid($address)) { $message = "The address {$address} was not valid"; EventLog::logError('error.getBalance', ['address' => $address, 'message' => $message]); return new JsonResponse(['message' => $message], 500); } $balances = $xcpd_client->get_balances(['filters' => ['field' => 'address', 'op' => '==', 'value' => $address]]); // and get BTC balance too $btc_float_balance = $bitcoin_payer->getBalance($address); $balances = array_merge([['asset' => 'BTC', 'quantity' => $btc_float_balance]], $balances); $out = ['balances' => [], 'balancesSat' => []]; foreach ($balances as $balance) { $asset_name = $balance['asset']; if ($asset_name == 'BTC') { // BTC quantity is a float $quantity_float = floatval($balance['quantity']); $quantity_sat = CurrencyUtil::valueToSatoshis($balance['quantity']); } else { // determine quantity based on asset info $is_divisible = $asset_info_cache->isDivisible($asset_name); if ($is_divisible) { $quantity_float = CurrencyUtil::satoshisToValue($balance['quantity']); $quantity_sat = intval($balance['quantity']); } else { // non-divisible assets don't use satoshis $quantity_float = floatval($balance['quantity']); $quantity_sat = CurrencyUtil::valueToSatoshis($balance['quantity']); } } $out['balances'][$asset_name] = $quantity_float; $out['balancesSat'][$asset_name] = $quantity_sat; } ksort($out['balances']); ksort($out['balancesSat']); return json_encode($out); }
/** * gets a list of the current UTXOs that are primed * * @return Response */ public function getPrimedUTXOs($address_uuid, Guard $auth, Request $request, APIControllerHelper $helper, PaymentAddressRepository $payment_address_repository, TXORepository $txo_repository) { try { $user = $auth->getUser(); if (!$user) { throw new Exception("User not found", 1); } $payment_address = $helper->requireResourceOwnedByUser($address_uuid, $user, $payment_address_repository); $size = floatval($request->query('size')); if ($size <= 0) { throw new Exception("Invalid size", 400); } $size_satoshis = CurrencyUtil::valueToSatoshis($size); // get the UTXOs // [TXO::UNCONFIRMED, TXO::CONFIRMED] $txos = $this->filterGreenOrConfirmedUTXOs($txo_repository->findByPaymentAddress($payment_address, null, true)); // count the number that match the size $matching_count = 0; $total_count = 0; $filtered_txos = []; foreach ($txos as $txo) { if ($txo['amount'] == $size_satoshis) { ++$matching_count; } $filtered_txos[] = ['txid' => $txo['txid'], 'n' => $txo['n'], 'amount' => CurrencyUtil::satoshisToValue($txo['amount']), 'type' => TXO::typeIntegerToString($txo['type']), 'green' => !!$txo['type']]; ++$total_count; } $output = ['primedCount' => $matching_count, 'totalCount' => $total_count, 'utxos' => $filtered_txos]; return $helper->buildJSONResponse($output); } catch (Exception $e) { if ($e->getCode() >= 400 and $e->getCode() < 500) { throw new HttpResponseException(new JsonResponse(['errors' => [$e->getMessage()]], 400)); } throw $e; } }
public function buildParsedTransactionData($bitcoin_transaction_data, $ts) { try { $parsed_transaction_data = []; $parsed_transaction_data = ['txid' => $bitcoin_transaction_data['txid'], 'network' => 'bitcoin', 'timestamp' => round($ts / 1000), 'counterPartyTxType' => false, 'sources' => [], 'destinations' => [], 'values' => [], 'asset' => false, 'bitcoinTx' => $bitcoin_transaction_data, 'counterpartyTx' => []]; $xcp_data = $this->parser->parseBitcoinTransaction($bitcoin_transaction_data); if ($xcp_data) { // ensure 1 source and 1 desination if (!isset($xcp_data['sources'][0])) { $xcp_data['sources'] = ['unknown']; Log::error("No source found in transaction: " . ((isset($bitcoin_transaction_data) and isset($bitcoin_transaction_data['txid'])) ? $bitcoin_transaction_data['txid'] : "unknown")); } if (!isset($xcp_data['destinations'][0])) { $xcp_data['destinations'] = ['unknown']; Log::error("No destination found in transaction: " . ((isset($bitcoin_transaction_data) and isset($bitcoin_transaction_data['txid'])) ? $bitcoin_transaction_data['txid'] : "unknown")); } // this is a counterparty transaction $parsed_transaction_data['network'] = 'counterparty'; $parsed_transaction_data['counterPartyTxType'] = $xcp_data['type']; $parsed_transaction_data['sources'] = $xcp_data['sources']; $parsed_transaction_data['destinations'] = $xcp_data['destinations']; if ($xcp_data['type'] === 'send') { $is_divisible = $this->asset_cache->isDivisible($xcp_data['asset']); // if the asset info doesn't exist, assume it is divisible if ($is_divisible === null) { $is_divisible = true; } if ($is_divisible) { $quantity_sat = $xcp_data['quantity']; $quantity_float = CurrencyUtil::satoshisToValue($xcp_data['quantity']); } else { $quantity_sat = CurrencyUtil::valueToSatoshis($xcp_data['quantity']); $quantity_float = intval($xcp_data['quantity']); } $xcp_data['quantity'] = $quantity_float; $xcp_data['quantitySat'] = $quantity_sat; $destination = $xcp_data['destinations'][0]; $parsed_transaction_data['values'] = [$destination => $quantity_float]; $parsed_transaction_data['asset'] = $xcp_data['asset']; // dustSize // dustSizeSat list($sources, $quantity_by_destination) = $this->extractSourcesAndDestinations($bitcoin_transaction_data); $dust_size_float = isset($quantity_by_destination[$destination]) ? $quantity_by_destination[$destination] : 0; $xcp_data['dustSize'] = $dust_size_float; $xcp_data['dustSizeSat'] = CurrencyUtil::valueToSatoshis($dust_size_float); } // Log::debug("\$xcp_data=".json_encode($xcp_data, 192)); $parsed_transaction_data['counterpartyTx'] = $xcp_data; } else { // this is just a bitcoin transaction list($sources, $quantity_by_destination) = $this->extractSourcesAndDestinations($bitcoin_transaction_data); $parsed_transaction_data['network'] = 'bitcoin'; $parsed_transaction_data['sources'] = $sources; $parsed_transaction_data['destinations'] = array_keys($quantity_by_destination); $parsed_transaction_data['values'] = $quantity_by_destination; $parsed_transaction_data['asset'] = 'BTC'; } // add a blockheight if (isset($parsed_transaction_data['bitcoinTx']['blockhash']) and $hash = $parsed_transaction_data['bitcoinTx']['blockhash']) { $block = $this->blockchain_store->findByHash($hash); $parsed_transaction_data['bitcoinTx']['blockheight'] = $block ? $block['height'] : null; } // add a transaction fingerprint $parsed_transaction_data['transactionFingerprint'] = $this->buildFingerprint($parsed_transaction_data['bitcoinTx']); return $parsed_transaction_data; } catch (Exception $e) { Log::warning("Failed to parse transaction: " . ((isset($bitcoin_transaction_data) and isset($bitcoin_transaction_data['txid'])) ? $bitcoin_transaction_data['txid'] : "unknown") . "\n" . $e->getMessage()); // print "ERROR: ".$e->getMessage()."\n"; // echo "\$parsed_transaction_data:\n".json_encode($parsed_transaction_data, 192)."\n"; throw $e; } }
protected function debugDumpUTXOs($utxos) { $out = ''; $out .= 'total utxos: ' . count($utxos) . "\n"; foreach ($utxos as $utxo) { $out .= ' ' . $utxo['txid'] . ':' . $utxo['n'] . ' (' . CurrencyUtil::satoshisToValue($utxo['amount']) . ')' . "\n"; } return rtrim($out); }
protected function assembleAccountBalancesWithTXID($results, $in_satoshis = false) { $sums = array_fill_keys(LedgerEntry::allTypeStrings(), []); foreach ($results as $result) { $txid = $result['txid']; if (!$txid) { $txid = 'none'; } if ($in_satoshis) { $sums[LedgerEntry::typeIntegerToString($result['type'])][$txid][$result['asset']] = $result['total_amount']; } else { $sums[LedgerEntry::typeIntegerToString($result['type'])][$txid][$result['asset']] = CurrencyUtil::satoshisToValue($result['total_amount']); } } return $sums; }
/** * Execute the console command. * * @return mixed */ public function fire() { $ledger = app('App\\Repositories\\LedgerEntryRepository'); $payment_address_repo = app('App\\Repositories\\PaymentAddressRepository'); $account_repository = app('App\\Repositories\\AccountRepository'); $user_repository = app('App\\Repositories\\UserRepository'); $xcpd_client = app('Tokenly\\XCPDClient\\Client'); $bitcoin_payer = app('Tokenly\\BitcoinPayer\\BitcoinPayer'); $asset_info_cache = app('Tokenly\\CounterpartyAssetInfoCache\\Cache'); $payment_address_uuid = $this->input->getArgument('payment-address-uuid'); if ($payment_address_uuid) { $payment_address = $payment_address_repo->findByUuid($payment_address_uuid); if (!$payment_address) { throw new Exception("Payment address not found", 1); } $payment_addresses = [$payment_address]; } else { $payment_addresses = $payment_address_repo->findAll(); } foreach ($payment_addresses as $payment_address) { Log::debug("reconciling accounts for {$payment_address['address']} ({$payment_address['uuid']})"); // get XCP balances $balances = $xcpd_client->get_balances(['filters' => ['field' => 'address', 'op' => '==', 'value' => $payment_address['address']]]); // and get BTC balance too $btc_float_balance = $bitcoin_payer->getBalance($payment_address['address']); $balances = array_merge([['asset' => 'BTC', 'quantity' => $btc_float_balance]], $balances); // get xchain balances $raw_xchain_balances_by_type = $ledger->combinedAccountBalancesByAsset($payment_address, null); // echo "\$raw_xchain_balances_by_type: ".json_encode($raw_xchain_balances_by_type, 192)."\n"; $combined_xchain_balances = []; foreach ($raw_xchain_balances_by_type as $type_string => $xchain_balances) { foreach ($xchain_balances as $asset => $quantity) { if ($type_string == 'sending' and $asset == 'BTC') { continue; } if ($type_string == 'unconfirmed' and $asset != 'BTC') { continue; } if (!isset($combined_xchain_balances[$asset])) { $combined_xchain_balances[$asset] = 0.0; } $combined_xchain_balances[$asset] += $quantity; } } // get daemon balances $daemon_balances = []; foreach ($balances as $balance) { $asset_name = $balance['asset']; if ($asset_name == 'BTC') { // BTC quantity is a float $quantity_float = floatval($balance['quantity']); } else { // determine quantity based on asset info $is_divisible = $asset_info_cache->isDivisible($asset_name); if ($is_divisible) { $quantity_float = CurrencyUtil::satoshisToValue($balance['quantity']); } else { // non-divisible assets don't use satoshis $quantity_float = floatval($balance['quantity']); } } $daemon_balances[$asset_name] = $quantity_float; } // compare $differences = $this->buildDifferences($combined_xchain_balances, $daemon_balances); if ($differences['any']) { $this->comment("Differences found for {$payment_address['address']} ({$payment_address['uuid']})"); $this->line(json_encode($differences, 192)); $this->line(''); } else { Log::debug("no differences for {$payment_address['address']} ({$payment_address['uuid']})"); if ($payment_address_uuid) { // only showing one address $this->comment("No differences found for {$payment_address['address']} ({$payment_address['uuid']})"); } } } $this->info('done'); }
public function testAPICreatePrimes_2() { $this->app->make('CounterpartySenderMockBuilder')->installMockCounterpartySenderDependencies($this->app, $this); // setup list($payment_address, $sample_txos) = $this->setupPrimes(); // api tester $api_tester = $this->getAPITester(); $create_primes_vars = ['size' => CurrencyUtil::satoshisToValue(5430), 'count' => 2]; $response = $api_tester->callAPIWithAuthentication('POST', '/api/v1/primes/' . $payment_address['uuid'], $create_primes_vars); $api_data = json_decode($response->getContent(), true); PHPUnit::assertEquals(0, $api_data['oldPrimedCount']); PHPUnit::assertEquals(2, $api_data['newPrimedCount']); PHPUnit::assertEquals(true, $api_data['primed']); // check the composed transaction $composed_transaction_raw = DB::connection('untransacted')->table('composed_transactions')->first(); $send_data = app('TransactionComposerHelper')->parseBTCTransaction($composed_transaction_raw->transaction); $bitcoin_address = $payment_address['address']; PHPUnit::assertCount(2, $send_data['change']); PHPUnit::assertEquals($bitcoin_address, $send_data['destination']); PHPUnit::assertEquals(5430, $send_data['btc_amount']); PHPUnit::assertEquals($bitcoin_address, $send_data['change'][0][0]); PHPUnit::assertEquals(5430, $send_data['change'][0][1]); }
public function testChooseTXOsFour() { // receiving a transaction adds TXOs $txo_repository = app('App\\Repositories\\TXORepository'); $txo_chooser = app('App\\Blockchain\\Sender\\TXOChooser'); $float = function ($i) { return CurrencyUtil::satoshisToValue($i); }; list($payment_address, $sample_txos) = $this->makeAddressAndSampleTXOs_4(); // choose exact change from a bunch $chosen_txos = $txo_chooser->chooseUTXOs($payment_address, 0.0005, 0.0001, $float(5430)); // $this->assertFound([2,1,3,4], $sample_txos, $chosen_txos); }
protected function executeSend(APIControllerHelper $helper, Request $request, PaymentAddressRepository $payment_address_respository, SendRepository $send_respository, PaymentAddressSender $address_sender, Guard $auth, APICallRepository $api_call_repository, $id) { $user = $auth->getUser(); if (!$user) { throw new Exception("User not found", 1); } // get the address $payment_address = $payment_address_respository->findByUuid($id); if (!$payment_address) { return new JsonResponse(['message' => 'address not found'], 404); } // make sure this address belongs to this user if ($payment_address['user_id'] != $user['id']) { return new JsonResponse(['message' => 'Not authorized to send from this address'], 403); } // attributes $request_attributes = $request->only(array_keys($request->rules())); // determine if this is a multisend $is_multisend = (isset($request_attributes['destinations']) and $request_attributes['destinations']); $is_regular_send = !$is_multisend; // normalize destinations $destinations = $is_multisend ? $this->normalizeDestinations($request_attributes['destinations']) : ''; $destination = $is_regular_send ? $request_attributes['destination'] : ''; // determine variables $quantity_sat = CurrencyUtil::valueToSatoshis($is_multisend ? $this->sumMultisendQuantity($destinations) : $request_attributes['quantity']); $asset = $is_regular_send ? $request_attributes['asset'] : 'BTC'; $is_sweep = isset($request_attributes['sweep']) ? !!$request_attributes['sweep'] : false; $float_fee = isset($request_attributes['fee']) ? $request_attributes['fee'] : PaymentAddressSender::DEFAULT_FEE; $dust_size = isset($request_attributes['dust_size']) ? $request_attributes['dust_size'] : PaymentAddressSender::DEFAULT_REGULAR_DUST_SIZE; $request_id = isset($request_attributes['requestId']) ? $request_attributes['requestId'] : Uuid::uuid4()->toString(); // create attibutes $create_attributes = []; $create_attributes['user_id'] = $user['id']; $create_attributes['payment_address_id'] = $payment_address['id']; $create_attributes['destination'] = $destination; $create_attributes['quantity_sat'] = $quantity_sat; $create_attributes['asset'] = $asset; $create_attributes['is_sweep'] = $is_sweep; $create_attributes['fee'] = $float_fee; $create_attributes['dust_size'] = $dust_size; // for multisends $create_attributes['destinations'] = $destinations; // the transaction must be committed before the lock is release and not after // therefore we must release the lock after this closure completes $lock_must_be_released = false; $lock_must_be_released_with_delay = false; // create a send and lock it immediately $send_result = $send_respository->executeWithNewLockedSendByRequestID($request_id, $create_attributes, function ($locked_send) use($request_attributes, $create_attributes, $payment_address, $user, $helper, $send_respository, $address_sender, $api_call_repository, $request_id, $is_multisend, $is_regular_send, $quantity_sat, $asset, $destination, $destinations, $is_sweep, $float_fee, $dust_size, &$lock_must_be_released, &$lock_must_be_released_with_delay) { $api_call = $api_call_repository->create(['user_id' => $user['id'], 'details' => ['method' => 'api/v1/sends/' . $payment_address['uuid'], 'args' => $request_attributes]]); // if a send already exists by this request_id, just return it if (isset($locked_send['txid']) && strlen($locked_send['txid'])) { EventLog::log('send.alreadyFound', $locked_send); return $helper->transformResourceForOutput($locked_send); } $float_quantity = CurrencyUtil::satoshisToValue($quantity_sat); // send EventLog::log('send.requested', array_merge($request_attributes, $create_attributes)); if ($is_sweep) { try { // get lock $lock_acquired = AccountHandler::acquirePaymentAddressLock($payment_address); if ($lock_acquired) { $lock_must_be_released = true; } list($txid, $float_balance_sent) = $address_sender->sweepAllAssets($payment_address, $request_attributes['destination'], $float_fee); $quantity_sat_sent = CurrencyUtil::valueToSatoshis($float_balance_sent); // clear all balances from all accounts AccountHandler::zeroAllBalances($payment_address, $api_call); // release the account lock with a slight delay if ($lock_acquired) { $lock_must_be_released_with_delay = true; } } catch (PaymentException $e) { EventLog::logError('error.sweep', $e); return new JsonResponse(['message' => $e->getMessage()], 500); } catch (Exception $e) { EventLog::logError('error.sweep', $e); return new JsonResponse(['message' => 'Unable to complete this request'], 500); } } else { try { // get the account $account_name = (isset($request_attributes['account']) and strlen($request_attributes['account'])) ? $request_attributes['account'] : 'default'; $account = AccountHandler::getAccount($payment_address, $account_name); if (!$account) { EventLog::logError('error.send.accountMissing', ['address_id' => $payment_address['id'], 'account' => $account_name]); return new JsonResponse(['message' => "This account did not exist."], 404); } // Log::debug("\$account=".json_encode($account, 192)); // get lock $lock_acquired = AccountHandler::acquirePaymentAddressLock($payment_address); if ($lock_acquired) { $lock_must_be_released = true; } // whether to spend unconfirmed balances $allow_unconfirmed = isset($request_attributes['unconfirmed']) ? $request_attributes['unconfirmed'] : false; // Log::debug("\$allow_unconfirmed=".json_encode($allow_unconfirmed, 192)); // validate that the funds are available if ($allow_unconfirmed) { $has_enough_funds = AccountHandler::accountHasSufficientFunds($account, $float_quantity, $asset, $float_fee, $dust_size); } else { $has_enough_funds = AccountHandler::accountHasSufficientConfirmedFunds($account, $float_quantity, $asset, $float_fee, $dust_size); } if (!$has_enough_funds) { EventLog::logError('error.send.insufficient', ['address_id' => $payment_address['id'], 'account' => $account_name, 'quantity' => $float_quantity, 'asset' => $asset]); return new JsonResponse(['message' => "This account does not have sufficient" . ($allow_unconfirmed ? '' : ' confirmed') . " funds available."], 400); } // send the funds EventLog::log('send.begin', ['request_id' => $request_id, 'address_id' => $payment_address['id'], 'account' => $account_name, 'quantity' => $float_quantity, 'asset' => $asset, 'destination' => $is_multisend ? $destinations : $destination]); $txid = $address_sender->sendByRequestID($request_id, $payment_address, $is_multisend ? $destinations : $destination, $float_quantity, $asset, $float_fee, $dust_size); EventLog::log('send.complete', ['txid' => $txid, 'request_id' => $request_id, 'address_id' => $payment_address['id'], 'account' => $account_name, 'quantity' => $float_quantity, 'asset' => $asset, 'destination' => $is_multisend ? $destinations : $destination]); // tag funds as sent with the txid if ($allow_unconfirmed) { AccountHandler::markAccountFundsAsSending($account, $float_quantity, $asset, $float_fee, $dust_size, $txid); } else { AccountHandler::markConfirmedAccountFundsAsSending($account, $float_quantity, $asset, $float_fee, $dust_size, $txid); // Log::debug("After marking confirmed funds as sent, all accounts for ${account['name']}: ".json_encode(app('App\Repositories\LedgerEntryRepository')->accountBalancesByAsset($account, null), 192)); // Log::debug("After marking confirmed funds as sent, all accounts for default: ".json_encode(app('App\Repositories\LedgerEntryRepository')->accountBalancesByAsset(AccountHandler::getAccount($payment_address), null), 192)); } // release the account lock if ($lock_acquired) { $lock_must_be_released_with_delay = true; } } catch (AccountException $e) { EventLog::logError('error.pay', $e); return new JsonResponse(['message' => $e->getMessage(), 'errorName' => $e->getErrorName()], $e->getStatusCode()); } catch (PaymentException $e) { EventLog::logError('error.pay', $e); return new JsonResponse(['message' => $e->getMessage()], 500); } catch (Exception $e) { EventLog::logError('error.pay', $e); return new JsonResponse(['message' => 'Unable to complete this request'], 500); } } $attributes = []; $attributes['sent'] = time(); $attributes['txid'] = $txid; EventLog::log('send.complete', $attributes); // update and send response $send_respository->update($locked_send, $attributes); return $helper->buildJSONResponse($locked_send->serializeForAPI()); }, self::SEND_LOCK_TIMEOUT); // make sure to release the lock if ($lock_must_be_released_with_delay) { $this->releasePaymentAddressLockWithDelay($payment_address); } else { if ($lock_must_be_released) { AccountHandler::releasePaymentAddressLock($payment_address); } } return $send_result; }
protected function normalizeBitcoindUTXORecord($unspent_txo_record) { return ['address' => $unspent_txo_record->destination_address, 'txid' => $unspent_txo_record->txid, 'vout' => $unspent_txo_record->n, 'script' => $unspent_txo_record->script, 'amount' => CurrencyUtil::satoshisToValue($unspent_txo_record->destination_value), 'amount_sat' => $unspent_txo_record->destination_value, 'confirmations' => $unspent_txo_record->confirmations, 'confirmed' => $unspent_txo_record->confirmations > 0]; }
public function getDustSizeAttribute() { return CurrencyUtil::satoshisToValue($this->attributes['dust_size_sat']); }
/** * Returns the value as a float * @return float value as a float */ public function getFloat() { return CurrencyUtil::satoshisToValue($this->satoshis_qty); }