storage

type AddUpdate struct {
	SessionID int64 `tl:"long"`
	Seqno     int64 `tl:"int"`
	Update    any   `tl:"struct boxed [storage.updateInit,storage.updateHavePieces,storage.updateState]"`
}

type Connector struct {
	TorrentServer
	// contains filtered or unexported fields
}

type DHT interface {
	StoreAddress(ctx context.Context, addresses address.List, ttl time.Duration, ownerKey ed25519.PrivateKey, copies int) (int, []byte, error)
	FindAddresses(ctx context.Context, key []byte) (*address.List, ed25519.PublicKey, error)
	FindOverlayNodes(ctx context.Context, overlayId []byte, continuation ...*dht.Continuation) (*overlay.NodesList, *dht.Continuation, error)
	Close()
}

type DownloadResult struct {
	Path        string
	Dir         string
	Description string
}

type Event struct {
	Name  string
	Value any
}

type FECInfoNone struct{}

type FS interface {
	Open(name string, mode OpenMode) (FSFile, error)
	Delete(name string) error
	Exists(name string) bool
	GetController() FSController
}

type FSController interface {
	AcquireRead(path string, p []byte, off int64) (n int, err error)
	RemoveFile(path string) error
}

type FSFile interface {
	io.ReaderAt
	io.WriterAt
	io.Closer
	Sync() error
}

type FileIndex struct {
	BlockFrom       uint32
	BlockTo         uint32
	BlockFromOffset uint32
	BlockToOffset   uint32
	Name            string
	// contains filtered or unexported fields
}

type FileInfo struct {
	Size            uint64
	FromPiece       uint32
	ToPiece         uint32
	FromPieceOffset uint32
	ToPieceOffset   uint32
	Index           uint32
	Name            string
}

type FileRef interface {
	GetName() string
	GetSize() uint64
	CreateReader() (io.ReaderAt, func() error, error)
}

type GetPiece struct {
	PieceID int32 `tl:"int"`
}

type GetTorrentInfo struct{}

type KnownNode struct {
	Node       atomic.Pointer[overlay.Node]
	FailStreak atomic.Uint32
	InProgress atomic.Bool

	TriedAt time.Time
}

type NetConnector interface {
	GetID() []byte
	GetADNLPrivateKey() ed25519.PrivateKey
	SetDownloadLimit(bytesPerSec uint64)
	SetUploadLimit(bytesPerSec uint64)
	GetUploadLimit() uint64
	GetDownloadLimit() uint64
	ThrottleDownload(ctx context.Context, sz uint64) error
	ThrottleUpload(ctx context.Context, sz uint64) error
	CreateDownloader(ctx context.Context, t *Torrent) (_ TorrentDownloader, err error)
	ConnectToNode(ctx context.Context, t *Torrent, node *overlay.Node, addrList *address.List) error
	TorrentServer
}

type Ok struct{}

type OpenMode int

type PeerConnection struct {
	InflightPieces    atomic.Int32
	MaxInflightPieces atomic.Int32

	StableCount   atomic.Int64
	UnstableCount atomic.Int64
	IsLastSuccess atomic.Bool
	LastChange    atomic.Int64
	UpStreak      atomic.Int64
	DownStreak    atomic.Int64
	// contains filtered or unexported fields
}

type PeerInfo struct {
	Addr       string
	Uploaded   uint64
	Downloaded uint64
	// contains filtered or unexported fields
}

type Piece struct {
	Proof []byte `tl:"bytes"`
	Data  []byte `tl:"bytes"`
}

type PieceInfo struct {
	StartFileIndex uint32
	Proof          []byte
}

type PiecesInfo struct {
	OverallPieces    int
	PiecesToDownload int
}

type Ping struct {
	SessionID int64 `tl:"long"`
}

type Pong struct{}

type PreFetcher struct {
	// contains filtered or unexported fields
}

type Progress struct {
	Downloaded string
	Speed      string
}

type Server struct {
	// contains filtered or unexported fields
}

type SpeedLimit struct {
	// contains filtered or unexported fields
}

type State struct {
	WillUpload   bool `tl:"bool"`
	WantDownload bool `tl:"bool"`
}

type Storage interface {
	GetFS() FS
	GetAll() []*Torrent
	GetTorrentByOverlay(overlay []byte) *Torrent
	SetTorrent(torrent *Torrent) error
	SetActiveFiles(bagId []byte, ids []uint32) error
	GetActiveFiles(bagId []byte) ([]uint32, error)
	GetPiece(bagId []byte, id uint32) (*PieceInfo, error)
	RemovePiece(bagId []byte, id uint32) error
	SetPiece(bagId []byte, id uint32, p *PieceInfo) error
	PiecesMask(bagId []byte, num uint32) []byte
	UpdateUploadStats(bagId []byte, val uint64) error
	VerifyOnStartup() bool
	GetForcedPieceSize() uint32
}

type Torrent struct {
	BagID          []byte
	Path           string
	Info           *TorrentInfo
	Header         *TorrentHeader
	CreatedAt      time.Time
	CreatedLocally bool
	// contains filtered or unexported fields
}

type TorrentDownloader interface {
	Close()
	IsActive() bool
}

type TorrentHeader struct {
	FilesCount    uint32
	TotalNameSize uint64
	TotalDataSize uint64
	FEC           FECInfoNone
	DirNameSize   uint32
	DirName       []byte
	NameIndex     []uint64
	DataIndex     []uint64
	Names         []byte
	Data          []byte
}

type TorrentInfo struct {
	PieceSize   uint32   `tlb:"## 32"`
	FileSize    uint64   `tlb:"## 64"`
	RootHash    []byte   `tlb:"bits 256"`
	HeaderSize  uint64   `tlb:"## 64"`
	HeaderHash  []byte   `tlb:"bits 256"`
	Description tlb.Text `tlb:"."`
}

type TorrentInfoContainer struct {
	Data []byte `tl:"bytes"`
}

type TorrentServer interface {
	ConnectToNode(ctx context.Context, t *Torrent, node *overlay.Node, addrs *address.List) error
	GetADNLPrivateKey() ed25519.PrivateKey
	GetID() []byte
	Stop()
}

type TorrentStats struct {
	Uploaded uint64
}

type UpdateHavePieces struct {
	PieceIDs []int32 `tl:"vector int"`
}

type UpdateInit struct {
	HavePieces       []byte `tl:"bytes"`
	HavePiecesOffset int32  `tl:"int"`
	State            State  `tl:"struct boxed"`
}

type UpdateState struct {
	State State `tl:"struct boxed"`
}