LNClient.go raw

   1  // Code generated by mockery; DO NOT EDIT.
   2  // github.com/vektra/mockery
   3  // template: testify
   4  
   5  package mocks
   6  
   7  import (
   8  	"context"
   9  
  10  	"github.com/getAlby/hub/lnclient"
  11  	mock "github.com/stretchr/testify/mock"
  12  )
  13  
  14  // NewMockLNClient creates a new instance of MockLNClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
  15  // The first argument is typically a *testing.T value.
  16  func NewMockLNClient(t interface {
  17  	mock.TestingT
  18  	Cleanup(func())
  19  }) *MockLNClient {
  20  	mock := &MockLNClient{}
  21  	mock.Mock.Test(t)
  22  
  23  	t.Cleanup(func() { mock.AssertExpectations(t) })
  24  
  25  	return mock
  26  }
  27  
  28  // MockLNClient is an autogenerated mock type for the LNClient type
  29  type MockLNClient struct {
  30  	mock.Mock
  31  }
  32  
  33  type MockLNClient_Expecter struct {
  34  	mock *mock.Mock
  35  }
  36  
  37  func (_m *MockLNClient) EXPECT() *MockLNClient_Expecter {
  38  	return &MockLNClient_Expecter{mock: &_m.Mock}
  39  }
  40  
  41  // CancelHoldInvoice provides a mock function for the type MockLNClient
  42  func (_mock *MockLNClient) CancelHoldInvoice(ctx context.Context, paymentHash string) error {
  43  	ret := _mock.Called(ctx, paymentHash)
  44  
  45  	if len(ret) == 0 {
  46  		panic("no return value specified for CancelHoldInvoice")
  47  	}
  48  
  49  	var r0 error
  50  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
  51  		r0 = returnFunc(ctx, paymentHash)
  52  	} else {
  53  		r0 = ret.Error(0)
  54  	}
  55  	return r0
  56  }
  57  
  58  // MockLNClient_CancelHoldInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelHoldInvoice'
  59  type MockLNClient_CancelHoldInvoice_Call struct {
  60  	*mock.Call
  61  }
  62  
  63  // CancelHoldInvoice is a helper method to define mock.On call
  64  //   - ctx context.Context
  65  //   - paymentHash string
  66  func (_e *MockLNClient_Expecter) CancelHoldInvoice(ctx interface{}, paymentHash interface{}) *MockLNClient_CancelHoldInvoice_Call {
  67  	return &MockLNClient_CancelHoldInvoice_Call{Call: _e.mock.On("CancelHoldInvoice", ctx, paymentHash)}
  68  }
  69  
  70  func (_c *MockLNClient_CancelHoldInvoice_Call) Run(run func(ctx context.Context, paymentHash string)) *MockLNClient_CancelHoldInvoice_Call {
  71  	_c.Call.Run(func(args mock.Arguments) {
  72  		var arg0 context.Context
  73  		if args[0] != nil {
  74  			arg0 = args[0].(context.Context)
  75  		}
  76  		var arg1 string
  77  		if args[1] != nil {
  78  			arg1 = args[1].(string)
  79  		}
  80  		run(
  81  			arg0,
  82  			arg1,
  83  		)
  84  	})
  85  	return _c
  86  }
  87  
  88  func (_c *MockLNClient_CancelHoldInvoice_Call) Return(err error) *MockLNClient_CancelHoldInvoice_Call {
  89  	_c.Call.Return(err)
  90  	return _c
  91  }
  92  
  93  func (_c *MockLNClient_CancelHoldInvoice_Call) RunAndReturn(run func(ctx context.Context, paymentHash string) error) *MockLNClient_CancelHoldInvoice_Call {
  94  	_c.Call.Return(run)
  95  	return _c
  96  }
  97  
  98  // CloseChannel provides a mock function for the type MockLNClient
  99  func (_mock *MockLNClient) CloseChannel(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest) error {
 100  	ret := _mock.Called(ctx, closeChannelRequest)
 101  
 102  	if len(ret) == 0 {
 103  		panic("no return value specified for CloseChannel")
 104  	}
 105  
 106  	var r0 error
 107  	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.CloseChannelRequest) error); ok {
 108  		r0 = returnFunc(ctx, closeChannelRequest)
 109  	} else {
 110  		r0 = ret.Error(0)
 111  	}
 112  	return r0
 113  }
 114  
 115  // MockLNClient_CloseChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseChannel'
 116  type MockLNClient_CloseChannel_Call struct {
 117  	*mock.Call
 118  }
 119  
 120  // CloseChannel is a helper method to define mock.On call
 121  //   - ctx context.Context
 122  //   - closeChannelRequest *lnclient.CloseChannelRequest
 123  func (_e *MockLNClient_Expecter) CloseChannel(ctx interface{}, closeChannelRequest interface{}) *MockLNClient_CloseChannel_Call {
 124  	return &MockLNClient_CloseChannel_Call{Call: _e.mock.On("CloseChannel", ctx, closeChannelRequest)}
 125  }
 126  
 127  func (_c *MockLNClient_CloseChannel_Call) Run(run func(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest)) *MockLNClient_CloseChannel_Call {
 128  	_c.Call.Run(func(args mock.Arguments) {
 129  		var arg0 context.Context
 130  		if args[0] != nil {
 131  			arg0 = args[0].(context.Context)
 132  		}
 133  		var arg1 *lnclient.CloseChannelRequest
 134  		if args[1] != nil {
 135  			arg1 = args[1].(*lnclient.CloseChannelRequest)
 136  		}
 137  		run(
 138  			arg0,
 139  			arg1,
 140  		)
 141  	})
 142  	return _c
 143  }
 144  
 145  func (_c *MockLNClient_CloseChannel_Call) Return(err error) *MockLNClient_CloseChannel_Call {
 146  	_c.Call.Return(err)
 147  	return _c
 148  }
 149  
 150  func (_c *MockLNClient_CloseChannel_Call) RunAndReturn(run func(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest) error) *MockLNClient_CloseChannel_Call {
 151  	_c.Call.Return(run)
 152  	return _c
 153  }
 154  
 155  // ConnectPeer provides a mock function for the type MockLNClient
 156  func (_mock *MockLNClient) ConnectPeer(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest) error {
 157  	ret := _mock.Called(ctx, connectPeerRequest)
 158  
 159  	if len(ret) == 0 {
 160  		panic("no return value specified for ConnectPeer")
 161  	}
 162  
 163  	var r0 error
 164  	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.ConnectPeerRequest) error); ok {
 165  		r0 = returnFunc(ctx, connectPeerRequest)
 166  	} else {
 167  		r0 = ret.Error(0)
 168  	}
 169  	return r0
 170  }
 171  
 172  // MockLNClient_ConnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectPeer'
 173  type MockLNClient_ConnectPeer_Call struct {
 174  	*mock.Call
 175  }
 176  
 177  // ConnectPeer is a helper method to define mock.On call
 178  //   - ctx context.Context
 179  //   - connectPeerRequest *lnclient.ConnectPeerRequest
 180  func (_e *MockLNClient_Expecter) ConnectPeer(ctx interface{}, connectPeerRequest interface{}) *MockLNClient_ConnectPeer_Call {
 181  	return &MockLNClient_ConnectPeer_Call{Call: _e.mock.On("ConnectPeer", ctx, connectPeerRequest)}
 182  }
 183  
 184  func (_c *MockLNClient_ConnectPeer_Call) Run(run func(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest)) *MockLNClient_ConnectPeer_Call {
 185  	_c.Call.Run(func(args mock.Arguments) {
 186  		var arg0 context.Context
 187  		if args[0] != nil {
 188  			arg0 = args[0].(context.Context)
 189  		}
 190  		var arg1 *lnclient.ConnectPeerRequest
 191  		if args[1] != nil {
 192  			arg1 = args[1].(*lnclient.ConnectPeerRequest)
 193  		}
 194  		run(
 195  			arg0,
 196  			arg1,
 197  		)
 198  	})
 199  	return _c
 200  }
 201  
 202  func (_c *MockLNClient_ConnectPeer_Call) Return(err error) *MockLNClient_ConnectPeer_Call {
 203  	_c.Call.Return(err)
 204  	return _c
 205  }
 206  
 207  func (_c *MockLNClient_ConnectPeer_Call) RunAndReturn(run func(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest) error) *MockLNClient_ConnectPeer_Call {
 208  	_c.Call.Return(run)
 209  	return _c
 210  }
 211  
 212  // DisconnectPeer provides a mock function for the type MockLNClient
 213  func (_mock *MockLNClient) DisconnectPeer(ctx context.Context, peerId string) error {
 214  	ret := _mock.Called(ctx, peerId)
 215  
 216  	if len(ret) == 0 {
 217  		panic("no return value specified for DisconnectPeer")
 218  	}
 219  
 220  	var r0 error
 221  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
 222  		r0 = returnFunc(ctx, peerId)
 223  	} else {
 224  		r0 = ret.Error(0)
 225  	}
 226  	return r0
 227  }
 228  
 229  // MockLNClient_DisconnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectPeer'
 230  type MockLNClient_DisconnectPeer_Call struct {
 231  	*mock.Call
 232  }
 233  
 234  // DisconnectPeer is a helper method to define mock.On call
 235  //   - ctx context.Context
 236  //   - peerId string
 237  func (_e *MockLNClient_Expecter) DisconnectPeer(ctx interface{}, peerId interface{}) *MockLNClient_DisconnectPeer_Call {
 238  	return &MockLNClient_DisconnectPeer_Call{Call: _e.mock.On("DisconnectPeer", ctx, peerId)}
 239  }
 240  
 241  func (_c *MockLNClient_DisconnectPeer_Call) Run(run func(ctx context.Context, peerId string)) *MockLNClient_DisconnectPeer_Call {
 242  	_c.Call.Run(func(args mock.Arguments) {
 243  		var arg0 context.Context
 244  		if args[0] != nil {
 245  			arg0 = args[0].(context.Context)
 246  		}
 247  		var arg1 string
 248  		if args[1] != nil {
 249  			arg1 = args[1].(string)
 250  		}
 251  		run(
 252  			arg0,
 253  			arg1,
 254  		)
 255  	})
 256  	return _c
 257  }
 258  
 259  func (_c *MockLNClient_DisconnectPeer_Call) Return(err error) *MockLNClient_DisconnectPeer_Call {
 260  	_c.Call.Return(err)
 261  	return _c
 262  }
 263  
 264  func (_c *MockLNClient_DisconnectPeer_Call) RunAndReturn(run func(ctx context.Context, peerId string) error) *MockLNClient_DisconnectPeer_Call {
 265  	_c.Call.Return(run)
 266  	return _c
 267  }
 268  
 269  // ExecuteCustomNodeCommand provides a mock function for the type MockLNClient
 270  func (_mock *MockLNClient) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
 271  	ret := _mock.Called(ctx, command)
 272  
 273  	if len(ret) == 0 {
 274  		panic("no return value specified for ExecuteCustomNodeCommand")
 275  	}
 276  
 277  	var r0 *lnclient.CustomNodeCommandResponse
 278  	var r1 error
 279  	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error)); ok {
 280  		return returnFunc(ctx, command)
 281  	}
 282  	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.CustomNodeCommandRequest) *lnclient.CustomNodeCommandResponse); ok {
 283  		r0 = returnFunc(ctx, command)
 284  	} else {
 285  		if ret.Get(0) != nil {
 286  			r0 = ret.Get(0).(*lnclient.CustomNodeCommandResponse)
 287  		}
 288  	}
 289  	if returnFunc, ok := ret.Get(1).(func(context.Context, *lnclient.CustomNodeCommandRequest) error); ok {
 290  		r1 = returnFunc(ctx, command)
 291  	} else {
 292  		r1 = ret.Error(1)
 293  	}
 294  	return r0, r1
 295  }
 296  
 297  // MockLNClient_ExecuteCustomNodeCommand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteCustomNodeCommand'
 298  type MockLNClient_ExecuteCustomNodeCommand_Call struct {
 299  	*mock.Call
 300  }
 301  
 302  // ExecuteCustomNodeCommand is a helper method to define mock.On call
 303  //   - ctx context.Context
 304  //   - command *lnclient.CustomNodeCommandRequest
 305  func (_e *MockLNClient_Expecter) ExecuteCustomNodeCommand(ctx interface{}, command interface{}) *MockLNClient_ExecuteCustomNodeCommand_Call {
 306  	return &MockLNClient_ExecuteCustomNodeCommand_Call{Call: _e.mock.On("ExecuteCustomNodeCommand", ctx, command)}
 307  }
 308  
 309  func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) Run(run func(ctx context.Context, command *lnclient.CustomNodeCommandRequest)) *MockLNClient_ExecuteCustomNodeCommand_Call {
 310  	_c.Call.Run(func(args mock.Arguments) {
 311  		var arg0 context.Context
 312  		if args[0] != nil {
 313  			arg0 = args[0].(context.Context)
 314  		}
 315  		var arg1 *lnclient.CustomNodeCommandRequest
 316  		if args[1] != nil {
 317  			arg1 = args[1].(*lnclient.CustomNodeCommandRequest)
 318  		}
 319  		run(
 320  			arg0,
 321  			arg1,
 322  		)
 323  	})
 324  	return _c
 325  }
 326  
 327  func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) Return(customNodeCommandResponse *lnclient.CustomNodeCommandResponse, err error) *MockLNClient_ExecuteCustomNodeCommand_Call {
 328  	_c.Call.Return(customNodeCommandResponse, err)
 329  	return _c
 330  }
 331  
 332  func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) RunAndReturn(run func(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error)) *MockLNClient_ExecuteCustomNodeCommand_Call {
 333  	_c.Call.Return(run)
 334  	return _c
 335  }
 336  
 337  // GetBalances provides a mock function for the type MockLNClient
 338  func (_mock *MockLNClient) GetBalances(ctx context.Context, includeInactiveChannels bool) (*lnclient.BalancesResponse, error) {
 339  	ret := _mock.Called(ctx, includeInactiveChannels)
 340  
 341  	if len(ret) == 0 {
 342  		panic("no return value specified for GetBalances")
 343  	}
 344  
 345  	var r0 *lnclient.BalancesResponse
 346  	var r1 error
 347  	if returnFunc, ok := ret.Get(0).(func(context.Context, bool) (*lnclient.BalancesResponse, error)); ok {
 348  		return returnFunc(ctx, includeInactiveChannels)
 349  	}
 350  	if returnFunc, ok := ret.Get(0).(func(context.Context, bool) *lnclient.BalancesResponse); ok {
 351  		r0 = returnFunc(ctx, includeInactiveChannels)
 352  	} else {
 353  		if ret.Get(0) != nil {
 354  			r0 = ret.Get(0).(*lnclient.BalancesResponse)
 355  		}
 356  	}
 357  	if returnFunc, ok := ret.Get(1).(func(context.Context, bool) error); ok {
 358  		r1 = returnFunc(ctx, includeInactiveChannels)
 359  	} else {
 360  		r1 = ret.Error(1)
 361  	}
 362  	return r0, r1
 363  }
 364  
 365  // MockLNClient_GetBalances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBalances'
 366  type MockLNClient_GetBalances_Call struct {
 367  	*mock.Call
 368  }
 369  
 370  // GetBalances is a helper method to define mock.On call
 371  //   - ctx context.Context
 372  //   - includeInactiveChannels bool
 373  func (_e *MockLNClient_Expecter) GetBalances(ctx interface{}, includeInactiveChannels interface{}) *MockLNClient_GetBalances_Call {
 374  	return &MockLNClient_GetBalances_Call{Call: _e.mock.On("GetBalances", ctx, includeInactiveChannels)}
 375  }
 376  
 377  func (_c *MockLNClient_GetBalances_Call) Run(run func(ctx context.Context, includeInactiveChannels bool)) *MockLNClient_GetBalances_Call {
 378  	_c.Call.Run(func(args mock.Arguments) {
 379  		var arg0 context.Context
 380  		if args[0] != nil {
 381  			arg0 = args[0].(context.Context)
 382  		}
 383  		var arg1 bool
 384  		if args[1] != nil {
 385  			arg1 = args[1].(bool)
 386  		}
 387  		run(
 388  			arg0,
 389  			arg1,
 390  		)
 391  	})
 392  	return _c
 393  }
 394  
 395  func (_c *MockLNClient_GetBalances_Call) Return(balancesResponse *lnclient.BalancesResponse, err error) *MockLNClient_GetBalances_Call {
 396  	_c.Call.Return(balancesResponse, err)
 397  	return _c
 398  }
 399  
 400  func (_c *MockLNClient_GetBalances_Call) RunAndReturn(run func(ctx context.Context, includeInactiveChannels bool) (*lnclient.BalancesResponse, error)) *MockLNClient_GetBalances_Call {
 401  	_c.Call.Return(run)
 402  	return _c
 403  }
 404  
 405  // GetCustomNodeCommandDefinitions provides a mock function for the type MockLNClient
 406  func (_mock *MockLNClient) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
 407  	ret := _mock.Called()
 408  
 409  	if len(ret) == 0 {
 410  		panic("no return value specified for GetCustomNodeCommandDefinitions")
 411  	}
 412  
 413  	var r0 []lnclient.CustomNodeCommandDef
 414  	if returnFunc, ok := ret.Get(0).(func() []lnclient.CustomNodeCommandDef); ok {
 415  		r0 = returnFunc()
 416  	} else {
 417  		if ret.Get(0) != nil {
 418  			r0 = ret.Get(0).([]lnclient.CustomNodeCommandDef)
 419  		}
 420  	}
 421  	return r0
 422  }
 423  
 424  // MockLNClient_GetCustomNodeCommandDefinitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCustomNodeCommandDefinitions'
 425  type MockLNClient_GetCustomNodeCommandDefinitions_Call struct {
 426  	*mock.Call
 427  }
 428  
 429  // GetCustomNodeCommandDefinitions is a helper method to define mock.On call
 430  func (_e *MockLNClient_Expecter) GetCustomNodeCommandDefinitions() *MockLNClient_GetCustomNodeCommandDefinitions_Call {
 431  	return &MockLNClient_GetCustomNodeCommandDefinitions_Call{Call: _e.mock.On("GetCustomNodeCommandDefinitions")}
 432  }
 433  
 434  func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) Run(run func()) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
 435  	_c.Call.Run(func(args mock.Arguments) {
 436  		run()
 437  	})
 438  	return _c
 439  }
 440  
 441  func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) Return(customNodeCommandDefs []lnclient.CustomNodeCommandDef) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
 442  	_c.Call.Return(customNodeCommandDefs)
 443  	return _c
 444  }
 445  
 446  func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) RunAndReturn(run func() []lnclient.CustomNodeCommandDef) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
 447  	_c.Call.Return(run)
 448  	return _c
 449  }
 450  
 451  // GetInfo provides a mock function for the type MockLNClient
 452  func (_mock *MockLNClient) GetInfo(ctx context.Context) (*lnclient.NodeInfo, error) {
 453  	ret := _mock.Called(ctx)
 454  
 455  	if len(ret) == 0 {
 456  		panic("no return value specified for GetInfo")
 457  	}
 458  
 459  	var r0 *lnclient.NodeInfo
 460  	var r1 error
 461  	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeInfo, error)); ok {
 462  		return returnFunc(ctx)
 463  	}
 464  	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.NodeInfo); ok {
 465  		r0 = returnFunc(ctx)
 466  	} else {
 467  		if ret.Get(0) != nil {
 468  			r0 = ret.Get(0).(*lnclient.NodeInfo)
 469  		}
 470  	}
 471  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
 472  		r1 = returnFunc(ctx)
 473  	} else {
 474  		r1 = ret.Error(1)
 475  	}
 476  	return r0, r1
 477  }
 478  
 479  // MockLNClient_GetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInfo'
 480  type MockLNClient_GetInfo_Call struct {
 481  	*mock.Call
 482  }
 483  
 484  // GetInfo is a helper method to define mock.On call
 485  //   - ctx context.Context
 486  func (_e *MockLNClient_Expecter) GetInfo(ctx interface{}) *MockLNClient_GetInfo_Call {
 487  	return &MockLNClient_GetInfo_Call{Call: _e.mock.On("GetInfo", ctx)}
 488  }
 489  
 490  func (_c *MockLNClient_GetInfo_Call) Run(run func(ctx context.Context)) *MockLNClient_GetInfo_Call {
 491  	_c.Call.Run(func(args mock.Arguments) {
 492  		var arg0 context.Context
 493  		if args[0] != nil {
 494  			arg0 = args[0].(context.Context)
 495  		}
 496  		run(
 497  			arg0,
 498  		)
 499  	})
 500  	return _c
 501  }
 502  
 503  func (_c *MockLNClient_GetInfo_Call) Return(info *lnclient.NodeInfo, err error) *MockLNClient_GetInfo_Call {
 504  	_c.Call.Return(info, err)
 505  	return _c
 506  }
 507  
 508  func (_c *MockLNClient_GetInfo_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.NodeInfo, error)) *MockLNClient_GetInfo_Call {
 509  	_c.Call.Return(run)
 510  	return _c
 511  }
 512  
 513  // GetLogOutput provides a mock function for the type MockLNClient
 514  func (_mock *MockLNClient) GetLogOutput(ctx context.Context, maxLen int) ([]byte, error) {
 515  	ret := _mock.Called(ctx, maxLen)
 516  
 517  	if len(ret) == 0 {
 518  		panic("no return value specified for GetLogOutput")
 519  	}
 520  
 521  	var r0 []byte
 522  	var r1 error
 523  	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]byte, error)); ok {
 524  		return returnFunc(ctx, maxLen)
 525  	}
 526  	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []byte); ok {
 527  		r0 = returnFunc(ctx, maxLen)
 528  	} else {
 529  		if ret.Get(0) != nil {
 530  			r0 = ret.Get(0).([]byte)
 531  		}
 532  	}
 533  	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
 534  		r1 = returnFunc(ctx, maxLen)
 535  	} else {
 536  		r1 = ret.Error(1)
 537  	}
 538  	return r0, r1
 539  }
 540  
 541  // MockLNClient_GetLogOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogOutput'
 542  type MockLNClient_GetLogOutput_Call struct {
 543  	*mock.Call
 544  }
 545  
 546  // GetLogOutput is a helper method to define mock.On call
 547  //   - ctx context.Context
 548  //   - maxLen int
 549  func (_e *MockLNClient_Expecter) GetLogOutput(ctx interface{}, maxLen interface{}) *MockLNClient_GetLogOutput_Call {
 550  	return &MockLNClient_GetLogOutput_Call{Call: _e.mock.On("GetLogOutput", ctx, maxLen)}
 551  }
 552  
 553  func (_c *MockLNClient_GetLogOutput_Call) Run(run func(ctx context.Context, maxLen int)) *MockLNClient_GetLogOutput_Call {
 554  	_c.Call.Run(func(args mock.Arguments) {
 555  		var arg0 context.Context
 556  		if args[0] != nil {
 557  			arg0 = args[0].(context.Context)
 558  		}
 559  		var arg1 int
 560  		if args[1] != nil {
 561  			arg1 = args[1].(int)
 562  		}
 563  		run(
 564  			arg0,
 565  			arg1,
 566  		)
 567  	})
 568  	return _c
 569  }
 570  
 571  func (_c *MockLNClient_GetLogOutput_Call) Return(bytes []byte, err error) *MockLNClient_GetLogOutput_Call {
 572  	_c.Call.Return(bytes, err)
 573  	return _c
 574  }
 575  
 576  func (_c *MockLNClient_GetLogOutput_Call) RunAndReturn(run func(ctx context.Context, maxLen int) ([]byte, error)) *MockLNClient_GetLogOutput_Call {
 577  	_c.Call.Return(run)
 578  	return _c
 579  }
 580  
 581  // GetNetworkGraph provides a mock function for the type MockLNClient
 582  func (_mock *MockLNClient) GetNetworkGraph(ctx context.Context, nodeIds []string) (lnclient.NetworkGraphResponse, error) {
 583  	ret := _mock.Called(ctx, nodeIds)
 584  
 585  	if len(ret) == 0 {
 586  		panic("no return value specified for GetNetworkGraph")
 587  	}
 588  
 589  	var r0 lnclient.NetworkGraphResponse
 590  	var r1 error
 591  	if returnFunc, ok := ret.Get(0).(func(context.Context, []string) (lnclient.NetworkGraphResponse, error)); ok {
 592  		return returnFunc(ctx, nodeIds)
 593  	}
 594  	if returnFunc, ok := ret.Get(0).(func(context.Context, []string) lnclient.NetworkGraphResponse); ok {
 595  		r0 = returnFunc(ctx, nodeIds)
 596  	} else {
 597  		if ret.Get(0) != nil {
 598  			r0 = ret.Get(0).(lnclient.NetworkGraphResponse)
 599  		}
 600  	}
 601  	if returnFunc, ok := ret.Get(1).(func(context.Context, []string) error); ok {
 602  		r1 = returnFunc(ctx, nodeIds)
 603  	} else {
 604  		r1 = ret.Error(1)
 605  	}
 606  	return r0, r1
 607  }
 608  
 609  // MockLNClient_GetNetworkGraph_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkGraph'
 610  type MockLNClient_GetNetworkGraph_Call struct {
 611  	*mock.Call
 612  }
 613  
 614  // GetNetworkGraph is a helper method to define mock.On call
 615  //   - ctx context.Context
 616  //   - nodeIds []string
 617  func (_e *MockLNClient_Expecter) GetNetworkGraph(ctx interface{}, nodeIds interface{}) *MockLNClient_GetNetworkGraph_Call {
 618  	return &MockLNClient_GetNetworkGraph_Call{Call: _e.mock.On("GetNetworkGraph", ctx, nodeIds)}
 619  }
 620  
 621  func (_c *MockLNClient_GetNetworkGraph_Call) Run(run func(ctx context.Context, nodeIds []string)) *MockLNClient_GetNetworkGraph_Call {
 622  	_c.Call.Run(func(args mock.Arguments) {
 623  		var arg0 context.Context
 624  		if args[0] != nil {
 625  			arg0 = args[0].(context.Context)
 626  		}
 627  		var arg1 []string
 628  		if args[1] != nil {
 629  			arg1 = args[1].([]string)
 630  		}
 631  		run(
 632  			arg0,
 633  			arg1,
 634  		)
 635  	})
 636  	return _c
 637  }
 638  
 639  func (_c *MockLNClient_GetNetworkGraph_Call) Return(v lnclient.NetworkGraphResponse, err error) *MockLNClient_GetNetworkGraph_Call {
 640  	_c.Call.Return(v, err)
 641  	return _c
 642  }
 643  
 644  func (_c *MockLNClient_GetNetworkGraph_Call) RunAndReturn(run func(ctx context.Context, nodeIds []string) (lnclient.NetworkGraphResponse, error)) *MockLNClient_GetNetworkGraph_Call {
 645  	_c.Call.Return(run)
 646  	return _c
 647  }
 648  
 649  // GetNewOnchainAddress provides a mock function for the type MockLNClient
 650  func (_mock *MockLNClient) GetNewOnchainAddress(ctx context.Context) (string, error) {
 651  	ret := _mock.Called(ctx)
 652  
 653  	if len(ret) == 0 {
 654  		panic("no return value specified for GetNewOnchainAddress")
 655  	}
 656  
 657  	var r0 string
 658  	var r1 error
 659  	if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
 660  		return returnFunc(ctx)
 661  	}
 662  	if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
 663  		r0 = returnFunc(ctx)
 664  	} else {
 665  		r0 = ret.Get(0).(string)
 666  	}
 667  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
 668  		r1 = returnFunc(ctx)
 669  	} else {
 670  		r1 = ret.Error(1)
 671  	}
 672  	return r0, r1
 673  }
 674  
 675  // MockLNClient_GetNewOnchainAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNewOnchainAddress'
 676  type MockLNClient_GetNewOnchainAddress_Call struct {
 677  	*mock.Call
 678  }
 679  
 680  // GetNewOnchainAddress is a helper method to define mock.On call
 681  //   - ctx context.Context
 682  func (_e *MockLNClient_Expecter) GetNewOnchainAddress(ctx interface{}) *MockLNClient_GetNewOnchainAddress_Call {
 683  	return &MockLNClient_GetNewOnchainAddress_Call{Call: _e.mock.On("GetNewOnchainAddress", ctx)}
 684  }
 685  
 686  func (_c *MockLNClient_GetNewOnchainAddress_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNewOnchainAddress_Call {
 687  	_c.Call.Run(func(args mock.Arguments) {
 688  		var arg0 context.Context
 689  		if args[0] != nil {
 690  			arg0 = args[0].(context.Context)
 691  		}
 692  		run(
 693  			arg0,
 694  		)
 695  	})
 696  	return _c
 697  }
 698  
 699  func (_c *MockLNClient_GetNewOnchainAddress_Call) Return(s string, err error) *MockLNClient_GetNewOnchainAddress_Call {
 700  	_c.Call.Return(s, err)
 701  	return _c
 702  }
 703  
 704  func (_c *MockLNClient_GetNewOnchainAddress_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockLNClient_GetNewOnchainAddress_Call {
 705  	_c.Call.Return(run)
 706  	return _c
 707  }
 708  
 709  // GetNodeConnectionInfo provides a mock function for the type MockLNClient
 710  func (_mock *MockLNClient) GetNodeConnectionInfo(ctx context.Context) (*lnclient.NodeConnectionInfo, error) {
 711  	ret := _mock.Called(ctx)
 712  
 713  	if len(ret) == 0 {
 714  		panic("no return value specified for GetNodeConnectionInfo")
 715  	}
 716  
 717  	var r0 *lnclient.NodeConnectionInfo
 718  	var r1 error
 719  	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeConnectionInfo, error)); ok {
 720  		return returnFunc(ctx)
 721  	}
 722  	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.NodeConnectionInfo); ok {
 723  		r0 = returnFunc(ctx)
 724  	} else {
 725  		if ret.Get(0) != nil {
 726  			r0 = ret.Get(0).(*lnclient.NodeConnectionInfo)
 727  		}
 728  	}
 729  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
 730  		r1 = returnFunc(ctx)
 731  	} else {
 732  		r1 = ret.Error(1)
 733  	}
 734  	return r0, r1
 735  }
 736  
 737  // MockLNClient_GetNodeConnectionInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeConnectionInfo'
 738  type MockLNClient_GetNodeConnectionInfo_Call struct {
 739  	*mock.Call
 740  }
 741  
 742  // GetNodeConnectionInfo is a helper method to define mock.On call
 743  //   - ctx context.Context
 744  func (_e *MockLNClient_Expecter) GetNodeConnectionInfo(ctx interface{}) *MockLNClient_GetNodeConnectionInfo_Call {
 745  	return &MockLNClient_GetNodeConnectionInfo_Call{Call: _e.mock.On("GetNodeConnectionInfo", ctx)}
 746  }
 747  
 748  func (_c *MockLNClient_GetNodeConnectionInfo_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNodeConnectionInfo_Call {
 749  	_c.Call.Run(func(args mock.Arguments) {
 750  		var arg0 context.Context
 751  		if args[0] != nil {
 752  			arg0 = args[0].(context.Context)
 753  		}
 754  		run(
 755  			arg0,
 756  		)
 757  	})
 758  	return _c
 759  }
 760  
 761  func (_c *MockLNClient_GetNodeConnectionInfo_Call) Return(nodeConnectionInfo *lnclient.NodeConnectionInfo, err error) *MockLNClient_GetNodeConnectionInfo_Call {
 762  	_c.Call.Return(nodeConnectionInfo, err)
 763  	return _c
 764  }
 765  
 766  func (_c *MockLNClient_GetNodeConnectionInfo_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.NodeConnectionInfo, error)) *MockLNClient_GetNodeConnectionInfo_Call {
 767  	_c.Call.Return(run)
 768  	return _c
 769  }
 770  
 771  // GetNodeStatus provides a mock function for the type MockLNClient
 772  func (_mock *MockLNClient) GetNodeStatus(ctx context.Context) (*lnclient.NodeStatus, error) {
 773  	ret := _mock.Called(ctx)
 774  
 775  	if len(ret) == 0 {
 776  		panic("no return value specified for GetNodeStatus")
 777  	}
 778  
 779  	var r0 *lnclient.NodeStatus
 780  	var r1 error
 781  	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeStatus, error)); ok {
 782  		return returnFunc(ctx)
 783  	}
 784  	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.NodeStatus); ok {
 785  		r0 = returnFunc(ctx)
 786  	} else {
 787  		if ret.Get(0) != nil {
 788  			r0 = ret.Get(0).(*lnclient.NodeStatus)
 789  		}
 790  	}
 791  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
 792  		r1 = returnFunc(ctx)
 793  	} else {
 794  		r1 = ret.Error(1)
 795  	}
 796  	return r0, r1
 797  }
 798  
 799  // MockLNClient_GetNodeStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeStatus'
 800  type MockLNClient_GetNodeStatus_Call struct {
 801  	*mock.Call
 802  }
 803  
 804  // GetNodeStatus is a helper method to define mock.On call
 805  //   - ctx context.Context
 806  func (_e *MockLNClient_Expecter) GetNodeStatus(ctx interface{}) *MockLNClient_GetNodeStatus_Call {
 807  	return &MockLNClient_GetNodeStatus_Call{Call: _e.mock.On("GetNodeStatus", ctx)}
 808  }
 809  
 810  func (_c *MockLNClient_GetNodeStatus_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNodeStatus_Call {
 811  	_c.Call.Run(func(args mock.Arguments) {
 812  		var arg0 context.Context
 813  		if args[0] != nil {
 814  			arg0 = args[0].(context.Context)
 815  		}
 816  		run(
 817  			arg0,
 818  		)
 819  	})
 820  	return _c
 821  }
 822  
 823  func (_c *MockLNClient_GetNodeStatus_Call) Return(nodeStatus *lnclient.NodeStatus, err error) *MockLNClient_GetNodeStatus_Call {
 824  	_c.Call.Return(nodeStatus, err)
 825  	return _c
 826  }
 827  
 828  func (_c *MockLNClient_GetNodeStatus_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.NodeStatus, error)) *MockLNClient_GetNodeStatus_Call {
 829  	_c.Call.Return(run)
 830  	return _c
 831  }
 832  
 833  // GetOnchainBalance provides a mock function for the type MockLNClient
 834  func (_mock *MockLNClient) GetOnchainBalance(ctx context.Context) (*lnclient.OnchainBalanceResponse, error) {
 835  	ret := _mock.Called(ctx)
 836  
 837  	if len(ret) == 0 {
 838  		panic("no return value specified for GetOnchainBalance")
 839  	}
 840  
 841  	var r0 *lnclient.OnchainBalanceResponse
 842  	var r1 error
 843  	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.OnchainBalanceResponse, error)); ok {
 844  		return returnFunc(ctx)
 845  	}
 846  	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.OnchainBalanceResponse); ok {
 847  		r0 = returnFunc(ctx)
 848  	} else {
 849  		if ret.Get(0) != nil {
 850  			r0 = ret.Get(0).(*lnclient.OnchainBalanceResponse)
 851  		}
 852  	}
 853  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
 854  		r1 = returnFunc(ctx)
 855  	} else {
 856  		r1 = ret.Error(1)
 857  	}
 858  	return r0, r1
 859  }
 860  
 861  // MockLNClient_GetOnchainBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOnchainBalance'
 862  type MockLNClient_GetOnchainBalance_Call struct {
 863  	*mock.Call
 864  }
 865  
 866  // GetOnchainBalance is a helper method to define mock.On call
 867  //   - ctx context.Context
 868  func (_e *MockLNClient_Expecter) GetOnchainBalance(ctx interface{}) *MockLNClient_GetOnchainBalance_Call {
 869  	return &MockLNClient_GetOnchainBalance_Call{Call: _e.mock.On("GetOnchainBalance", ctx)}
 870  }
 871  
 872  func (_c *MockLNClient_GetOnchainBalance_Call) Run(run func(ctx context.Context)) *MockLNClient_GetOnchainBalance_Call {
 873  	_c.Call.Run(func(args mock.Arguments) {
 874  		var arg0 context.Context
 875  		if args[0] != nil {
 876  			arg0 = args[0].(context.Context)
 877  		}
 878  		run(
 879  			arg0,
 880  		)
 881  	})
 882  	return _c
 883  }
 884  
 885  func (_c *MockLNClient_GetOnchainBalance_Call) Return(onchainBalanceResponse *lnclient.OnchainBalanceResponse, err error) *MockLNClient_GetOnchainBalance_Call {
 886  	_c.Call.Return(onchainBalanceResponse, err)
 887  	return _c
 888  }
 889  
 890  func (_c *MockLNClient_GetOnchainBalance_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.OnchainBalanceResponse, error)) *MockLNClient_GetOnchainBalance_Call {
 891  	_c.Call.Return(run)
 892  	return _c
 893  }
 894  
 895  // GetPubkey provides a mock function for the type MockLNClient
 896  func (_mock *MockLNClient) GetPubkey() string {
 897  	ret := _mock.Called()
 898  
 899  	if len(ret) == 0 {
 900  		panic("no return value specified for GetPubkey")
 901  	}
 902  
 903  	var r0 string
 904  	if returnFunc, ok := ret.Get(0).(func() string); ok {
 905  		r0 = returnFunc()
 906  	} else {
 907  		r0 = ret.Get(0).(string)
 908  	}
 909  	return r0
 910  }
 911  
 912  // MockLNClient_GetPubkey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPubkey'
 913  type MockLNClient_GetPubkey_Call struct {
 914  	*mock.Call
 915  }
 916  
 917  // GetPubkey is a helper method to define mock.On call
 918  func (_e *MockLNClient_Expecter) GetPubkey() *MockLNClient_GetPubkey_Call {
 919  	return &MockLNClient_GetPubkey_Call{Call: _e.mock.On("GetPubkey")}
 920  }
 921  
 922  func (_c *MockLNClient_GetPubkey_Call) Run(run func()) *MockLNClient_GetPubkey_Call {
 923  	_c.Call.Run(func(args mock.Arguments) {
 924  		run()
 925  	})
 926  	return _c
 927  }
 928  
 929  func (_c *MockLNClient_GetPubkey_Call) Return(s string) *MockLNClient_GetPubkey_Call {
 930  	_c.Call.Return(s)
 931  	return _c
 932  }
 933  
 934  func (_c *MockLNClient_GetPubkey_Call) RunAndReturn(run func() string) *MockLNClient_GetPubkey_Call {
 935  	_c.Call.Return(run)
 936  	return _c
 937  }
 938  
 939  // GetStorageDir provides a mock function for the type MockLNClient
 940  func (_mock *MockLNClient) GetStorageDir() (string, error) {
 941  	ret := _mock.Called()
 942  
 943  	if len(ret) == 0 {
 944  		panic("no return value specified for GetStorageDir")
 945  	}
 946  
 947  	var r0 string
 948  	var r1 error
 949  	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
 950  		return returnFunc()
 951  	}
 952  	if returnFunc, ok := ret.Get(0).(func() string); ok {
 953  		r0 = returnFunc()
 954  	} else {
 955  		r0 = ret.Get(0).(string)
 956  	}
 957  	if returnFunc, ok := ret.Get(1).(func() error); ok {
 958  		r1 = returnFunc()
 959  	} else {
 960  		r1 = ret.Error(1)
 961  	}
 962  	return r0, r1
 963  }
 964  
 965  // MockLNClient_GetStorageDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStorageDir'
 966  type MockLNClient_GetStorageDir_Call struct {
 967  	*mock.Call
 968  }
 969  
 970  // GetStorageDir is a helper method to define mock.On call
 971  func (_e *MockLNClient_Expecter) GetStorageDir() *MockLNClient_GetStorageDir_Call {
 972  	return &MockLNClient_GetStorageDir_Call{Call: _e.mock.On("GetStorageDir")}
 973  }
 974  
 975  func (_c *MockLNClient_GetStorageDir_Call) Run(run func()) *MockLNClient_GetStorageDir_Call {
 976  	_c.Call.Run(func(args mock.Arguments) {
 977  		run()
 978  	})
 979  	return _c
 980  }
 981  
 982  func (_c *MockLNClient_GetStorageDir_Call) Return(s string, err error) *MockLNClient_GetStorageDir_Call {
 983  	_c.Call.Return(s, err)
 984  	return _c
 985  }
 986  
 987  func (_c *MockLNClient_GetStorageDir_Call) RunAndReturn(run func() (string, error)) *MockLNClient_GetStorageDir_Call {
 988  	_c.Call.Return(run)
 989  	return _c
 990  }
 991  
 992  // GetSupportedNIP47Methods provides a mock function for the type MockLNClient
 993  func (_mock *MockLNClient) GetSupportedNIP47Methods() []string {
 994  	ret := _mock.Called()
 995  
 996  	if len(ret) == 0 {
 997  		panic("no return value specified for GetSupportedNIP47Methods")
 998  	}
 999  
1000  	var r0 []string
1001  	if returnFunc, ok := ret.Get(0).(func() []string); ok {
1002  		r0 = returnFunc()
1003  	} else {
1004  		if ret.Get(0) != nil {
1005  			r0 = ret.Get(0).([]string)
1006  		}
1007  	}
1008  	return r0
1009  }
1010  
1011  // MockLNClient_GetSupportedNIP47Methods_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSupportedNIP47Methods'
1012  type MockLNClient_GetSupportedNIP47Methods_Call struct {
1013  	*mock.Call
1014  }
1015  
1016  // GetSupportedNIP47Methods is a helper method to define mock.On call
1017  func (_e *MockLNClient_Expecter) GetSupportedNIP47Methods() *MockLNClient_GetSupportedNIP47Methods_Call {
1018  	return &MockLNClient_GetSupportedNIP47Methods_Call{Call: _e.mock.On("GetSupportedNIP47Methods")}
1019  }
1020  
1021  func (_c *MockLNClient_GetSupportedNIP47Methods_Call) Run(run func()) *MockLNClient_GetSupportedNIP47Methods_Call {
1022  	_c.Call.Run(func(args mock.Arguments) {
1023  		run()
1024  	})
1025  	return _c
1026  }
1027  
1028  func (_c *MockLNClient_GetSupportedNIP47Methods_Call) Return(strings []string) *MockLNClient_GetSupportedNIP47Methods_Call {
1029  	_c.Call.Return(strings)
1030  	return _c
1031  }
1032  
1033  func (_c *MockLNClient_GetSupportedNIP47Methods_Call) RunAndReturn(run func() []string) *MockLNClient_GetSupportedNIP47Methods_Call {
1034  	_c.Call.Return(run)
1035  	return _c
1036  }
1037  
1038  // GetSupportedNIP47NotificationTypes provides a mock function for the type MockLNClient
1039  func (_mock *MockLNClient) GetSupportedNIP47NotificationTypes() []string {
1040  	ret := _mock.Called()
1041  
1042  	if len(ret) == 0 {
1043  		panic("no return value specified for GetSupportedNIP47NotificationTypes")
1044  	}
1045  
1046  	var r0 []string
1047  	if returnFunc, ok := ret.Get(0).(func() []string); ok {
1048  		r0 = returnFunc()
1049  	} else {
1050  		if ret.Get(0) != nil {
1051  			r0 = ret.Get(0).([]string)
1052  		}
1053  	}
1054  	return r0
1055  }
1056  
1057  // MockLNClient_GetSupportedNIP47NotificationTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSupportedNIP47NotificationTypes'
1058  type MockLNClient_GetSupportedNIP47NotificationTypes_Call struct {
1059  	*mock.Call
1060  }
1061  
1062  // GetSupportedNIP47NotificationTypes is a helper method to define mock.On call
1063  func (_e *MockLNClient_Expecter) GetSupportedNIP47NotificationTypes() *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
1064  	return &MockLNClient_GetSupportedNIP47NotificationTypes_Call{Call: _e.mock.On("GetSupportedNIP47NotificationTypes")}
1065  }
1066  
1067  func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) Run(run func()) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
1068  	_c.Call.Run(func(args mock.Arguments) {
1069  		run()
1070  	})
1071  	return _c
1072  }
1073  
1074  func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) Return(strings []string) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
1075  	_c.Call.Return(strings)
1076  	return _c
1077  }
1078  
1079  func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) RunAndReturn(run func() []string) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
1080  	_c.Call.Return(run)
1081  	return _c
1082  }
1083  
1084  // ListChannels provides a mock function for the type MockLNClient
1085  func (_mock *MockLNClient) ListChannels(ctx context.Context) ([]lnclient.Channel, error) {
1086  	ret := _mock.Called(ctx)
1087  
1088  	if len(ret) == 0 {
1089  		panic("no return value specified for ListChannels")
1090  	}
1091  
1092  	var r0 []lnclient.Channel
1093  	var r1 error
1094  	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]lnclient.Channel, error)); ok {
1095  		return returnFunc(ctx)
1096  	}
1097  	if returnFunc, ok := ret.Get(0).(func(context.Context) []lnclient.Channel); ok {
1098  		r0 = returnFunc(ctx)
1099  	} else {
1100  		if ret.Get(0) != nil {
1101  			r0 = ret.Get(0).([]lnclient.Channel)
1102  		}
1103  	}
1104  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1105  		r1 = returnFunc(ctx)
1106  	} else {
1107  		r1 = ret.Error(1)
1108  	}
1109  	return r0, r1
1110  }
1111  
1112  // MockLNClient_ListChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannels'
1113  type MockLNClient_ListChannels_Call struct {
1114  	*mock.Call
1115  }
1116  
1117  // ListChannels is a helper method to define mock.On call
1118  //   - ctx context.Context
1119  func (_e *MockLNClient_Expecter) ListChannels(ctx interface{}) *MockLNClient_ListChannels_Call {
1120  	return &MockLNClient_ListChannels_Call{Call: _e.mock.On("ListChannels", ctx)}
1121  }
1122  
1123  func (_c *MockLNClient_ListChannels_Call) Run(run func(ctx context.Context)) *MockLNClient_ListChannels_Call {
1124  	_c.Call.Run(func(args mock.Arguments) {
1125  		var arg0 context.Context
1126  		if args[0] != nil {
1127  			arg0 = args[0].(context.Context)
1128  		}
1129  		run(
1130  			arg0,
1131  		)
1132  	})
1133  	return _c
1134  }
1135  
1136  func (_c *MockLNClient_ListChannels_Call) Return(channels []lnclient.Channel, err error) *MockLNClient_ListChannels_Call {
1137  	_c.Call.Return(channels, err)
1138  	return _c
1139  }
1140  
1141  func (_c *MockLNClient_ListChannels_Call) RunAndReturn(run func(ctx context.Context) ([]lnclient.Channel, error)) *MockLNClient_ListChannels_Call {
1142  	_c.Call.Return(run)
1143  	return _c
1144  }
1145  
1146  // ListOnchainTransactions provides a mock function for the type MockLNClient
1147  func (_mock *MockLNClient) ListOnchainTransactions(ctx context.Context) ([]lnclient.OnchainTransaction, error) {
1148  	ret := _mock.Called(ctx)
1149  
1150  	if len(ret) == 0 {
1151  		panic("no return value specified for ListOnchainTransactions")
1152  	}
1153  
1154  	var r0 []lnclient.OnchainTransaction
1155  	var r1 error
1156  	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]lnclient.OnchainTransaction, error)); ok {
1157  		return returnFunc(ctx)
1158  	}
1159  	if returnFunc, ok := ret.Get(0).(func(context.Context) []lnclient.OnchainTransaction); ok {
1160  		r0 = returnFunc(ctx)
1161  	} else {
1162  		if ret.Get(0) != nil {
1163  			r0 = ret.Get(0).([]lnclient.OnchainTransaction)
1164  		}
1165  	}
1166  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1167  		r1 = returnFunc(ctx)
1168  	} else {
1169  		r1 = ret.Error(1)
1170  	}
1171  	return r0, r1
1172  }
1173  
1174  // MockLNClient_ListOnchainTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOnchainTransactions'
1175  type MockLNClient_ListOnchainTransactions_Call struct {
1176  	*mock.Call
1177  }
1178  
1179  // ListOnchainTransactions is a helper method to define mock.On call
1180  //   - ctx context.Context
1181  func (_e *MockLNClient_Expecter) ListOnchainTransactions(ctx interface{}) *MockLNClient_ListOnchainTransactions_Call {
1182  	return &MockLNClient_ListOnchainTransactions_Call{Call: _e.mock.On("ListOnchainTransactions", ctx)}
1183  }
1184  
1185  func (_c *MockLNClient_ListOnchainTransactions_Call) Run(run func(ctx context.Context)) *MockLNClient_ListOnchainTransactions_Call {
1186  	_c.Call.Run(func(args mock.Arguments) {
1187  		var arg0 context.Context
1188  		if args[0] != nil {
1189  			arg0 = args[0].(context.Context)
1190  		}
1191  		run(
1192  			arg0,
1193  		)
1194  	})
1195  	return _c
1196  }
1197  
1198  func (_c *MockLNClient_ListOnchainTransactions_Call) Return(onchainTransactions []lnclient.OnchainTransaction, err error) *MockLNClient_ListOnchainTransactions_Call {
1199  	_c.Call.Return(onchainTransactions, err)
1200  	return _c
1201  }
1202  
1203  func (_c *MockLNClient_ListOnchainTransactions_Call) RunAndReturn(run func(ctx context.Context) ([]lnclient.OnchainTransaction, error)) *MockLNClient_ListOnchainTransactions_Call {
1204  	_c.Call.Return(run)
1205  	return _c
1206  }
1207  
1208  // ListPeers provides a mock function for the type MockLNClient
1209  func (_mock *MockLNClient) ListPeers(ctx context.Context) ([]lnclient.PeerDetails, error) {
1210  	ret := _mock.Called(ctx)
1211  
1212  	if len(ret) == 0 {
1213  		panic("no return value specified for ListPeers")
1214  	}
1215  
1216  	var r0 []lnclient.PeerDetails
1217  	var r1 error
1218  	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]lnclient.PeerDetails, error)); ok {
1219  		return returnFunc(ctx)
1220  	}
1221  	if returnFunc, ok := ret.Get(0).(func(context.Context) []lnclient.PeerDetails); ok {
1222  		r0 = returnFunc(ctx)
1223  	} else {
1224  		if ret.Get(0) != nil {
1225  			r0 = ret.Get(0).([]lnclient.PeerDetails)
1226  		}
1227  	}
1228  	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1229  		r1 = returnFunc(ctx)
1230  	} else {
1231  		r1 = ret.Error(1)
1232  	}
1233  	return r0, r1
1234  }
1235  
1236  // MockLNClient_ListPeers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeers'
1237  type MockLNClient_ListPeers_Call struct {
1238  	*mock.Call
1239  }
1240  
1241  // ListPeers is a helper method to define mock.On call
1242  //   - ctx context.Context
1243  func (_e *MockLNClient_Expecter) ListPeers(ctx interface{}) *MockLNClient_ListPeers_Call {
1244  	return &MockLNClient_ListPeers_Call{Call: _e.mock.On("ListPeers", ctx)}
1245  }
1246  
1247  func (_c *MockLNClient_ListPeers_Call) Run(run func(ctx context.Context)) *MockLNClient_ListPeers_Call {
1248  	_c.Call.Run(func(args mock.Arguments) {
1249  		var arg0 context.Context
1250  		if args[0] != nil {
1251  			arg0 = args[0].(context.Context)
1252  		}
1253  		run(
1254  			arg0,
1255  		)
1256  	})
1257  	return _c
1258  }
1259  
1260  func (_c *MockLNClient_ListPeers_Call) Return(peerDetailss []lnclient.PeerDetails, err error) *MockLNClient_ListPeers_Call {
1261  	_c.Call.Return(peerDetailss, err)
1262  	return _c
1263  }
1264  
1265  func (_c *MockLNClient_ListPeers_Call) RunAndReturn(run func(ctx context.Context) ([]lnclient.PeerDetails, error)) *MockLNClient_ListPeers_Call {
1266  	_c.Call.Return(run)
1267  	return _c
1268  }
1269  
1270  // LookupInvoice provides a mock function for the type MockLNClient
1271  func (_mock *MockLNClient) LookupInvoice(ctx context.Context, paymentHash string) (*lnclient.Transaction, error) {
1272  	ret := _mock.Called(ctx, paymentHash)
1273  
1274  	if len(ret) == 0 {
1275  		panic("no return value specified for LookupInvoice")
1276  	}
1277  
1278  	var r0 *lnclient.Transaction
1279  	var r1 error
1280  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*lnclient.Transaction, error)); ok {
1281  		return returnFunc(ctx, paymentHash)
1282  	}
1283  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *lnclient.Transaction); ok {
1284  		r0 = returnFunc(ctx, paymentHash)
1285  	} else {
1286  		if ret.Get(0) != nil {
1287  			r0 = ret.Get(0).(*lnclient.Transaction)
1288  		}
1289  	}
1290  	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1291  		r1 = returnFunc(ctx, paymentHash)
1292  	} else {
1293  		r1 = ret.Error(1)
1294  	}
1295  	return r0, r1
1296  }
1297  
1298  // MockLNClient_LookupInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LookupInvoice'
1299  type MockLNClient_LookupInvoice_Call struct {
1300  	*mock.Call
1301  }
1302  
1303  // LookupInvoice is a helper method to define mock.On call
1304  //   - ctx context.Context
1305  //   - paymentHash string
1306  func (_e *MockLNClient_Expecter) LookupInvoice(ctx interface{}, paymentHash interface{}) *MockLNClient_LookupInvoice_Call {
1307  	return &MockLNClient_LookupInvoice_Call{Call: _e.mock.On("LookupInvoice", ctx, paymentHash)}
1308  }
1309  
1310  func (_c *MockLNClient_LookupInvoice_Call) Run(run func(ctx context.Context, paymentHash string)) *MockLNClient_LookupInvoice_Call {
1311  	_c.Call.Run(func(args mock.Arguments) {
1312  		var arg0 context.Context
1313  		if args[0] != nil {
1314  			arg0 = args[0].(context.Context)
1315  		}
1316  		var arg1 string
1317  		if args[1] != nil {
1318  			arg1 = args[1].(string)
1319  		}
1320  		run(
1321  			arg0,
1322  			arg1,
1323  		)
1324  	})
1325  	return _c
1326  }
1327  
1328  func (_c *MockLNClient_LookupInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_LookupInvoice_Call {
1329  	_c.Call.Return(transaction, err)
1330  	return _c
1331  }
1332  
1333  func (_c *MockLNClient_LookupInvoice_Call) RunAndReturn(run func(ctx context.Context, paymentHash string) (*lnclient.Transaction, error)) *MockLNClient_LookupInvoice_Call {
1334  	_c.Call.Return(run)
1335  	return _c
1336  }
1337  
1338  // MakeHoldInvoice provides a mock function for the type MockLNClient
1339  func (_mock *MockLNClient) MakeHoldInvoice(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, paymentHash string, minCltvExpiryDelta *uint64) (*lnclient.Transaction, error) {
1340  	ret := _mock.Called(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)
1341  
1342  	if len(ret) == 0 {
1343  		panic("no return value specified for MakeHoldInvoice")
1344  	}
1345  
1346  	var r0 *lnclient.Transaction
1347  	var r1 error
1348  	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, string, *uint64) (*lnclient.Transaction, error)); ok {
1349  		return returnFunc(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)
1350  	}
1351  	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, string, *uint64) *lnclient.Transaction); ok {
1352  		r0 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)
1353  	} else {
1354  		if ret.Get(0) != nil {
1355  			r0 = ret.Get(0).(*lnclient.Transaction)
1356  		}
1357  	}
1358  	if returnFunc, ok := ret.Get(1).(func(context.Context, int64, string, string, int64, string, *uint64) error); ok {
1359  		r1 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)
1360  	} else {
1361  		r1 = ret.Error(1)
1362  	}
1363  	return r0, r1
1364  }
1365  
1366  // MockLNClient_MakeHoldInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeHoldInvoice'
1367  type MockLNClient_MakeHoldInvoice_Call struct {
1368  	*mock.Call
1369  }
1370  
1371  // MakeHoldInvoice is a helper method to define mock.On call
1372  //   - ctx context.Context
1373  //   - amountMsat int64
1374  //   - description string
1375  //   - descriptionHash string
1376  //   - expiry int64
1377  //   - paymentHash string
1378  //   - minCltvExpiryDelta *uint64
1379  func (_e *MockLNClient_Expecter) MakeHoldInvoice(ctx interface{}, amountMsat interface{}, description interface{}, descriptionHash interface{}, expiry interface{}, paymentHash interface{}, minCltvExpiryDelta interface{}) *MockLNClient_MakeHoldInvoice_Call {
1380  	return &MockLNClient_MakeHoldInvoice_Call{Call: _e.mock.On("MakeHoldInvoice", ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)}
1381  }
1382  
1383  func (_c *MockLNClient_MakeHoldInvoice_Call) Run(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, paymentHash string, minCltvExpiryDelta *uint64)) *MockLNClient_MakeHoldInvoice_Call {
1384  	_c.Call.Run(func(args mock.Arguments) {
1385  		var arg0 context.Context
1386  		if args[0] != nil {
1387  			arg0 = args[0].(context.Context)
1388  		}
1389  		var arg1 int64
1390  		if args[1] != nil {
1391  			arg1 = args[1].(int64)
1392  		}
1393  		var arg2 string
1394  		if args[2] != nil {
1395  			arg2 = args[2].(string)
1396  		}
1397  		var arg3 string
1398  		if args[3] != nil {
1399  			arg3 = args[3].(string)
1400  		}
1401  		var arg4 int64
1402  		if args[4] != nil {
1403  			arg4 = args[4].(int64)
1404  		}
1405  		var arg5 string
1406  		if args[5] != nil {
1407  			arg5 = args[5].(string)
1408  		}
1409  		var arg6 *uint64
1410  		if args[6] != nil {
1411  			arg6 = args[6].(*uint64)
1412  		}
1413  		run(
1414  			arg0,
1415  			arg1,
1416  			arg2,
1417  			arg3,
1418  			arg4,
1419  			arg5,
1420  			arg6,
1421  		)
1422  	})
1423  	return _c
1424  }
1425  
1426  func (_c *MockLNClient_MakeHoldInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_MakeHoldInvoice_Call {
1427  	_c.Call.Return(transaction, err)
1428  	return _c
1429  }
1430  
1431  func (_c *MockLNClient_MakeHoldInvoice_Call) RunAndReturn(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, paymentHash string, minCltvExpiryDelta *uint64) (*lnclient.Transaction, error)) *MockLNClient_MakeHoldInvoice_Call {
1432  	_c.Call.Return(run)
1433  	return _c
1434  }
1435  
1436  // MakeInvoice provides a mock function for the type MockLNClient
1437  func (_mock *MockLNClient) MakeInvoice(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, throughNodePubkey *string) (*lnclient.Transaction, error) {
1438  	ret := _mock.Called(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)
1439  
1440  	if len(ret) == 0 {
1441  		panic("no return value specified for MakeInvoice")
1442  	}
1443  
1444  	var r0 *lnclient.Transaction
1445  	var r1 error
1446  	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, *string) (*lnclient.Transaction, error)); ok {
1447  		return returnFunc(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)
1448  	}
1449  	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, *string) *lnclient.Transaction); ok {
1450  		r0 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)
1451  	} else {
1452  		if ret.Get(0) != nil {
1453  			r0 = ret.Get(0).(*lnclient.Transaction)
1454  		}
1455  	}
1456  	if returnFunc, ok := ret.Get(1).(func(context.Context, int64, string, string, int64, *string) error); ok {
1457  		r1 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)
1458  	} else {
1459  		r1 = ret.Error(1)
1460  	}
1461  	return r0, r1
1462  }
1463  
1464  // MockLNClient_MakeInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeInvoice'
1465  type MockLNClient_MakeInvoice_Call struct {
1466  	*mock.Call
1467  }
1468  
1469  // MakeInvoice is a helper method to define mock.On call
1470  //   - ctx context.Context
1471  //   - amountMsat int64
1472  //   - description string
1473  //   - descriptionHash string
1474  //   - expiry int64
1475  //   - throughNodePubkey *string
1476  func (_e *MockLNClient_Expecter) MakeInvoice(ctx interface{}, amountMsat interface{}, description interface{}, descriptionHash interface{}, expiry interface{}, throughNodePubkey interface{}) *MockLNClient_MakeInvoice_Call {
1477  	return &MockLNClient_MakeInvoice_Call{Call: _e.mock.On("MakeInvoice", ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)}
1478  }
1479  
1480  func (_c *MockLNClient_MakeInvoice_Call) Run(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, throughNodePubkey *string)) *MockLNClient_MakeInvoice_Call {
1481  	_c.Call.Run(func(args mock.Arguments) {
1482  		var arg0 context.Context
1483  		if args[0] != nil {
1484  			arg0 = args[0].(context.Context)
1485  		}
1486  		var arg1 int64
1487  		if args[1] != nil {
1488  			arg1 = args[1].(int64)
1489  		}
1490  		var arg2 string
1491  		if args[2] != nil {
1492  			arg2 = args[2].(string)
1493  		}
1494  		var arg3 string
1495  		if args[3] != nil {
1496  			arg3 = args[3].(string)
1497  		}
1498  		var arg4 int64
1499  		if args[4] != nil {
1500  			arg4 = args[4].(int64)
1501  		}
1502  		var arg5 *string
1503  		if args[5] != nil {
1504  			arg5 = args[5].(*string)
1505  		}
1506  		run(
1507  			arg0,
1508  			arg1,
1509  			arg2,
1510  			arg3,
1511  			arg4,
1512  			arg5,
1513  		)
1514  	})
1515  	return _c
1516  }
1517  
1518  func (_c *MockLNClient_MakeInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_MakeInvoice_Call {
1519  	_c.Call.Return(transaction, err)
1520  	return _c
1521  }
1522  
1523  func (_c *MockLNClient_MakeInvoice_Call) RunAndReturn(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, throughNodePubkey *string) (*lnclient.Transaction, error)) *MockLNClient_MakeInvoice_Call {
1524  	_c.Call.Return(run)
1525  	return _c
1526  }
1527  
1528  // MakeOffer provides a mock function for the type MockLNClient
1529  func (_mock *MockLNClient) MakeOffer(ctx context.Context, description string) (string, error) {
1530  	ret := _mock.Called(ctx, description)
1531  
1532  	if len(ret) == 0 {
1533  		panic("no return value specified for MakeOffer")
1534  	}
1535  
1536  	var r0 string
1537  	var r1 error
1538  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
1539  		return returnFunc(ctx, description)
1540  	}
1541  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
1542  		r0 = returnFunc(ctx, description)
1543  	} else {
1544  		r0 = ret.Get(0).(string)
1545  	}
1546  	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1547  		r1 = returnFunc(ctx, description)
1548  	} else {
1549  		r1 = ret.Error(1)
1550  	}
1551  	return r0, r1
1552  }
1553  
1554  // MockLNClient_MakeOffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeOffer'
1555  type MockLNClient_MakeOffer_Call struct {
1556  	*mock.Call
1557  }
1558  
1559  // MakeOffer is a helper method to define mock.On call
1560  //   - ctx context.Context
1561  //   - description string
1562  func (_e *MockLNClient_Expecter) MakeOffer(ctx interface{}, description interface{}) *MockLNClient_MakeOffer_Call {
1563  	return &MockLNClient_MakeOffer_Call{Call: _e.mock.On("MakeOffer", ctx, description)}
1564  }
1565  
1566  func (_c *MockLNClient_MakeOffer_Call) Run(run func(ctx context.Context, description string)) *MockLNClient_MakeOffer_Call {
1567  	_c.Call.Run(func(args mock.Arguments) {
1568  		var arg0 context.Context
1569  		if args[0] != nil {
1570  			arg0 = args[0].(context.Context)
1571  		}
1572  		var arg1 string
1573  		if args[1] != nil {
1574  			arg1 = args[1].(string)
1575  		}
1576  		run(
1577  			arg0,
1578  			arg1,
1579  		)
1580  	})
1581  	return _c
1582  }
1583  
1584  func (_c *MockLNClient_MakeOffer_Call) Return(s string, err error) *MockLNClient_MakeOffer_Call {
1585  	_c.Call.Return(s, err)
1586  	return _c
1587  }
1588  
1589  func (_c *MockLNClient_MakeOffer_Call) RunAndReturn(run func(ctx context.Context, description string) (string, error)) *MockLNClient_MakeOffer_Call {
1590  	_c.Call.Return(run)
1591  	return _c
1592  }
1593  
1594  // OpenChannel provides a mock function for the type MockLNClient
1595  func (_mock *MockLNClient) OpenChannel(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error) {
1596  	ret := _mock.Called(ctx, openChannelRequest)
1597  
1598  	if len(ret) == 0 {
1599  		panic("no return value specified for OpenChannel")
1600  	}
1601  
1602  	var r0 *lnclient.OpenChannelResponse
1603  	var r1 error
1604  	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error)); ok {
1605  		return returnFunc(ctx, openChannelRequest)
1606  	}
1607  	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.OpenChannelRequest) *lnclient.OpenChannelResponse); ok {
1608  		r0 = returnFunc(ctx, openChannelRequest)
1609  	} else {
1610  		if ret.Get(0) != nil {
1611  			r0 = ret.Get(0).(*lnclient.OpenChannelResponse)
1612  		}
1613  	}
1614  	if returnFunc, ok := ret.Get(1).(func(context.Context, *lnclient.OpenChannelRequest) error); ok {
1615  		r1 = returnFunc(ctx, openChannelRequest)
1616  	} else {
1617  		r1 = ret.Error(1)
1618  	}
1619  	return r0, r1
1620  }
1621  
1622  // MockLNClient_OpenChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenChannel'
1623  type MockLNClient_OpenChannel_Call struct {
1624  	*mock.Call
1625  }
1626  
1627  // OpenChannel is a helper method to define mock.On call
1628  //   - ctx context.Context
1629  //   - openChannelRequest *lnclient.OpenChannelRequest
1630  func (_e *MockLNClient_Expecter) OpenChannel(ctx interface{}, openChannelRequest interface{}) *MockLNClient_OpenChannel_Call {
1631  	return &MockLNClient_OpenChannel_Call{Call: _e.mock.On("OpenChannel", ctx, openChannelRequest)}
1632  }
1633  
1634  func (_c *MockLNClient_OpenChannel_Call) Run(run func(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest)) *MockLNClient_OpenChannel_Call {
1635  	_c.Call.Run(func(args mock.Arguments) {
1636  		var arg0 context.Context
1637  		if args[0] != nil {
1638  			arg0 = args[0].(context.Context)
1639  		}
1640  		var arg1 *lnclient.OpenChannelRequest
1641  		if args[1] != nil {
1642  			arg1 = args[1].(*lnclient.OpenChannelRequest)
1643  		}
1644  		run(
1645  			arg0,
1646  			arg1,
1647  		)
1648  	})
1649  	return _c
1650  }
1651  
1652  func (_c *MockLNClient_OpenChannel_Call) Return(openChannelResponse *lnclient.OpenChannelResponse, err error) *MockLNClient_OpenChannel_Call {
1653  	_c.Call.Return(openChannelResponse, err)
1654  	return _c
1655  }
1656  
1657  func (_c *MockLNClient_OpenChannel_Call) RunAndReturn(run func(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error)) *MockLNClient_OpenChannel_Call {
1658  	_c.Call.Return(run)
1659  	return _c
1660  }
1661  
1662  // RedeemOnchainFunds provides a mock function for the type MockLNClient
1663  func (_mock *MockLNClient) RedeemOnchainFunds(ctx context.Context, toAddress string, amountSat uint64, feeRate *uint64, sendAll bool) (string, error) {
1664  	ret := _mock.Called(ctx, toAddress, amountSat, feeRate, sendAll)
1665  
1666  	if len(ret) == 0 {
1667  		panic("no return value specified for RedeemOnchainFunds")
1668  	}
1669  
1670  	var r0 string
1671  	var r1 error
1672  	if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, *uint64, bool) (string, error)); ok {
1673  		return returnFunc(ctx, toAddress, amountSat, feeRate, sendAll)
1674  	}
1675  	if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, *uint64, bool) string); ok {
1676  		r0 = returnFunc(ctx, toAddress, amountSat, feeRate, sendAll)
1677  	} else {
1678  		r0 = ret.Get(0).(string)
1679  	}
1680  	if returnFunc, ok := ret.Get(1).(func(context.Context, string, uint64, *uint64, bool) error); ok {
1681  		r1 = returnFunc(ctx, toAddress, amountSat, feeRate, sendAll)
1682  	} else {
1683  		r1 = ret.Error(1)
1684  	}
1685  	return r0, r1
1686  }
1687  
1688  // MockLNClient_RedeemOnchainFunds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RedeemOnchainFunds'
1689  type MockLNClient_RedeemOnchainFunds_Call struct {
1690  	*mock.Call
1691  }
1692  
1693  // RedeemOnchainFunds is a helper method to define mock.On call
1694  //   - ctx context.Context
1695  //   - toAddress string
1696  //   - amountSat uint64
1697  //   - feeRate *uint64
1698  //   - sendAll bool
1699  func (_e *MockLNClient_Expecter) RedeemOnchainFunds(ctx interface{}, toAddress interface{}, amountSat interface{}, feeRate interface{}, sendAll interface{}) *MockLNClient_RedeemOnchainFunds_Call {
1700  	return &MockLNClient_RedeemOnchainFunds_Call{Call: _e.mock.On("RedeemOnchainFunds", ctx, toAddress, amountSat, feeRate, sendAll)}
1701  }
1702  
1703  func (_c *MockLNClient_RedeemOnchainFunds_Call) Run(run func(ctx context.Context, toAddress string, amountSat uint64, feeRate *uint64, sendAll bool)) *MockLNClient_RedeemOnchainFunds_Call {
1704  	_c.Call.Run(func(args mock.Arguments) {
1705  		var arg0 context.Context
1706  		if args[0] != nil {
1707  			arg0 = args[0].(context.Context)
1708  		}
1709  		var arg1 string
1710  		if args[1] != nil {
1711  			arg1 = args[1].(string)
1712  		}
1713  		var arg2 uint64
1714  		if args[2] != nil {
1715  			arg2 = args[2].(uint64)
1716  		}
1717  		var arg3 *uint64
1718  		if args[3] != nil {
1719  			arg3 = args[3].(*uint64)
1720  		}
1721  		var arg4 bool
1722  		if args[4] != nil {
1723  			arg4 = args[4].(bool)
1724  		}
1725  		run(
1726  			arg0,
1727  			arg1,
1728  			arg2,
1729  			arg3,
1730  			arg4,
1731  		)
1732  	})
1733  	return _c
1734  }
1735  
1736  func (_c *MockLNClient_RedeemOnchainFunds_Call) Return(txId string, err error) *MockLNClient_RedeemOnchainFunds_Call {
1737  	_c.Call.Return(txId, err)
1738  	return _c
1739  }
1740  
1741  func (_c *MockLNClient_RedeemOnchainFunds_Call) RunAndReturn(run func(ctx context.Context, toAddress string, amountSat uint64, feeRate *uint64, sendAll bool) (string, error)) *MockLNClient_RedeemOnchainFunds_Call {
1742  	_c.Call.Return(run)
1743  	return _c
1744  }
1745  
1746  // ResetRouter provides a mock function for the type MockLNClient
1747  func (_mock *MockLNClient) ResetRouter(key string) error {
1748  	ret := _mock.Called(key)
1749  
1750  	if len(ret) == 0 {
1751  		panic("no return value specified for ResetRouter")
1752  	}
1753  
1754  	var r0 error
1755  	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
1756  		r0 = returnFunc(key)
1757  	} else {
1758  		r0 = ret.Error(0)
1759  	}
1760  	return r0
1761  }
1762  
1763  // MockLNClient_ResetRouter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetRouter'
1764  type MockLNClient_ResetRouter_Call struct {
1765  	*mock.Call
1766  }
1767  
1768  // ResetRouter is a helper method to define mock.On call
1769  //   - key string
1770  func (_e *MockLNClient_Expecter) ResetRouter(key interface{}) *MockLNClient_ResetRouter_Call {
1771  	return &MockLNClient_ResetRouter_Call{Call: _e.mock.On("ResetRouter", key)}
1772  }
1773  
1774  func (_c *MockLNClient_ResetRouter_Call) Run(run func(key string)) *MockLNClient_ResetRouter_Call {
1775  	_c.Call.Run(func(args mock.Arguments) {
1776  		var arg0 string
1777  		if args[0] != nil {
1778  			arg0 = args[0].(string)
1779  		}
1780  		run(
1781  			arg0,
1782  		)
1783  	})
1784  	return _c
1785  }
1786  
1787  func (_c *MockLNClient_ResetRouter_Call) Return(err error) *MockLNClient_ResetRouter_Call {
1788  	_c.Call.Return(err)
1789  	return _c
1790  }
1791  
1792  func (_c *MockLNClient_ResetRouter_Call) RunAndReturn(run func(key string) error) *MockLNClient_ResetRouter_Call {
1793  	_c.Call.Return(run)
1794  	return _c
1795  }
1796  
1797  // SendKeysend provides a mock function for the type MockLNClient
1798  func (_mock *MockLNClient) SendKeysend(amountMsat uint64, destination string, customRecords []lnclient.TLVRecord, preimage string) (*lnclient.PayKeysendResponse, error) {
1799  	ret := _mock.Called(amountMsat, destination, customRecords, preimage)
1800  
1801  	if len(ret) == 0 {
1802  		panic("no return value specified for SendKeysend")
1803  	}
1804  
1805  	var r0 *lnclient.PayKeysendResponse
1806  	var r1 error
1807  	if returnFunc, ok := ret.Get(0).(func(uint64, string, []lnclient.TLVRecord, string) (*lnclient.PayKeysendResponse, error)); ok {
1808  		return returnFunc(amountMsat, destination, customRecords, preimage)
1809  	}
1810  	if returnFunc, ok := ret.Get(0).(func(uint64, string, []lnclient.TLVRecord, string) *lnclient.PayKeysendResponse); ok {
1811  		r0 = returnFunc(amountMsat, destination, customRecords, preimage)
1812  	} else {
1813  		if ret.Get(0) != nil {
1814  			r0 = ret.Get(0).(*lnclient.PayKeysendResponse)
1815  		}
1816  	}
1817  	if returnFunc, ok := ret.Get(1).(func(uint64, string, []lnclient.TLVRecord, string) error); ok {
1818  		r1 = returnFunc(amountMsat, destination, customRecords, preimage)
1819  	} else {
1820  		r1 = ret.Error(1)
1821  	}
1822  	return r0, r1
1823  }
1824  
1825  // MockLNClient_SendKeysend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendKeysend'
1826  type MockLNClient_SendKeysend_Call struct {
1827  	*mock.Call
1828  }
1829  
1830  // SendKeysend is a helper method to define mock.On call
1831  //   - amountMsat uint64
1832  //   - destination string
1833  //   - customRecords []lnclient.TLVRecord
1834  //   - preimage string
1835  func (_e *MockLNClient_Expecter) SendKeysend(amountMsat interface{}, destination interface{}, customRecords interface{}, preimage interface{}) *MockLNClient_SendKeysend_Call {
1836  	return &MockLNClient_SendKeysend_Call{Call: _e.mock.On("SendKeysend", amountMsat, destination, customRecords, preimage)}
1837  }
1838  
1839  func (_c *MockLNClient_SendKeysend_Call) Run(run func(amountMsat uint64, destination string, customRecords []lnclient.TLVRecord, preimage string)) *MockLNClient_SendKeysend_Call {
1840  	_c.Call.Run(func(args mock.Arguments) {
1841  		var arg0 uint64
1842  		if args[0] != nil {
1843  			arg0 = args[0].(uint64)
1844  		}
1845  		var arg1 string
1846  		if args[1] != nil {
1847  			arg1 = args[1].(string)
1848  		}
1849  		var arg2 []lnclient.TLVRecord
1850  		if args[2] != nil {
1851  			arg2 = args[2].([]lnclient.TLVRecord)
1852  		}
1853  		var arg3 string
1854  		if args[3] != nil {
1855  			arg3 = args[3].(string)
1856  		}
1857  		run(
1858  			arg0,
1859  			arg1,
1860  			arg2,
1861  			arg3,
1862  		)
1863  	})
1864  	return _c
1865  }
1866  
1867  func (_c *MockLNClient_SendKeysend_Call) Return(payKeysendResponse *lnclient.PayKeysendResponse, err error) *MockLNClient_SendKeysend_Call {
1868  	_c.Call.Return(payKeysendResponse, err)
1869  	return _c
1870  }
1871  
1872  func (_c *MockLNClient_SendKeysend_Call) RunAndReturn(run func(amountMsat uint64, destination string, customRecords []lnclient.TLVRecord, preimage string) (*lnclient.PayKeysendResponse, error)) *MockLNClient_SendKeysend_Call {
1873  	_c.Call.Return(run)
1874  	return _c
1875  }
1876  
1877  // SendPaymentSync provides a mock function for the type MockLNClient
1878  func (_mock *MockLNClient) SendPaymentSync(payReq string, amountMsat *uint64) (*lnclient.PayInvoiceResponse, error) {
1879  	ret := _mock.Called(payReq, amountMsat)
1880  
1881  	if len(ret) == 0 {
1882  		panic("no return value specified for SendPaymentSync")
1883  	}
1884  
1885  	var r0 *lnclient.PayInvoiceResponse
1886  	var r1 error
1887  	if returnFunc, ok := ret.Get(0).(func(string, *uint64) (*lnclient.PayInvoiceResponse, error)); ok {
1888  		return returnFunc(payReq, amountMsat)
1889  	}
1890  	if returnFunc, ok := ret.Get(0).(func(string, *uint64) *lnclient.PayInvoiceResponse); ok {
1891  		r0 = returnFunc(payReq, amountMsat)
1892  	} else {
1893  		if ret.Get(0) != nil {
1894  			r0 = ret.Get(0).(*lnclient.PayInvoiceResponse)
1895  		}
1896  	}
1897  	if returnFunc, ok := ret.Get(1).(func(string, *uint64) error); ok {
1898  		r1 = returnFunc(payReq, amountMsat)
1899  	} else {
1900  		r1 = ret.Error(1)
1901  	}
1902  	return r0, r1
1903  }
1904  
1905  // MockLNClient_SendPaymentSync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendPaymentSync'
1906  type MockLNClient_SendPaymentSync_Call struct {
1907  	*mock.Call
1908  }
1909  
1910  // SendPaymentSync is a helper method to define mock.On call
1911  //   - payReq string
1912  //   - amountMsat *uint64
1913  func (_e *MockLNClient_Expecter) SendPaymentSync(payReq interface{}, amountMsat interface{}) *MockLNClient_SendPaymentSync_Call {
1914  	return &MockLNClient_SendPaymentSync_Call{Call: _e.mock.On("SendPaymentSync", payReq, amountMsat)}
1915  }
1916  
1917  func (_c *MockLNClient_SendPaymentSync_Call) Run(run func(payReq string, amountMsat *uint64)) *MockLNClient_SendPaymentSync_Call {
1918  	_c.Call.Run(func(args mock.Arguments) {
1919  		var arg0 string
1920  		if args[0] != nil {
1921  			arg0 = args[0].(string)
1922  		}
1923  		var arg1 *uint64
1924  		if args[1] != nil {
1925  			arg1 = args[1].(*uint64)
1926  		}
1927  		run(
1928  			arg0,
1929  			arg1,
1930  		)
1931  	})
1932  	return _c
1933  }
1934  
1935  func (_c *MockLNClient_SendPaymentSync_Call) Return(payInvoiceResponse *lnclient.PayInvoiceResponse, err error) *MockLNClient_SendPaymentSync_Call {
1936  	_c.Call.Return(payInvoiceResponse, err)
1937  	return _c
1938  }
1939  
1940  func (_c *MockLNClient_SendPaymentSync_Call) RunAndReturn(run func(payReq string, amountMsat *uint64) (*lnclient.PayInvoiceResponse, error)) *MockLNClient_SendPaymentSync_Call {
1941  	_c.Call.Return(run)
1942  	return _c
1943  }
1944  
1945  // SettleHoldInvoice provides a mock function for the type MockLNClient
1946  func (_mock *MockLNClient) SettleHoldInvoice(ctx context.Context, preimage string) error {
1947  	ret := _mock.Called(ctx, preimage)
1948  
1949  	if len(ret) == 0 {
1950  		panic("no return value specified for SettleHoldInvoice")
1951  	}
1952  
1953  	var r0 error
1954  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1955  		r0 = returnFunc(ctx, preimage)
1956  	} else {
1957  		r0 = ret.Error(0)
1958  	}
1959  	return r0
1960  }
1961  
1962  // MockLNClient_SettleHoldInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SettleHoldInvoice'
1963  type MockLNClient_SettleHoldInvoice_Call struct {
1964  	*mock.Call
1965  }
1966  
1967  // SettleHoldInvoice is a helper method to define mock.On call
1968  //   - ctx context.Context
1969  //   - preimage string
1970  func (_e *MockLNClient_Expecter) SettleHoldInvoice(ctx interface{}, preimage interface{}) *MockLNClient_SettleHoldInvoice_Call {
1971  	return &MockLNClient_SettleHoldInvoice_Call{Call: _e.mock.On("SettleHoldInvoice", ctx, preimage)}
1972  }
1973  
1974  func (_c *MockLNClient_SettleHoldInvoice_Call) Run(run func(ctx context.Context, preimage string)) *MockLNClient_SettleHoldInvoice_Call {
1975  	_c.Call.Run(func(args mock.Arguments) {
1976  		var arg0 context.Context
1977  		if args[0] != nil {
1978  			arg0 = args[0].(context.Context)
1979  		}
1980  		var arg1 string
1981  		if args[1] != nil {
1982  			arg1 = args[1].(string)
1983  		}
1984  		run(
1985  			arg0,
1986  			arg1,
1987  		)
1988  	})
1989  	return _c
1990  }
1991  
1992  func (_c *MockLNClient_SettleHoldInvoice_Call) Return(err error) *MockLNClient_SettleHoldInvoice_Call {
1993  	_c.Call.Return(err)
1994  	return _c
1995  }
1996  
1997  func (_c *MockLNClient_SettleHoldInvoice_Call) RunAndReturn(run func(ctx context.Context, preimage string) error) *MockLNClient_SettleHoldInvoice_Call {
1998  	_c.Call.Return(run)
1999  	return _c
2000  }
2001  
2002  // Shutdown provides a mock function for the type MockLNClient
2003  func (_mock *MockLNClient) Shutdown() error {
2004  	ret := _mock.Called()
2005  
2006  	if len(ret) == 0 {
2007  		panic("no return value specified for Shutdown")
2008  	}
2009  
2010  	var r0 error
2011  	if returnFunc, ok := ret.Get(0).(func() error); ok {
2012  		r0 = returnFunc()
2013  	} else {
2014  		r0 = ret.Error(0)
2015  	}
2016  	return r0
2017  }
2018  
2019  // MockLNClient_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
2020  type MockLNClient_Shutdown_Call struct {
2021  	*mock.Call
2022  }
2023  
2024  // Shutdown is a helper method to define mock.On call
2025  func (_e *MockLNClient_Expecter) Shutdown() *MockLNClient_Shutdown_Call {
2026  	return &MockLNClient_Shutdown_Call{Call: _e.mock.On("Shutdown")}
2027  }
2028  
2029  func (_c *MockLNClient_Shutdown_Call) Run(run func()) *MockLNClient_Shutdown_Call {
2030  	_c.Call.Run(func(args mock.Arguments) {
2031  		run()
2032  	})
2033  	return _c
2034  }
2035  
2036  func (_c *MockLNClient_Shutdown_Call) Return(err error) *MockLNClient_Shutdown_Call {
2037  	_c.Call.Return(err)
2038  	return _c
2039  }
2040  
2041  func (_c *MockLNClient_Shutdown_Call) RunAndReturn(run func() error) *MockLNClient_Shutdown_Call {
2042  	_c.Call.Return(run)
2043  	return _c
2044  }
2045  
2046  // SignMessage provides a mock function for the type MockLNClient
2047  func (_mock *MockLNClient) SignMessage(ctx context.Context, message string) (string, error) {
2048  	ret := _mock.Called(ctx, message)
2049  
2050  	if len(ret) == 0 {
2051  		panic("no return value specified for SignMessage")
2052  	}
2053  
2054  	var r0 string
2055  	var r1 error
2056  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
2057  		return returnFunc(ctx, message)
2058  	}
2059  	if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
2060  		r0 = returnFunc(ctx, message)
2061  	} else {
2062  		r0 = ret.Get(0).(string)
2063  	}
2064  	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2065  		r1 = returnFunc(ctx, message)
2066  	} else {
2067  		r1 = ret.Error(1)
2068  	}
2069  	return r0, r1
2070  }
2071  
2072  // MockLNClient_SignMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignMessage'
2073  type MockLNClient_SignMessage_Call struct {
2074  	*mock.Call
2075  }
2076  
2077  // SignMessage is a helper method to define mock.On call
2078  //   - ctx context.Context
2079  //   - message string
2080  func (_e *MockLNClient_Expecter) SignMessage(ctx interface{}, message interface{}) *MockLNClient_SignMessage_Call {
2081  	return &MockLNClient_SignMessage_Call{Call: _e.mock.On("SignMessage", ctx, message)}
2082  }
2083  
2084  func (_c *MockLNClient_SignMessage_Call) Run(run func(ctx context.Context, message string)) *MockLNClient_SignMessage_Call {
2085  	_c.Call.Run(func(args mock.Arguments) {
2086  		var arg0 context.Context
2087  		if args[0] != nil {
2088  			arg0 = args[0].(context.Context)
2089  		}
2090  		var arg1 string
2091  		if args[1] != nil {
2092  			arg1 = args[1].(string)
2093  		}
2094  		run(
2095  			arg0,
2096  			arg1,
2097  		)
2098  	})
2099  	return _c
2100  }
2101  
2102  func (_c *MockLNClient_SignMessage_Call) Return(s string, err error) *MockLNClient_SignMessage_Call {
2103  	_c.Call.Return(s, err)
2104  	return _c
2105  }
2106  
2107  func (_c *MockLNClient_SignMessage_Call) RunAndReturn(run func(ctx context.Context, message string) (string, error)) *MockLNClient_SignMessage_Call {
2108  	_c.Call.Return(run)
2109  	return _c
2110  }
2111  
2112  // UpdateChannel provides a mock function for the type MockLNClient
2113  func (_mock *MockLNClient) UpdateChannel(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest) error {
2114  	ret := _mock.Called(ctx, updateChannelRequest)
2115  
2116  	if len(ret) == 0 {
2117  		panic("no return value specified for UpdateChannel")
2118  	}
2119  
2120  	var r0 error
2121  	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.UpdateChannelRequest) error); ok {
2122  		r0 = returnFunc(ctx, updateChannelRequest)
2123  	} else {
2124  		r0 = ret.Error(0)
2125  	}
2126  	return r0
2127  }
2128  
2129  // MockLNClient_UpdateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannel'
2130  type MockLNClient_UpdateChannel_Call struct {
2131  	*mock.Call
2132  }
2133  
2134  // UpdateChannel is a helper method to define mock.On call
2135  //   - ctx context.Context
2136  //   - updateChannelRequest *lnclient.UpdateChannelRequest
2137  func (_e *MockLNClient_Expecter) UpdateChannel(ctx interface{}, updateChannelRequest interface{}) *MockLNClient_UpdateChannel_Call {
2138  	return &MockLNClient_UpdateChannel_Call{Call: _e.mock.On("UpdateChannel", ctx, updateChannelRequest)}
2139  }
2140  
2141  func (_c *MockLNClient_UpdateChannel_Call) Run(run func(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest)) *MockLNClient_UpdateChannel_Call {
2142  	_c.Call.Run(func(args mock.Arguments) {
2143  		var arg0 context.Context
2144  		if args[0] != nil {
2145  			arg0 = args[0].(context.Context)
2146  		}
2147  		var arg1 *lnclient.UpdateChannelRequest
2148  		if args[1] != nil {
2149  			arg1 = args[1].(*lnclient.UpdateChannelRequest)
2150  		}
2151  		run(
2152  			arg0,
2153  			arg1,
2154  		)
2155  	})
2156  	return _c
2157  }
2158  
2159  func (_c *MockLNClient_UpdateChannel_Call) Return(err error) *MockLNClient_UpdateChannel_Call {
2160  	_c.Call.Return(err)
2161  	return _c
2162  }
2163  
2164  func (_c *MockLNClient_UpdateChannel_Call) RunAndReturn(run func(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest) error) *MockLNClient_UpdateChannel_Call {
2165  	_c.Call.Return(run)
2166  	return _c
2167  }
2168  
2169  // UpdateLastWalletSyncRequest provides a mock function for the type MockLNClient
2170  func (_mock *MockLNClient) UpdateLastWalletSyncRequest() {
2171  	_mock.Called()
2172  	return
2173  }
2174  
2175  // MockLNClient_UpdateLastWalletSyncRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLastWalletSyncRequest'
2176  type MockLNClient_UpdateLastWalletSyncRequest_Call struct {
2177  	*mock.Call
2178  }
2179  
2180  // UpdateLastWalletSyncRequest is a helper method to define mock.On call
2181  func (_e *MockLNClient_Expecter) UpdateLastWalletSyncRequest() *MockLNClient_UpdateLastWalletSyncRequest_Call {
2182  	return &MockLNClient_UpdateLastWalletSyncRequest_Call{Call: _e.mock.On("UpdateLastWalletSyncRequest")}
2183  }
2184  
2185  func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) Run(run func()) *MockLNClient_UpdateLastWalletSyncRequest_Call {
2186  	_c.Call.Run(func(args mock.Arguments) {
2187  		run()
2188  	})
2189  	return _c
2190  }
2191  
2192  func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) Return() *MockLNClient_UpdateLastWalletSyncRequest_Call {
2193  	_c.Call.Return()
2194  	return _c
2195  }
2196  
2197  func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) RunAndReturn(run func()) *MockLNClient_UpdateLastWalletSyncRequest_Call {
2198  	_c.Run(run)
2199  	return _c
2200  }
2201