public function testIncomingInvalidatedTransactionUpdatesLedgerEntries() { $provisional_tx_repository = app('App\\Repositories\\ProvisionalTransactionRepository'); $notification_repository = app('App\\Repositories\\NotificationRepository'); $ledger_entry_repository = app('App\\Repositories\\LedgerEntryRepository'); // setup monitors $payment_address_helper = app('PaymentAddressHelper'); $payment_address_one = $payment_address_helper->createSamplePaymentAddressWithoutInitialBalances(null, ['address' => '1JztLWos5K7LsqW5E78EASgiVBaCe6f7cD']); // receive unconfirmed transactions $parsed_txs = $this->receiveUnconfirmedTransactions(1); // check accounts $account_one = AccountHandler::getAccount($payment_address_one, 'default'); $balance = $ledger_entry_repository->accountBalancesByAsset($account_one, null); PHPUnit::assertEquals(0.004, $balance['unconfirmed']['BTC']); // now confirm a malleated version of the transaction $malleated_tx = $parsed_txs[0]; $malleated_tx['txid'] = str_repeat('0', 54) . 'MALLEATED1'; $malleated_txs = [$malleated_tx]; // now confirm the malleated transaction (with 2 confirmations) $this->sendConfirmationEvents(2, $malleated_txs); // check for invalidation notification $balance = $ledger_entry_repository->accountBalancesByAsset($account_one, null); PHPUnit::assertEquals(0.004, $balance['confirmed']['BTC']); PHPUnit::assertArrayNotHasKey('BTC', $balance['unconfirmed']); }
public function send(PaymentAddress $payment_address, $parsed_tx, $confirmations) { $is_confirmed = $confirmations >= self::SEND_CONFIRMATIONS_REQUIRED; // check for vins if (!isset($parsed_tx['bitcoinTx']['vin']) or !$parsed_tx['bitcoinTx']['vin']) { EventLog::logError('bitcoinTx.send.noVins', ['txid' => $parsed_tx['txid']]); return; } // get the sending account $account = AccountHandler::getAccount($payment_address); foreach ($parsed_tx['bitcoinTx']['vin'] as $vin) { // update the UTXO record $is_spendable = true; if ($is_spendable) { $spent_txid = isset($vin['txid']) ? $vin['txid'] : null; $spent_n = isset($vin['vout']) ? $vin['vout'] : null; if ($spent_txid and $spent_n !== null) { $type = $is_confirmed ? TXO::SENT : TXO::SENDING; $spent = true; // spend the utxo (updates an existing utxo) Log::debug("new send TXO: {$spent_txid}:{$spent_n}/" . CurrencyUtil::valueToSatoshis($vin['value']) . " " . TXO::typeIntegerToString($type) . " to " . $payment_address['uuid']); $this->txo_repository->updateOrCreate(['txid' => $spent_txid, 'n' => $spent_n, 'type' => $type, 'spent' => $spent, 'amount' => CurrencyUtil::valueToSatoshis($vin['value'])], $payment_address, $account); } } } }
/** * Execute the console command. * * @return mixed */ public function fire() { $payment_address_repo = app('App\\Repositories\\PaymentAddressRepository'); $account_repository = app('App\\Repositories\\AccountRepository'); $user_repository = app('App\\Repositories\\UserRepository'); $payment_address_uuid = $this->input->getArgument('payment-address-uuid'); $name = $this->input->getOption('name'); $show_ledger = $this->input->getOption('ledger'); $show_inactive = $this->input->getOption('inactive'); $payment_address = $payment_address_repo->findByUuid($payment_address_uuid); if (!$payment_address) { throw new Exception("Payment address not found", 1); } $this->info("Showing accounts for payment address {$payment_address['address']} ({$payment_address['uuid']})"); if (strlen($name)) { $account = AccountHandler::getAccount($payment_address, $name); if (!$account) { $this->error("Account not found for {$name}"); return; } $accounts = [$account]; } else { // all accounts, maybe including inactive $accounts = $account_repository->findByAddress($payment_address, $show_inactive ? null : 1); } foreach ($accounts as $account) { $this->line($this->showAccount($account, $show_ledger)); } $this->info('done'); }
public function createSampleTXO($payment_address = null, $overrides = []) { if ($payment_address === null) { $payment_address = app('PaymentAddressHelper')->createSamplePaymentAddress(); } $account = AccountHandler::getAccount($payment_address, 'default'); // build a real script $script = ScriptFactory::scriptPubKey()->payToAddress(AddressFactory::fromString($payment_address['address'])); $attributes = array_merge(['txid' => $this->nextTXID(), 'n' => 0, 'script' => $script->getBuffer()->getHex(), 'amount' => 54321, 'type' => TXO::CONFIRMED, 'spent' => false, 'green' => false], $overrides); $txo_model = $this->txo_repository->create($payment_address, $account, $attributes); return $txo_model; }
public function addBalancesToPaymentAddressAccount($balances, $payment_address, $with_utxos = true, $account_name = 'default', $txid = 'SAMPLE01') { if (!$balances) { return; } $account = AccountHandler::getAccount($payment_address, $account_name); foreach ($balances as $asset => $quantity) { $this->ledger_entry_repository->addCredit($quantity, $asset, $account, LedgerEntry::CONFIRMED, LedgerEntry::DIRECTION_OTHER, $txid); } if ($with_utxos) { $float_btc_balance = isset($balances['BTC']) ? $balances['BTC'] : 0; return $this->addUTXOToPaymentAddress($float_btc_balance, $payment_address, $account_name, $txid); } return []; }
public function testPrimingTransactionUpdatesBalancesCorrectly() { $user = $this->app->make('\\UserHelper')->createSampleUser(); $payment_address = $this->app->make('\\PaymentAddressHelper')->createSamplePaymentAddress($user); $my_address = $payment_address['address']; $default_account = AccountHandler::getAccount($payment_address); // test balances before $ledger_entry_repo = app('App\\Repositories\\LedgerEntryRepository'); $balances = $ledger_entry_repo->accountBalancesByAsset($default_account, null); PHPUnit::assertEquals(1, $balances['confirmed']['BTC']); // generate a multi priming transaction $parsed_transaction = $this->buildTransaction(0.4, $my_address, [[$my_address, 0.0001], [$my_address, 0.0001], [$my_address, 0.0001], [$my_address, 0.3996]]); // echo "\$parsed_transaction: ".json_encode($parsed_transaction, 192)."\n"; $this->sendTransactionWithConfirmations($parsed_transaction, 0); // test balances after $ledger_entry_repo = app('App\\Repositories\\LedgerEntryRepository'); $balances = $ledger_entry_repo->accountBalancesByAsset($default_account, null); // echo "[after] \$balances: ".json_encode($balances, 192)."\n"; PHPUnit::assertEquals(0.9999, $balances['confirmed']['BTC']); }
public function testUpdateByTXOIdentifiers() { // add one $txo_repository = $this->app->make('App\\Repositories\\TXORepository'); $txid = $this->TXOHelper()->nextTXID(); $txid_2 = $this->TXOHelper()->nextTXID(); $payment_address = app('PaymentAddressHelper')->createSamplePaymentAddressWithoutInitialBalances(); $default_account = AccountHandler::getAccount($payment_address); // create... $attributes = ['txid' => $txid, 'n' => 0, 'type' => TXO::CONFIRMED, 'script' => 'testscript', 'spent' => false]; $txo_model_1 = $txo_repository->updateOrCreate($attributes, $payment_address, $default_account); $txo_model_2 = $txo_repository->updateOrCreate(['n' => 1] + $attributes, $payment_address, $default_account); $txo_model_3 = $txo_repository->updateOrCreate(['txid' => $txid_2] + $attributes, $payment_address, $default_account); $txo_model_4 = $txo_repository->updateOrCreate(['txid' => $txid_2, 'n' => 1] + $attributes, $payment_address, $default_account); // update $update_vars = ['script' => 'testscriptupdated']; $txo_repository->updateByTXOIdentifiers(["{$txid}:1", "{$txid_2}:1"], $update_vars); $reloaded_txo_1 = $txo_repository->findByID($txo_model_1['id']); $reloaded_txo_2 = $txo_repository->findByID($txo_model_2['id']); $reloaded_txo_3 = $txo_repository->findByID($txo_model_3['id']); $reloaded_txo_4 = $txo_repository->findByID($txo_model_4['id']); PHPUnit::assertEquals('testscript', $reloaded_txo_1['script']); PHPUnit::assertEquals('testscriptupdated', $reloaded_txo_2['script']); PHPUnit::assertEquals('testscript', $reloaded_txo_3['script']); PHPUnit::assertEquals('testscriptupdated', $reloaded_txo_4['script']); // update (2) $update_vars = ['script' => 'testscriptupdated222']; $txo_repository->updateByTXOIdentifiers(["{$txid}:0"], $update_vars); $reloaded_txo_1 = $txo_repository->findByID($txo_model_1['id']); $reloaded_txo_2 = $txo_repository->findByID($txo_model_2['id']); $reloaded_txo_3 = $txo_repository->findByID($txo_model_3['id']); $reloaded_txo_4 = $txo_repository->findByID($txo_model_4['id']); PHPUnit::assertEquals('testscriptupdated222', $reloaded_txo_1['script']); PHPUnit::assertEquals('testscriptupdated', $reloaded_txo_2['script']); PHPUnit::assertEquals('testscript', $reloaded_txo_3['script']); PHPUnit::assertEquals('testscriptupdated', $reloaded_txo_4['script']); }
protected function clearBalances($balance_type, $balances_by_asset, $payment_address, APICall $api_call) { $ledger = app('App\\Repositories\\LedgerEntryRepository'); // get the default account $account = AccountHandler::getAccount($payment_address, 'default'); foreach ($balances_by_asset as $asset => $quantity) { if ($quantity == 0) { continue; } // debit the {$balance_type} balance $msg = "Balancing {$balance_type} ledger with {$quantity} {$asset}"; $this->info($msg); $ledger_entry_type = $balance_type == 'unconfirmed' ? LedgerEntry::UNCONFIRMED : LedgerEntry::SENDING; if ($quantity < 0) { $ledger->addCredit(0 - $quantity, $asset, $account, $ledger_entry_type, LedgerEntry::DIRECTION_OTHER, null, $api_call); } else { $ledger->addDebit($quantity, $asset, $account, $ledger_entry_type, LedgerEntry::DIRECTION_OTHER, null, $api_call); } } }
protected function loadPaymentAddressInfo($address) { if (!isset($this->payment_address_info_cache)) { $this->payment_address_info_cache = []; } if (!isset($this->payment_address_info_cache[$address])) { $found_payment_address = $this->payment_address_repository->findByAddress($address)->first(); if ($found_payment_address) { $this->payment_address_info_cache[$address] = [$found_payment_address, AccountHandler::getAccount($found_payment_address)]; } else { $this->payment_address_info_cache[$address] = [null, null]; } } return $this->payment_address_info_cache[$address]; }
public function testMoveAccounts() { // receiving a transaction adds TXOs $txo_repository = $this->app->make('App\\Repositories\\TXORepository'); // setup monitors $payment_address_helper = app('PaymentAddressHelper'); $receiving_address_one = $payment_address_helper->createSamplePaymentAddressWithoutInitialBalances(null, ['address' => '1JztLWos5K7LsqW5E78EASgiVBaCe6f7cD']); // create a second account $default_account = AccountHandler::getAccount($receiving_address_one); $account_1 = AccountHandler::createAccount($receiving_address_one, 'account1'); // receive unconfirmed transactions $parsed_txs = $this->receiveUnconfirmedTransactions(1); $loaded_txos = $txo_repository->findAll(); // check that it is in the default account $all_txos = $txo_repository->findAll(); $loaded_txo = $all_txos[0]; PHPUnit::assertEquals($default_account['id'], $loaded_txo['account_id']); // move the utxo to account 1 TXOHandler::moveAccounts([$loaded_txo], $default_account, $account_1); $all_txos = $txo_repository->findAll(); PHPUnit::assertCount(1, $all_txos); $loaded_txo = $all_txos[0]; PHPUnit::assertEquals($account_1['id'], $loaded_txo['account_id']); // check findByAccount $loaded_txos = $txo_repository->findByAccount($default_account, true); PHPUnit::assertCount(0, $loaded_txos); $loaded_txos = $txo_repository->findByAccount($account_1, true); PHPUnit::assertCount(1, $loaded_txos); $loaded_txos = $txo_repository->findByAccount($account_1, false); PHPUnit::assertCount(0, $loaded_txos); }
/** * Execute the console command. * * @return mixed */ public function fire() { $txo_repository = app('App\\Repositories\\TXORepository'); $payment_address_repo = app('App\\Repositories\\PaymentAddressRepository'); $bitcoin_payer = app('Tokenly\\BitcoinPayer\\BitcoinPayer'); $payment_address_uuid = $this->input->getArgument('payment-address-uuid'); $should_reconcile = $this->input->getOption('reconcile'); 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 TXOs for {$payment_address['address']} ({$payment_address['uuid']})"); // get xchain utxos $xchain_utxos_map = []; $db_txos = $txo_repository->findByPaymentAddress($payment_address, null, true); // unspent only foreach ($db_txos as $db_txo) { if ($db_txo['type'] != TXO::CONFIRMED) { continue; } $filtered_utxo = ['txid' => $db_txo['txid'], 'n' => $db_txo['n'], 'script' => $db_txo['script'], 'amount' => $db_txo['amount']]; $xchain_utxos_map[$filtered_utxo['txid'] . ':' . $filtered_utxo['n']] = $filtered_utxo; } // get daemon utxos $daemon_utxos_map = []; $all_utxos = $bitcoin_payer->getAllUTXOs($payment_address['address']); if ($all_utxos) { foreach ($all_utxos as $utxo) { if (!isset($utxo['confirmations']) or $utxo['confirmations'] == 0) { continue; } $filtered_utxo = ['txid' => $utxo['txid'], 'n' => $utxo['vout'], 'script' => $utxo['script'], 'amount' => CurrencyUtil::valueToSatoshis($utxo['amount'])]; $daemon_utxos_map[$utxo['txid'] . ':' . $utxo['vout']] = $filtered_utxo; } } // compare $differences = $this->buildDifferences($xchain_utxos_map, $daemon_utxos_map); if ($differences['any']) { $this->comment("Differences found for {$payment_address['address']} ({$payment_address['uuid']})"); $this->line(json_encode($differences, 192)); $this->line(''); if ($should_reconcile) { $account = AccountHandler::getAccount($payment_address); foreach ($differences['differences'] as $difference) { // delete the xchain txo if it is different in any way if (isset($difference['xchain']) and $difference['xchain']) { $utxo = $difference['xchain']; $this->line('Removing xchain UTXO: ' . json_encode($utxo, 192)); // delete $txo_model = $txo_repository->findByTXIDAndOffset($utxo['txid'], $utxo['n']); if ($txo_model['payment_address_id'] != $payment_address['id']) { throw new Exception("Mismatched payment address id. Expected {$payment_address['id']}. Found {$txo_model['payment_address_id']}", 1); } } if (isset($difference['daemon'])) { $utxo = $difference['daemon']; $this->line('Adding daemon UTXO: ' . json_encode($utxo, 192)); // add the daemon's utxo $txo_repository->create($payment_address, $account, ['txid' => $utxo['txid'], 'n' => $utxo['n'], 'script' => $utxo['script'], 'amount' => $utxo['amount']]); } } } } else { $this->comment("No differences found for {$payment_address['address']} ({$payment_address['uuid']})"); } } $this->info('done'); }
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 syncConfirmedBalances($payment_address, $balance_differences, APICall $api_call) { $ledger = app('App\\Repositories\\LedgerEntryRepository'); foreach ($balance_differences as $asset => $qty_by_type) { $xchain_quantity = $qty_by_type['xchain']; $daemon_quantity = $qty_by_type['daemon']; $default_account = AccountHandler::getAccount($payment_address); if ($xchain_quantity > $daemon_quantity) { // debit $quantity = $xchain_quantity - $daemon_quantity; $msg = "Debiting {$quantity} {$asset} from account {$default_account['name']}"; $this->info($msg); $ledger->addDebit($quantity, $asset, $default_account, LedgerEntry::CONFIRMED, LedgerEntry::DIRECTION_OTHER, null, $api_call); } else { // credit $quantity = $daemon_quantity - $xchain_quantity; $msg = "Crediting {$quantity} {$asset} to account {$default_account['name']}"; $this->info($msg); $ledger->addCredit($quantity, $asset, $default_account, LedgerEntry::CONFIRMED, LedgerEntry::DIRECTION_OTHER, null, $api_call); } } }