pinner

README

ipfs-pinner

ipfs-pinner is a toolkit to help upload files or specific content id to IPFS pinning services.

Supported Golang version: See .github/workflows/testing.yml

Installation

Via Golang package get command

go get -u github.com/wabarc/ipfs-pinner/cmd/ipfs-pinner

Using Snapcraft (on GNU/Linux)

snap install ipfs-pinner

Usage

Supported Pinning Services

Infura

Infura is a freemium pinning service that doesn't require any additional setup. It's the default one used. Please bear in mind that Infura is a free service, so there is probably a rate-limiting.

How to enable

Command-line:

Use flag -p infura.

$ ipfs-pinner
A CLI tool for pin files to IPFS.

Usage:

  ipfs-pinner [options] [file1] ... [fileN]

  -p string
       IPFS pinner, supports pinners: infura, pinata. (default "infura")

Go package:

import (
        "fmt"

        "github.com/wabarc/ipfs-pinner/pkg/infura"
)

func main() {
        cid, err := infura.PinFile("file-to-path");
        if err != nil {
                fmt.Sprintln(err)
                return
        }
        fmt.Println(cid)
}

or requests with project authentication

import (
        "fmt"

        "github.com/wabarc/ipfs-pinner/pkg/infura"
)

func main() {
        inf := &infura.Infura{ProjectID: "your-project-id", ProjectSecret: "your-project-secret"}
        cid, err := inf.PinFile("file-to-path");
        if err != nil {
                fmt.Sprintln(err)
                return
        }
        fmt.Println(cid)
}

Pinata

Pinata is another freemium pinning service. It gives you more control over what's uploaded. You can delete, label and add custom metadata. This service requires signup.

Environment variables

Unix*:

IPFS_PINNER_PINATA_API_KEY=<api key>
IPFS_PINNER_PINATA_SECRET_API_KEY=<secret api key>

Windows:

set IPFS_PINNER_PINATA_API_KEY=<api key>
set IPFS_PINNER_PINATA_SECRET_API_KEY=<secret api key>

How to enable

Command-line:

Use flag -p pinata.

ipfs-pinner -p pinata file-to-path

Go package:

import (
        "fmt"

        "github.com/wabarc/ipfs-pinner/pkg/pinata"
)

func main() {
        pnt := pinata.Pinata{Apikey: "your api key", Secret: "your secret key"}
        cid, err := pnt.PinFile("file-to-path");
        if err != nil {
                fmt.Sprintln(err)
                return
        }
        fmt.Println(cid)
}

NFT.Storage

NFT.Storage is a long-term storage service designed for off-chain NFT data (like metadata, images, and other assets) for up to 31GiB in size. Data is content addressed using IPFS, meaning the URL pointing to a piece of data (“ipfs://…”) is completely unique to that data.

How to enable

Command-line:

Use flag -p nftstorage.

ipfs-pinner -p nftstorage file-to-path

Go package:

import (
        "fmt"

        "github.com/wabarc/ipfs-pinner/pkg/nftstorage"
)

func main() {
        nft := nftstorage.NFTStorage{Apikey: "your api key"}
        cid, err := nft.PinFile("file-to-path");
        if err != nil {
                fmt.Sprintln(err)
                return
        }
        fmt.Println(cid)
}

Web3.Storage

Web3.Storage is a service to make building on top of Filecoin as simple as possible - giving the developers the power of open, distributed networks via a friendly JS client library. Behind the scenes, Web3.Storage is backed by Filecoin and makes content available via IPFS leveraging the unique properties of each network.

How to enable

Command-line:

Use flag -p web3storage.

ipfs-pinner -p web3storage file-to-path

Go package:

import (
        "fmt"

        "github.com/wabarc/ipfs-pinner/pkg/web3storage"
)

func main() {
        web3 := web3storage.Web3Storage{Apikey: "your api key"}
        cid, err := web3.PinFile("file-to-path");
        if err != nil {
                fmt.Sprintln(err)
                return
        }
        fmt.Println(cid)
}

License

Permissive GPL 3.0 license, see the LICENSE file for details.

Documentation

Index

• type Config
  • func (cfg *Config) Pin(file interface{}) (cid string, err error)

Types

type Config

type Config struct {
	Pinner string
	Apikey string
	Secret string
}

Config represents pinner's configuration. Pinner is the identifier of the target IPFS service.

func (*Config) Pin

func (cfg *Config) Pin(file interface{}) (cid string, err error)

Pin pins a file to a network and returns a content id and an error. The file is an interface to access the file. It's contents may be either stored in memory or on disk. If stored on disk, it's underlying concrete type should be a file path. If it is in memory, it should be an *io.Reader or byte slice.