@aptos-labs/ts-sdk 1.9.0 → 1.9.1-plugin.1

package/src/assetUploader/assetUploader.ts

@@ -0,0 +1,87 @@
+import type { FundResponse, UploadResponse } from "@irys/sdk/build/cjs/common/types";
+import { AptosConfig } from "../api";
+import { Account } from "../core";
+import { IrysAssetUploader } from "./irys";
+
+/**
+ * Shared interfae for asset uploader providers to implement
+ *
+ * When extending the SDK to use different providers, we need to have those
+ * function arguments inputs and outputs use generics.
+ */
+export interface IAssetUploader {
+  fundNode(args: { account: Account; amount: number }): Promise<FundResponse>;
+  uploadData(args: { account: Account; data: string | Buffer; options?: any }): Promise<UploadResponse>;
+  uploadFile(args: { account: Account; filePathToUpload: string; options?: any }): Promise<UploadResponse>;
+  uploadFolder(args: { account: Account; folderToUpload: string; options?: any }): Promise<UploadResponse | undefined>;
+}
+
+export class AssetUploader {
+  readonly config: AptosConfig;
+
+  readonly assetUploader: IAssetUploader;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+
+    switch (config.assetUploaderProvider) {
+      case "irys":
+        this.assetUploader = new IrysAssetUploader(this.config);
+        break;
+      default:
+        throw new Error("Invalid asset uploader provided");
+    }
+  }
+
+  /**
+   * Funds the node you connected to with the specified amount of tokens
+   *
+   * @param args.account The account to sign and pay the fund transaction with
+   * @param args.amount The amount to fund the node in
+   *
+   * @return FundResponse
+   */
+  async fundNode(args: { account: Account; amount: number }): Promise<FundResponse> {
+    return this.assetUploader.fundNode({ ...args });
+  }
+
+  /**
+   * Upload a data
+   *
+   * @param args.account The account to sign and pay the fund transaction with
+   * @param args.data The data to upload
+   *
+   * @return UploadResponse
+   */
+  async uploadData(args: { account: Account; data: string | Buffer; options?: any }): Promise<UploadResponse> {
+    return this.assetUploader.uploadData({ ...args });
+  }
+
+  /**
+   * Upload a file
+   *
+   * @param args.account The account to sign and pay the upload file transaction with
+   * @param args.filePathToUpload The file to upload as the file path
+   *
+   * @return UploadResponse
+   */
+  async uploadFile(args: { account: Account; filePathToUpload: string; options?: any }): Promise<UploadResponse> {
+    return this.assetUploader.uploadFile({ ...args });
+  }
+
+  /**
+   * Upload a folder
+   *
+   * @param args.account The account to sign and pay the upload folder transaction with
+   * @param args.folderToUpload The folder to upload as the folder path
+   *
+   * @return UploadResponse | undefined
+   */
+  async uploadFolder(args: {
+    account: Account;
+    folderToUpload: string;
+    options?: any;
+  }): Promise<UploadResponse | undefined> {
+    return this.assetUploader.uploadFolder({ ...args });
+  }
+}

package/src/assetUploader/index.ts

@@ -0,0 +1 @@
+export * from "./assetUploader";

package/src/assetUploader/irys.ts

@@ -0,0 +1,102 @@
+import Irys from "@irys/sdk";
+import type { FundResponse, CreateAndUploadOptions, UploadResponse } from "@irys/sdk/build/cjs/common/types";
+import { AptosConfig } from "../api";
+import { Account } from "../core";
+import { Network } from "../utils";
+import { IAssetUploader } from "./assetUploader";
+
+/**
+ * Irys asset uploader
+ *
+ * Keeping the class here for now for simplicity, when/if extending the SDK
+ * to more providers encourged to get this out to its own file
+ */
+export class IrysAssetUploader implements IAssetUploader {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  resolveProvider(): { irysNode: string; providerUrl: Network } {
+    switch (this.config.network) {
+      case Network.DEVNET:
+        // Irys does not support Aptos' devnet
+        throw new Error("Irys does not support Aptos' devnet");
+      case Network.TESTNET:
+        return { irysNode: "devnet", providerUrl: Network.TESTNET };
+      case Network.MAINNET:
+        // Irys supports node1 and node2, there is no major difference between
+        // those and it is recommended to simply use node1
+        return { irysNode: "node1", providerUrl: Network.MAINNET };
+      default:
+        throw new Error("Unsopported network");
+    }
+  }
+
+  async getIrys(args: { account: Account }) {
+    const { irysNode, providerUrl } = this.resolveProvider();
+    const irys = Irys.init({
+      url: irysNode, // Irys node
+      token: "aptos", // Token used for payment and signing
+      publicKey: args.account.publicKey.toString(), // Aptos wallet publicKey
+      providerUrl: providerUrl, // Aptos Network
+      signingFunction: async (msg: Uint8Array) => args.account.sign(msg).toUint8Array(), // Signing function Irys will use
+    });
+    return irys;
+  }
+
+  async fundNode(args: { account: Account; amount: number }): Promise<FundResponse> {
+    const { account, amount } = args;
+    const irys = await this.getIrys({ account });
+    try {
+      return await irys.fund(amount);
+    } catch (e) {
+      throw new Error(`Error funding irys node ${e}`);
+    }
+  }
+
+  async uploadData(args: {
+    account: Account;
+    data: string | Buffer;
+    options?: CreateAndUploadOptions;
+  }): Promise<UploadResponse> {
+    const { account, data, options } = args;
+    const irys = await this.getIrys({ account });
+    try {
+      return await irys.upload(data, options);
+    } catch (e) {
+      throw new Error(`Error funding data to irys ${e}`);
+    }
+  }
+
+  async uploadFile(args: {
+    account: Account;
+    filePathToUpload: string;
+    options?: CreateAndUploadOptions;
+  }): Promise<UploadResponse> {
+    const { account, filePathToUpload, options } = args;
+    const irys = await this.getIrys({ account });
+
+    try {
+      return await irys.uploadFile(filePathToUpload, options);
+    } catch (e) {
+      throw new Error(`Error uploading file to irys ${e}`);
+    }
+  }
+
+  async uploadFolder(args: {
+    account: Account;
+    folderToUpload: string;
+    options?: any;
+  }): Promise<UploadResponse | undefined> {
+    const { account, folderToUpload, options } = args;
+    const irys = await this.getIrys({ account });
+
+    try {
+      return await irys.uploadFolder(folderToUpload, options);
+    } catch (e) {
+      throw new Error(`Error uploading folder to irys ${e}`);
+    }
+  }
+}

package/src/index.ts

@@ -9,3 +9,4 @@ export * from "./transactions";
 export * from "./transactions/management";
 export * from "./types";
 export * from "./utils";
+export * from "./assetUploader";

package/src/internal/queries/currentTokenOwnershipFieldsFragment.graphql

@@ -25,7 +25,6 @@ fragment CurrentTokenOwnershipFields on current_token_ownerships_v2 {
     token_properties
     token_standard
     token_uri
-    decimals
     current_collection {
       collection_id
       collection_name

package/src/types/index.ts

@@ -142,6 +142,8 @@ export type AptosSettings = {
   readonly clientConfig?: ClientConfig;
 
   readonly client?: Client;
+
+  readonly assetUploaderProvider?: string;
 };
 
 /**

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "1.9.0";
+export const VERSION = "1.9.1";