Pinata の SDK を使って IPFS を操作する

mkdir hello-pinata-sdk
cd hello-pinata-sdk
npm init -y
npm install --save-dev @pinata/sdk dotenv @types/node ts-node
touch .env test-authentication.ts

PINATA_API_KEY="00000000000000000000"
PINATA_API_SECRET="0000000000000000000000000000000000000000000000000000000000000000"
PINATA_JWT="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const { authenticated } = await pinata.testAuthentication();

  console.log(JSON.stringify({ authenticated }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config test-authentication.ts

{
  "authenticated": true
}

touch pin-file.ts

import PinataClient from "@pinata/sdk";
import { Readable } from "stream";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const dataToPin = Readable.from('Hello, Pinata');
  const pinResponse = await pinata.pinFileToIPFS(dataToPin, {
    pinataMetadata: {
      name: "myFirstPinnedData",
      keyvalues: {
        myKey: 'myValue',
      } as any,
    },
  })

  console.log(JSON.stringify({ pinResponse }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config pin-file.ts

{
  "pinResponse": {
    "IpfsHash": "QmeTv51GpP6cMF3KoAPDYTrEqB9NUvqHygafgM3bNM9Row",
    "PinSize": 21,
    "Timestamp": "2023-01-19T07:52:55.793Z"
  }
}

mkdir directory-to-pin
echo 'Hello, pinFromFS!' > directory-to-pin/message.txt
touch pin-directory.ts

import PinataClient, { PinataMetadataFilter } from "@pinata/sdk";
import { join } from "path";
import { cwd } from "process";

async function main() {
  const pinata = new PinataClient({
    pinataJWTKey: process.env.PINATA_JWT!,
  });

  const directoryToPin = join(cwd(), "directory-to-pin");
  const pinResponse = await pinata.pinFromFS(directoryToPin, {
    pinataMetadata: {
      name: "myFirstPinnedDirectory",
      keyvalues: {
        customKey: "customValue",
      } as any,
    },
  });

  console.log(JSON.stringify({ pinResponse }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config pin-directory.ts

{
  "pinResponse": {
    "IpfsHash": "QmZn26VASeHsaE8KUxd1dZWp2QUF9t3oL5oii5AdWbzs8V",
    "PinSize": 83,
    "Timestamp": "2023-01-20T00:34:51.184Z"
  }
}

  const pinResponse = await pinata.pinFromFS(directoryToPin, {
    pinataMetadata: {
      name: "myFirstPinnedDirectory",
      keyvalues: {
        customKey: "customValue",
      } as any,
    },
  });

export interface PinataMetadata {
    [key: string]: string | number | null;
}

export interface PinataMetadataFilter {
    name?: string | undefined;
    keyvalues: {
        [key: string]: {
            value: string | number | null;
            op: string;
        };
    };
}

{
  "pinResponse": {
    "IpfsHash": "QmZn26VASeHsaE8KUxd1dZWp2QUF9t3oL5oii5AdWbzs8V",
    "PinSize": 83,
    "Timestamp": "2023-01-20T00:34:51.184Z",
    "isDuplicate": true
  }
}

    pinataMetadata: {
      name: "myFirstPinnedData2",
      keyvalues: {
        myKey: 'myValue',
      } as any,
    },

{
  "pinResponse": {
    "IpfsHash": "QmZn26VASeHsaE8KUxd1dZWp2QUF9t3oL5oii5AdWbzs8V",
    "PinSize": 83,
    "Timestamp": "2023-01-20T00:34:51.184Z",
    "isDuplicate": true
  }
}

touch change-metadata.ts

import "@pinata/sdk";
import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const ipfsPinHash = "QmeTv51GpP6cMF3KoAPDYTrEqB9NUvqHygafgM3bNM9Row";
  const changeMetadataResponse = await pinata.hashMetadata(ipfsPinHash, {
    name: "myFirstPinnedData2",
    keyvalues: {
      customKey: null,
      customKey2: "customValue2",
    } as any,
  });

  console.log(JSON.stringify({ changeMetadataResponse }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config change-metadata.ts

{
  "changeMetadataResponse": "OK"
}

touch pin-by-hash.ts

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const ipfsHashToPin = 'QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq';
  const pinResponse = await pinata.pinByHash(ipfsHashToPin, {
    pinataMetadata: {
      name: "pinnedByHash",
    },
  })

  console.log(JSON.stringify({ pinResponse }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config pin-by-hash.ts

{
  "pinResponse": {
    "id": "84fe30c6-20e8-4cb8-8cef-e90a0d752ffe",
    "ipfsHash": "QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq",
    "status": "prechecking",
    "name": "pinnedByHash"
  }
}

touch list-pin-jobs.ts

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const pinJobs = await pinata.pinJobs();

  console.log(JSON.stringify({ pinJobs }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config list-pin-jobs.ts

{
  "pinJobs": {
    "count": 0,
    "rows": []
  }
}

{
  reason: 'FORBIDDEN',
  details: 'Account blocked due to plan usage limit'
}

touch unpin.ts

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const ipfsHashToUnpin = 'QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq';
  const unpinResponse = await pinata.unpin(ipfsHashToUnpin)

  console.log(JSON.stringify({ unpinResponse }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config unpin.ts

{
  "unpinResponse": "OK"
}

touch pin-json.ts

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const jsonToPin = {
    message: "Hello, pinJSONToIPFS!",
  };

  const pinResponse = await pinata.pinJSONToIPFS(jsonToPin, {
    pinataMetadata: {
      name: "myFirstPinnedJSON",
    },
  });

  console.log(JSON.stringify({ pinResponse }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config pin-json.ts

{
  "pinResponse": {
    "IpfsHash": "QmZEYZ9fDkJDqmEteeYRdcRGgUrHv2ytxpsp4QTPEcSuNF",
    "PinSize": 43,
    "Timestamp": "2023-01-23T01:43:25.281Z"
  }
}

touch list-pins.ts

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const listResponse = await pinata.pinList({
    pageLimit: 1,
  });

  console.log(JSON.stringify({ listResponse }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config list-pins.ts

{
  "listResponse": {
    "rows": [
      {
        "id": "1534de97-6d08-4356-a0bd-43c419b12419",
        "ipfs_pin_hash": "QmZEYZ9fDkJDqmEteeYRdcRGgUrHv2ytxpsp4QTPEcSuNF",
        "size": 43,
        "user_id": "ca1b5bfe-5679-4190-95ee-37786427ddf8",
        "date_pinned": "2023-01-23T01:43:25.281Z",
        "date_unpinned": null,
        "metadata": {
          "name": "myFirstPinnedJSON",
          "keyvalues": null
        },
        "regions": [
          {
            "regionId": "FRA1",
            "currentReplicationCount": 1,
            "desiredReplicationCount": 1
          },
          {
            "regionId": "NYC1",
            "currentReplicationCount": 1,
            "desiredReplicationCount": 1
          }
        ]
      }
    ]
  }
}

touch iterate-files.ts

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const getFilesIterator = pinata.getFilesByCount({
    status: "all",
  });

  for await (const getFileResponse of getFilesIterator) {
    console.log(JSON.stringify({ getResponse: getFileResponse }, null, 2));
  }
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config iterate-files.ts

(何も表示されない)

touch get-total-bytes.ts

import PinataClient from "@pinata/sdk";

async function main() {
  const pinata = new PinataClient({
    pinataApiKey: process.env.PINATA_API_KEY!,
    pinataSecretApiKey: process.env.PINATA_API_SECRET!,
  });

  const totalBytes = await pinata.userPinnedDataTotal();

  console.log(JSON.stringify({ totalBytes }, null, 2));
}

main().catch((err) => console.error(err));

npx ts-node -r dotenv/config get-total-bytes.ts

{
  "totalBytes": {
    "pin_count": 8,
    "pin_size_total": 926752,
    "pin_size_with_replications_total": 926752
  }
}

$ npm install --save-dev pinata-upload-cli
$ npx pinata-cli --help
Usage: pinata-cli [options]

A command line tool to upload files and folders to Pinata

Options:
  -V, --version                     output the version number
  -a, --auth [jwt]                  API jwt from Pinata
  -as --authSubmarine [api key]     V2 API Key from Pinata
  -u, --upload [file or folder]     Source folder or file to upload to IPFS
  -s, --submarine [file or folder]  Source folder or file to submarine on
                                    Pinata
  -h, --help                        display help for command
$ source .env && npx pinata-cli --auth $PINATA_JWT
Authenticated
$ npx pinata-cli --upload pin-file.ts
{ percent: 0, transferred: 0, total: 802 }
{ percent: 0.1882793017456359, transferred: 151, total: 802 }
{ percent: 0.9276807980049875, transferred: 744, total: 802 }
{ percent: 1, transferred: 802, total: 802 }
Pinning, please wait...
{
  IpfsHash: 'QmbEn3gdkj8HRBiC7o8iZFYBPhrEaWS152LRrh3mRKg22n',
  PinSize: 604,
  Timestamp: '2023-01-24T01:04:42.165Z'
}