Merge pull request #12 from metaplex-foundation/feat/new-methods

Adding new methods

Author: MarkSackerberg

README.md

@@ -7,7 +7,7 @@
     "scripts": {
         "build": "rimraf dist && tsc -p tsconfig.json",
         "build:docs": "typedoc",
-        "test": "ava",
+        "test": "ava -s",
         "lint": "eslint --ext js,ts,tsx src",
         "lint:fix": "eslint --fix --ext js,ts,tsx src",
         "format": "prettier --check src test",
@@ -76,4 +76,4 @@
             "path-to-regexp@>=4.0.0 <6.3.0": ">=6.3.0"
         }
     }
-}
+}

clients/js/package.json

@@ -9,6 +9,9 @@ import {
   DasApiAsset,
   DasApiAssetList,
   SearchAssetsRpcInput,
+  GetAssetSignaturesRpcResponse,
+  GetAssetProofsRpcResponse,
+  GetAssetSignaturesRpcInput,
 } from './types';
 
 export interface DasApiInterface {
@@ -19,13 +22,27 @@ export interface DasApiInterface {
    */
   getAsset(assetId: PublicKey): Promise<DasApiAsset>;
 
+  /**
+   * Return the metadata information of multiple compressed/standard assets.
+   *
+   * @param assetIds Array of the ids of the assets to fetch
+   */
+  getAssets(assetIds: PublicKey[]): Promise<DasApiAsset[]>;
+
   /**
    * Return the merkle tree proof information for a compressed asset.
    *
    * @param assetId the id of the asset to fetch the proof for
    */
   getAssetProof(assetId: PublicKey): Promise<GetAssetProofRpcResponse>;
 
+  /**
+   * Return the merkle tree proof information for multiple compressed assets.
+   *
+   * @param assetIds array of the ids of the assets to fetch the proofs for
+   */
+  getAssetProofs(assetIds: PublicKey[]): Promise<GetAssetProofsRpcResponse>;
+
   /**
    * Return the list of assets given an authority address.
    *
@@ -64,6 +81,15 @@ export interface DasApiInterface {
    * @param input the input parameters for the RPC call
    */
   searchAssets(input: SearchAssetsRpcInput): Promise<DasApiAssetList>;
+
+  /**
+   * Return the transaction signatures for a compressed asset
+   *
+   * @param input the input parameters for the RPC call
+   */
+  getAssetSignatures(
+    input: GetAssetSignaturesRpcInput
+  ): Promise<GetAssetSignaturesRpcResponse>;
 }
 
 export const createDasApiDecorator = (
@@ -75,6 +101,13 @@ export const createDasApiDecorator = (
     if (!asset) throw new DasApiError(`Asset not found: ${assetId}`);
     return asset;
   },
+  getAssets: async (assetIds: PublicKey[]) => {
+    const assets = await rpc.call<DasApiAsset[] | null>('getAssets', [
+      assetIds,
+    ]);
+    if (!assets) throw new DasApiError(`No assets found: ${assetIds}`);
+    return assets;
+  },
   getAssetProof: async (assetId: PublicKey) => {
     const proof = await rpc.call<GetAssetProofRpcResponse | null>(
       'getAssetProof',
@@ -83,6 +116,15 @@ export const createDasApiDecorator = (
     if (!proof) throw new DasApiError(`No proof found for asset: ${assetId}`);
     return proof;
   },
+  getAssetProofs: async (assetIds: PublicKey[]) => {
+    const proofs = await rpc.call<GetAssetProofsRpcResponse | null>(
+      'getAssetProofs',
+      [assetIds]
+    );
+    if (!proofs)
+      throw new DasApiError(`No proofs found for assets: ${assetIds}`);
+    return proofs;
+  },
   getAssetsByAuthority: async (input: GetAssetsByAuthorityRpcInput) => {
     if (typeof input.page === 'number' && (input.before || input.after)) {
       throw new DasApiError(
@@ -215,4 +257,28 @@ export const createDasApiDecorator = (
     }
     return assetList;
   },
+  getAssetSignatures: async (input: GetAssetSignaturesRpcInput) => {
+    const signatures = await rpc.call<GetAssetSignaturesRpcResponse | null>(
+      'getAssetSignaturesV2',
+      [
+        'assetId' in input ? input.assetId : null,
+        input.limit ?? null,
+        input.page ?? null,
+        input.before ?? null,
+        input.after ?? null,
+        'tree' in input ? input.tree : null,
+        'tree' in input ? input.leaf_index : null,
+        input.cursor ?? null,
+        input.sort_direction ?? null,
+      ]
+    );
+    if (!signatures) {
+      const identifier =
+        'assetId' in input
+          ? `asset: ${input.assetId}`
+          : `tree: ${input.tree}, leaf_index: ${input.leaf_index}`;
+      throw new DasApiError(`No signatures found for ${identifier}`);
+    }
+    return signatures;
+  },
 });

clients/js/src/decorator.ts

@@ -327,7 +327,7 @@ type Pagination = {
  * Sorting criteria.
  */
 type DasApiParamAssetSortBy = {
-  sortBy: 'created' | 'updated' | 'recent_action' | 'none';
+  sortBy: 'created' | 'updated' | 'recent_action' | 'id' | 'none';
   sortDirection: 'asc' | 'desc';
 };
 
@@ -441,3 +441,93 @@ export type GetAssetProofRpcResponse = {
   leaf: PublicKey;
   tree_id: PublicKey;
 };
+
+export type GetAssetProofsRpcResponse = Record<
+  PublicKey,
+  GetAssetProofRpcResponse
+>;
+
+export type GetAssetSignaturesRpcInput = {
+  /**
+   * The maximum number of assets to retrieve.
+   */
+  limit?: Nullable<number>;
+
+  /**
+   * The page number of the signatures.
+   */
+  page?: Nullable<number>;
+
+  /**
+   * Retrieve signatures before the specified `ID` value.
+   */
+  before?: Nullable<string>;
+
+  /**
+   * Retrieve signatures after the specified `ID` value.
+   */
+  after?: Nullable<string>;
+
+  /**
+   *
+   */
+  cursor?: Nullable<string>;
+
+  /**
+   * The sort direction.
+   */
+  sort_direction?: Nullable<'asc' | 'desc'>;
+} & (
+  | {
+      /**
+       * The Asset ID to retrieve signatures for.
+       */
+      assetId: PublicKey;
+      tree?: never;
+      leaf_index?: never;
+    }
+  | {
+      /**
+       * The tree ID to retrieve signatures for.
+       */
+      tree: PublicKey;
+      /**
+       * The leaf index to retrieve signatures for.
+       */
+      leaf_index: number;
+      assetId?: never;
+    }
+);
+
+export type DasApiTransactionSignature = {
+  signature: string;
+  instruction: string;
+  slot: number;
+};
+
+export type GetAssetSignaturesRpcResponse = {
+  /**
+   * total number of signatures in the list.
+   */
+  total: number;
+
+  /**
+   * Limit of signatures used to create the list. When the `total` value is
+   * lower than the `limit`, it means that there are no more signatures to be
+   * retrieved.
+   */
+  limit: number;
+
+  before: string;
+  after: string;
+
+  /**
+   * The page number of the signatures.
+   */
+  page?: number;
+
+  /**
+   * List of individual signatures.
+   */
+  items: DasApiTransactionSignature[];
+};

clients/js/src/types.ts

@@ -1,53 +1,54 @@
 import { publicKey } from '@metaplex-foundation/umi';
 import test from 'ava';
-import { DasApiAsset } from '../src';
+import {
+  DasApiAsset,
+  DasApiAssetCompression,
+  DasApiAssetContent,
+} from '../src';
 import { DAS_API_ENDPOINTS, createUmi } from './_setup';
 
 DAS_API_ENDPOINTS.forEach((endpoint) => {
   test(`it can fetch a compressed asset by ID (${endpoint.name})`, async (t) => {
     // Given a minted NFT.
     const umi = createUmi(endpoint.url);
-    const assetId = publicKey('8TrvJBRa6Pzb9BDadqroHhWTHxaxK8Ws8r91oZ2jxaVV');
+    const assetId = publicKey('GGRbPQhwmo3dXBkJSAjMFc1QYTKGBt8qc11tTp3LkEKA');
 
     // When we fetch the asset using its ID.
     const asset = await umi.rpc.getAsset(assetId);
 
     // Then we expect the following data.
-    t.like(asset, <DasApiAsset>{
-      interface: 'V1_NFT',
-      id: assetId,
-      content: {
-        json_uri:
-          'https://arweave.net/c9aGs5fOk7gD4wWnSvmzeqgtfxAGRgtI1jYzvl8-IVs/chiaki-violet-azure-common.json',
-        metadata: {
-          name: 'Chiaki Azure 55',
-        },
+    t.deepEqual(asset.interface, 'V1_NFT');
+    t.deepEqual(asset.id, assetId);
+    t.like(asset.content, <DasApiAssetContent>{
+      json_uri:
+        'https://arweave.net/c9aGs5fOk7gD4wWnSvmzeqgtfxAGRgtI1jYzvl8-IVs/chiaki-violet-azure-common.json',
+      metadata: {
+        name: 'Chiaki Azure 55',
       },
-      compression: {
-        eligible: false,
-        compressed: true,
-        data_hash: '3daLaunnCdbLtYR4Gas4xFnKLVezdMNqgjZEXtzhWqFA',
-        creator_hash: 'DJ7kGgdfHEMPJLUTW1YdnGX2JBc3DdD6ybJmkfE4wgSq',
-        asset_hash: 'BtbdpcxueKdAwpwRtyXMpUMV2Zbjd6YYtWvyiAK2FNQ6',
-        tree: '9PHhh7dJqdWnmjwiZEe6bMCFKnRSL436msEhN587adu5',
-        seq: 540278,
-        leaf_id: 539880,
-      },
-      grouping: [
-        {
-          group_key: 'collection',
-          group_value: 'PEEiTQbMc87HQ9TbXfHWWyW3bKiMExbGmAiMDR6NUiD',
-        },
-      ],
-      mutable: true,
-      burnt: false,
     });
+    t.deepEqual(asset.compression, <DasApiAssetCompression>{
+      eligible: false,
+      compressed: true,
+      data_hash: '29BdgNWxNB1sinkfmWKFQi3zWXRpsotp2FKoZhoqVa9F',
+      creator_hash: 'FGAvkyrzeEgvGGMfmi6ztGpvybHMYAL9w82nx6wzLVqn',
+      asset_hash: 'FGWfA5v5SZnpe9r32NEvDyX9hLeVEoBf3GqEkHX6YK9w',
+      tree: 'J1imb8C8SPzofrtgCxkN4nsKwHevzxgvHGeYBKFEDEmE',
+      seq: 1,
+      leaf_id: 0,
+    });
+    t.deepEqual(asset.grouping.length, 1);
+    t.like(asset.grouping[0], {
+      group_key: 'collection',
+      group_value: 'Dm1TRVw82roqpfqpzsFxSsWg6a4z3dku6ebVHSHuVo1c',
+    });
+    t.deepEqual(asset.mutable, true);
+    t.deepEqual(asset.burnt, false);
   });
 
   test(`it can fetch a regular asset by ID (${endpoint.name})`, async (t) => {
     // Given a minted NFT.
     const umi = createUmi(endpoint.url);
-    const assetId = publicKey('5ja3EvVuEu5rXgtYE3LXKG84s7Pmy5siFfYbcopMc2Dx');
+    const assetId = publicKey('8bFQbnBrzeiYQabEJ1ghy5T7uFpqFzPjUGsVi3SzSMHB');
 
     // When we fetch the asset using its ID.
     const asset = await umi.rpc.getAsset(assetId);
@@ -58,20 +59,19 @@ DAS_API_ENDPOINTS.forEach((endpoint) => {
       id: assetId,
       content: {
         metadata: {
-          name: 'Mad Lads #2732',
+          name: 'Chiaki Azure 55',
         },
       },
-      compression: {
-        compressed: false,
-      },
-      grouping: [
-        {
-          group_key: 'collection',
-          group_value: 'J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w',
-        },
-      ],
-      mutable: true,
-      burnt: false,
     });
+    t.like(asset.compression, <DasApiAssetCompression>{
+      compressed: false,
+    });
+    t.deepEqual(asset.grouping.length, 1);
+    t.like(asset.grouping[0], {
+      group_key: 'collection',
+      group_value: '5RT4e9uHUgG9h13cSc3L4YvkDc9qXSznoLaX4Tx8cpWS',
+    });
+    t.deepEqual(asset.mutable, true);
+    t.deepEqual(asset.burnt, false);
   });
 });

clients/js/test/getAsset.test.ts

@@ -7,24 +7,24 @@ DAS_API_ENDPOINTS.forEach((endpoint) => {
   test(`it can fetch the proof of a compressed asset by ID (${endpoint.name})`, async (t) => {
     // Given a minted NFT on devnet.
     const umi = createUmi(endpoint.url);
-    const assetId = publicKey('Ez6ezCMkRaUkWS5v6WVcP7uuCWiKadr3W2dHFkoZmteW');
+    const assetId = publicKey('GGRbPQhwmo3dXBkJSAjMFc1QYTKGBt8qc11tTp3LkEKA');
 
     // When we fetch the proof of the asset using its ID.
     const asset = await umi.rpc.getAssetProof(assetId);
 
     // Then we expect the following data.
     t.like(asset, <GetAssetProofRpcResponse>{
-      root: 'EFCPJ6uVgvwrCgAK3zxYv5xfFNmvSFNfGguQBLjRdDf',
+      root: 'ATo9owW1JofdTjhZNgMdYx8uS82mkExCSwCTvoyfTxmD',
       proof: [
-        '11111111111111111111111111111111',
-        'Cf5tmmFZ4D31tviuJezHdFLf5WF7yFvzfxNyftKsqTwr',
+        '7NCJtYyFmeG82fXeSW2DRfeTvitKeCs7e7hfAUowQtw5',
+        '8QoG5BnZH9RVz2qLsKPEQ5jnAaCBu3kdRd9Hf4PgSwx9',
         'DAbAU9srHpEUogXWuhy5VZ7g8UX9STymELtndcx1xgP1',
-        '6DVZtacK87UT6bTCLc9MLNJCHqAaySsFSjeGEXymMUh',
+        '3HCYqQRcQSChEuAw1ybNYHibrTNNjzbYzm56cmEmivB6',
         'GSz87YKd3YoZWcEKhnjSsYJwv8o5aWGdBdGGYUphRfTh',
       ],
-      node_index: 40,
-      leaf: 'ADh1Pe7CPB6JUTiPzHwoL1nJTDJA8zxeDMGPC5gYqSHE',
-      tree_id: '5wu82msJUAs4WWx3XtNMD5u7nuJSnfJMratppsZ6kL27',
+      node_index: 32,
+      leaf: 'FGWfA5v5SZnpe9r32NEvDyX9hLeVEoBf3GqEkHX6YK9w',
+      tree_id: 'J1imb8C8SPzofrtgCxkN4nsKwHevzxgvHGeYBKFEDEmE',
     });
   });
 });