Error on refund about omnipay-authorizenet HOT 6 OPEN

        $this->gateway_auth = Omnipay::create('AuthorizeNet_AIM');
        $this->gateway_auth->setDeveloperMode(config('app.env') !== 'production');
        $this->gateway_auth->setTestMode(config('services.authorize_net.test_mode', false));
        $this->gateway_auth->setApiLoginId(config('services.authorize_net.login_id'));
        $this->gateway_auth->setTransactionKey(config('services.authorize_net.transaction_key'));

 /**
     * Making the refund for the payment.
     *
     * @param array $transactionReference
     * @param float $amount
     * @return \Omnipay\AuthorizeNet\Message\AIMResponse|\Omnipay\Common\Message\ResponseInterface
     */
    public function makeRefund(array $transactionReference, float $amount)
    {
        $amount = (floor($amount * 100) / 100);

        $params = [
            'amount' => $amount,
            'transactionReference' => json_encode($transactionReference),
        ];

        $request = $this->gateway_auth->refund($params);

        return $request->send();
    }

/**
     * @param int $paymentId
     * @param array $refundData
     * @return string
     * @throws \Exception
     */
    public function makeRefund(int $paymentId, array $refundData): string
    {
        /** @var Payment $payment */
        $payment = $this->repository->findEntity($paymentId);

        $amount = 0;

        switch ($refundData['refund_type']) {
            case Payment::REFUND_TYPE_FULL:
                $amount = $payment->total_amount;
                break;
            case Payment::REFUND_OTHER_AMOUNT:
                $amount = $refundData['refund_amount'];
                break;
        }

        if ($amount > $payment->total_amount || $amount <= 0) {
            throw new \Exception('Wrong refund amount');
        }

        //Resolving the transaction detail which requested by refund.
        $transactionResponse = $this->client->getTransactionDetails($payment->transaction_id);

        $transactionReference = [
            'transId' => $payment->transaction_id,
            'card' => [
                'number' => null,
                'expiry' => null,
            ]
        ];

        if ($transactionResponse->isSuccessful()) {
            $transaction = optional($transactionResponse->getData())->transaction;

            $cardNumber = (string)$transaction->payment->creditCard->cardNumber;

            $transactionReference['card'] = [
                'number' => substr($cardNumber, -4, 4) ?: null,
                'expiry' => 'XXXX',
            ];
        } else {
            Log::critical('Unable get transaction details', [
                'payment' => $payment,
                'error' => $transactionResponse->getMessage(),
            ]);

            throw new \Exception(__('Unable get transaction details from Authorize.net: :error', [
                'error' => $transactionResponse->getMessage(),
            ]));
        }

        $response = $this->client
            ->setGateway('AuthorizeNet_AIM')
            ->makeRefund($transactionReference, $amount);

        if ($response->isSuccessful()) {
            $transaction = json_decode($response->getTransactionReference(), true);
            $transId = Arr::get($transaction, 'transId');

            $paymentAttributes = [
                'order_id' => $payment->order_id,
                'customer_id' => $payment->customer_id,
                'total_amount' => $amount,
                'transaction_id' => $transId,
                'payment_method_preview' => __('Refund (:type) for transaction #:trans_id', [
                    'trans_id' => $payment->transaction_id,
                    'type' => Str::title(str_replace('_', ' ', $refundData['refund_type'])),
                ]),
                'payment_status' => $response->getResultCode() ?? Payment::STATUS_REFUNDED,
                'gateway_response' => $response->getMessage(),
            ];

            $this->repository->create($paymentAttributes);

            return $response->getMessage();
        } else {
            Log::critical(__('The payment was not refunded! Payment Gateway response: :error', [
                'error' => $response->getMessage(),
            ]), [
                'response' => $response
            ]);
        }

        throw new \Exception(__('Unable make refund with error: :error', [
            'error' => $response->getMessage()
        ]));
    }