get a single transaction
@param  string $txhash transaction hash
@return array          associative array containing the response
346755
public function transaction($txhash) {
        $response = $this->dataClient->get($this->converter->getUrlForTransaction($txhash));
        $res = $this->converter->convertTx($response->body(), null);

        if ($this->converter instanceof BtccomConverter) {
            $res['raw'] = \json_decode($this->dataClient->get("tx/{$txhash}/raw")->body(), true)['data'];
        }

        return $res;
    }
1243135
public function get($transactionId)
    {
        if ($transactionId <= 0) {
            throw new HpsArgumentException('Invalid Transaction Id',HpsExceptionCodes::INVALID_ORIGINAL_TRANSACTION);
        }

        $xml = new DOMDocument();
        $hpsTransaction = $xml->createElement('hps:Transaction');
        $hpsReportTxnDetail = $xml->createElement('hps:ReportTxnDetail');
        $hpsReportTxnDetail->appendChild($xml->createElement('hps:TxnId', $transactionId));
        $hpsTransaction->appendChild($hpsReportTxnDetail);

        return $this->_submitTransaction($hpsTransaction, 'ReportTxnDetail');
    }
596789
public function retrieve ($hash)
    {
        $cached = $this->memcached->get($this->prefix . $hash);

        if ($this->memcached->getResultCode() === \Memcached::RES_SUCCESS) {
            $json = json_decode($cached, true);

            if (isset($json['token'], $json['expires'])) {
                return new AccessToken($json['token'], DateTime::createFromFormat('U', $json['expires']));
            }
        }
    }
27064
public function getTransactionById($wallet_uuid, $txid, $address_uuid)
    {
        $parameters = [
            'uuid' => $address_uuid,
        ];
        return $this->newAPIRequest('GET', $wallet_uuid . '/address/transaction/' . $txid, $parameters);
    }
526938
public function get(string $key, string $hash = '')
    {
        if (!$key && $hash) {
            $wp_using_ext_object_cache            = wp_using_ext_object_cache(false);
            $key                                  = $this->hashToKey($hash);
            $do_restore_wp_using_ext_object_cache = true; // See below.
        }
        if ($this->App->Config->§specs['§is_network_wide'] && $this->Wp->is_multisite) {
            $value = get_site_transient($this->App->Config->©brand['©var'].'_'.$key);
        } else {
            $value = get_transient($this->App->Config->©brand['©var'].'_'.$key);
        }
        if (!empty($do_restore_wp_using_ext_object_cache)) {
            wp_using_ext_object_cache($wp_using_ext_object_cache);
        }
        return $value === false ? null : $value;
    }
145242
protected function getItemByHash($hash)
    {
        foreach ($this->items as $item) {
            if ($item->getHash() === $hash) {
                return $item;
            }
        }
        
        return false;
    }
642925
public function lockUTXO($txHash, $txIdx, $ttl = 3) {
        return $this->sdk->lockWalletUTXO($this->identifier, $txHash, $txIdx, $ttl);
    }
1095557
public function handleVersionTwo(Transaction $transaction): Transaction
    {
        $transaction->id = Hash::sha256($transaction->serialize())->getHex();

        return $transaction;
    }
1176517
public function getHash()
    {
        $hash = [];
        foreach ($this as $embed) {
            $hash[] = $embed->getHash();
        }
        sort($hash);
        return md5(serialize($hash));
    }
937282
public function retrieve ($hash)
    {
        $colHash = $this->columns['hash'];
        $colExpires = $this->columns['expires'];
        $colToken = $this->columns['token'];

        $sql = "SELECT `{$colToken}`, `{$colExpires}` FROM `{$this->table}` WHERE `{$colHash}` = ? LIMIT 1";
        $st = $this->pdo->prepare($sql);
        $st->execute([hex2bin($hash)]);
        $row = $st->fetch(PDO::FETCH_ASSOC);
        $st->closeCursor();

        if (is_array($row)) {
            return new AccessToken($row[$colToken], DateTime::createFromFormat('U', $row[$colExpires]));
        } else {
            return null;
        }
    }
369966
public function get(string $hash): ?EntityInterface
    {
        $result = null;
        $content = $this->loadContent($hash);
        if ($content !== null) {
            $result = $this->createEntityFromContent($content);
        }
        return $result;
    }
1040610
public function fetch($transaction_id)
    {
        $url = 'transactions/' . $transaction_id;

        $api_response = $this->paylike->client->request('GET', $url);

        return $api_response->json['transaction'];
    }
428719
public function getHash()
    {
        if (null === $this->hash) {
            $this->hash = $this->calculateHash();
        }

        return $this->hash;
    }
218631
public function findOneBySha1($sha1Hash)
    {
        $query = $this->createQuery();
        $query->matching($query->equals('sha1', $sha1Hash))->setLimit(1);
        /** @var PersistentResource $resource */
        $resource = $query->execute()->getFirst();
        if ($resource === null) {
            /** @var PersistentResource $importedResource */
            foreach ($this->addedResources as $importedResource) {
                if ($importedResource->getSha1() === $sha1Hash) {
                    return $importedResource;
                }
            }
        }

        return $resource;
    }
256450
public function findAllByRegisteraddresshash($hash)
    {
        $query = $this->createQuery();

        $query->matching(
            $query->equals('registeraddresshash', $hash )
        );

        return $query->execute();
    }
401167
def tx_for_tx_hash(self, tx_hash):
        ""
        url = self.base_url("get_tx", b2h_rev(tx_hash))
        r = json.loads(urlopen(url).read().decode("utf8"))
        tx = Tx.parse(io.BytesIO(h2b(r.get("data").get("tx_hex"))))
        return tx
633461
protected function getRelatedAggregateFromHash(string $hash, string $relation)
    {
        foreach ($this->relationships[$relation] as $aggregate) {
            if ($aggregate->getEntityHash() == $hash) {
                return $aggregate;
            }
        }
    }