privately-smartcontract-lib 1.0.2

package/dist/modules/coin/coin.client.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivatelyCoinClient = void 0;
+const ethers_1 = require("ethers");
+const PrivatelyCoin_json_1 = __importDefault(require("../../../PrivatelyCoin.json"));
+const request_signature_1 = require("../../common/request-signature");
+const coin_approve_request_1 = require("./coin.approve.request");
+const coin_errors_1 = require("./coin.errors");
+const coin_transfer_request_1 = require("./coin.transfer.request");
+const COIN_CONTRACT_ADDRESS = "0x5fbdb2315678afecb367f032d93f642f64180aa3";
+/**
+ * CoinClient class to interact with the PrivatelyCoin smart contract
+ */
+class PrivatelyCoinClient {
+    contract;
+    signer;
+    domain;
+    /**
+     * Constructs a CoinClient instance to interact with the token contract
+     * @param signer The transaction signer (wallet with private key)
+     * @param network Network configuration for blockchain connection
+     */
+    constructor(signer, network) {
+        this.signer = signer;
+        this.contract = new ethers_1.Contract(COIN_CONTRACT_ADDRESS, PrivatelyCoin_json_1.default.abi, signer);
+        const name = PrivatelyCoin_json_1.default.contractName;
+        this.domain = {
+            name,
+            version: "1.0.0",
+            chainId: network.chainId,
+            verifyingContract: COIN_CONTRACT_ADDRESS
+        };
+    }
+    /**
+     * Retrieves the address of the current deployed contract.
+     * @returns The contract address.
+     */
+    getContractAddress() {
+        return COIN_CONTRACT_ADDRESS;
+    }
+    /**
+     * Creates a signed transfer request for meta-transaction execution
+     * @param to Recipient address
+     * @param amount Token amount to transfer
+     * @returns Promise containing transfer request and EIP-712 signature
+     */
+    async createTransferRequest(to, amount) {
+        const from = await this.signer.getAddress();
+        const nonce = (await this.getNonces()).transferNonce;
+        const request = {
+            from: from,
+            to: to,
+            amount: amount,
+            nonce: nonce
+        };
+        const signature = await this.signer.signTypedData(this.domain, coin_transfer_request_1.TRANSFER_REQUEST_TYPE, request);
+        return new request_signature_1.RequestSignature(request_signature_1.RequestType.COIN_TRANSFER, signature, request);
+    }
+    /**
+     * Relays a signed transfer request to execute as a meta-transaction
+     * @param request Signed transfer request object
+     * @param signature EIP-712 signature of the request
+     * @returns Blockchain transaction response
+     */
+    async relayTransferRequest(request, signature) {
+        try {
+            return await this.contract.metaTransfer(request.from, request.to, request.amount, signature);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Creates a signed allowance approval request for meta-transaction execution
+     * @param spender Authorized spending address
+     * @param amount Approved token amount
+     * @returns Promise containing approval request and EIP-712 signature
+     */
+    async createApproveRequest(spender, amount) {
+        const owner = await this.signer.getAddress();
+        const nonce = (await this.getNonces()).approveNonce;
+        const request = {
+            owner: owner,
+            spender: spender,
+            amount: amount,
+            nonce: nonce
+        };
+        const signature = await this.signer.signTypedData(this.domain, coin_approve_request_1.APPROVE_REQUEST_TYPE, request);
+        return new request_signature_1.RequestSignature(request_signature_1.RequestType.COIN_APPROVE, signature, request);
+    }
+    /**
+     * Relays a signed approval request to execute as a meta-transaction
+     * @param request Signed approval request object
+     * @param signature EIP-712 signature of the request
+     * @returns Blockchain transaction response
+     * @throws If signature verification fails or nonce mismatch occurs
+     */
+    async relayApproveRequest(request, signature) {
+        try {
+            return await this.contract.metaApprove(request.owner, request.spender, request.amount, signature);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Mints new tokens (requires minter role)
+     * @param to Recipient address
+     * @param amount Amount to mint
+     * @returns Blockchain transaction response
+     */
+    async mint(to, amount) {
+        try {
+            return await this.contract.mint(to, amount);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Executes standard ERC20 token transfer
+     * @param to Recipient address
+     * @param amount Amount to transfer
+     * @returns Blockchain transaction response
+     */
+    async transfer(to, amount) {
+        try {
+            return await this.contract.transfer(to, amount);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Approves spending allowance for a spender address
+     * @param spender Authorized spending address
+     * @param amount Approved amount
+     * @returns Blockchain transaction response
+     */
+    async approve(spender, amount) {
+        try {
+            return await this.contract.approve(spender, amount);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Gets remaining approved spending allowance
+     * @param owner Token owner address
+     * @param spender Authorized spender address
+     * @returns Remaining allowed amount
+     */
+    async allowance(owner, spender) {
+        try {
+            return await this.contract.allowance(owner, spender);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Transfers tokens from an approved address
+     * @param from Source address (must have allowance)
+     * @param to Recipient address
+     * @param amount Amount to transfer
+     * @returns Blockchain transaction response
+     */
+    async transferFrom(from, to, amount) {
+        try {
+            return await this.contract.transferFrom(from, to, amount);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves total token supply
+     * @returns Total circulating token amount
+     */
+    async totalSupply() {
+        try {
+            return await this.contract.totalSupply();
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Gets token balance for a specific address
+     * @param user Address to check
+     * @returns Current token balance
+     */
+    async getUserBalance(user) {
+        try {
+            return this.contract.balanceOf(user);
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves current balance for the signer's address
+     * @returns Current token balance for signer
+     */
+    async getBalance() {
+        const selfAddress = await this.signer.getAddress();
+        return this.getUserBalance(selfAddress);
+    }
+    /**
+     * Registers a listener for the "OnMint" event emitted by the contract when new coins are minted.
+     * @param listener A callback function to be executed when the "OnMint" event is triggered.
+     */
+    onMintEvent(listener) {
+        void this.contract.on("OnMint", (to, amount, finalBalance, event) => {
+            listener(to, amount, finalBalance, event);
+        });
+    }
+    /**
+     * Subscribes a listener to the "OnTransfer" event emitted by the contract when a transaction is executed.
+     * @param listener A callback function to be executed when the "OnTransfer" event is triggered.
+     */
+    onTransferEvent(listener) {
+        void this.contract.on("OnTransfer", (from, to, amount, fromFinalBalance, toFinalBalance, event) => {
+            listener(from, to, amount, fromFinalBalance, toFinalBalance, event);
+        });
+    }
+    /**
+     * Retrieves the current nonce for transfer and approve requests
+     * @returns Current nonces for signer's address
+     */
+    async getNonces() {
+        const selfAddress = await this.signer.getAddress();
+        try {
+            const nonces = await this.contract.getNonces(selfAddress);
+            return { transferNonce: nonces.transferNonce, approveNonce: nonces.approveNonce };
+        }
+        catch (error) {
+            throw coin_errors_1.CoinError.from(error, this.contract);
+        }
+    }
+}
+exports.PrivatelyCoinClient = PrivatelyCoinClient;

package/dist/modules/coin/coin.errors.d.ts

@@ -0,0 +1,6 @@
+import { Contract } from "ethers";
+import { PrivatelyError } from "../../common/privately.error";
+export declare class CoinError extends PrivatelyError {
+    constructor(message: string | object);
+    static from(error: any, contract?: Contract): CoinError;
+}

package/dist/modules/coin/coin.errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoinError = void 0;
+const privately_error_1 = require("../../common/privately.error");
+class CoinError extends privately_error_1.PrivatelyError {
+    constructor(message) {
+        super(`CoinError: ${typeof message === 'object' ? JSON.stringify(message) : message}`);
+        this.name = "CoinError";
+    }
+    static from(error, contract) {
+        try {
+            const message = (0, privately_error_1.parseContractError)(error, contract?.interface);
+            return new CoinError(message);
+        }
+        catch (parseError) {
+            return new CoinError({
+                originalError: error,
+                parseError
+            });
+        }
+    }
+}
+exports.CoinError = CoinError;

package/dist/modules/coin/coin.events.d.ts

@@ -0,0 +1,3 @@
+import { Log } from "ethers";
+export type OnMintListener = (to: string, amount: bigint, finalBalance: bigint, event: Log) => void;
+export type OnTransferListener = (from: string, to: string, amount: bigint, fromFinalBalance: bigint, toFinalBalance: bigint, event: Log) => void;

package/dist/modules/coin/coin.events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/coin/coin.nonces.d.ts

@@ -0,0 +1,4 @@
+export interface CoinNonces {
+    transferNonce: bigint;
+    approveNonce: bigint;
+}

package/dist/modules/coin/coin.nonces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/coin/coin.transfer.request.d.ts

@@ -0,0 +1,8 @@
+import { TypedDataField } from "ethers";
+export interface CoinTransferRequest {
+    from: string;
+    to: string;
+    amount: bigint;
+    nonce: bigint;
+}
+export declare const TRANSFER_REQUEST_TYPE: Record<string, TypedDataField[]>;

package/dist/modules/coin/coin.transfer.request.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSFER_REQUEST_TYPE = void 0;
+exports.TRANSFER_REQUEST_TYPE = {
+    TransferRequest: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "amount", type: "uint256" },
+        { name: "nonce", type: "uint256" }
+    ]
+};

package/dist/modules/coin/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./coin.approve.request";
+export * from "./coin.client";
+export * from "./coin.errors";
+export * from "./coin.nonces";
+export * from "./coin.transfer.request";

package/dist/modules/coin/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./coin.approve.request"), exports);
+__exportStar(require("./coin.client"), exports);
+__exportStar(require("./coin.errors"), exports);
+__exportStar(require("./coin.nonces"), exports);
+__exportStar(require("./coin.transfer.request"), exports);

package/dist/modules/collection/collection.approve.request.d.ts

@@ -0,0 +1,8 @@
+import { TypedDataField } from "ethers";
+export interface CollectionApproveRequest {
+    owner: string;
+    spender: string;
+    tokenId: bigint;
+    nonce: bigint;
+}
+export declare const COLLECTION_APPROVE_REQUEST_TYPE: Record<string, TypedDataField[]>;

package/dist/modules/collection/collection.approve.request.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLECTION_APPROVE_REQUEST_TYPE = void 0;
+exports.COLLECTION_APPROVE_REQUEST_TYPE = {
+    ApproveRequest: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "nonce", type: "uint256" }
+    ]
+};

package/dist/modules/collection/collection.client.d.ts

@@ -0,0 +1,97 @@
+import { Contract, Network, Signer, TransactionResponse } from "ethers";
+import { RequestSignature } from "../../common/request-signature";
+import { CollectionApproveRequest } from "./collection.approve.request";
+import { OnMintListener, OnTransferListener } from "./collection.events";
+import { CollectionMintRequest } from "./collection.mint.request";
+import { PrivatelyNFT } from "./collection.nft";
+import { CollectionTransferRequest } from "./collection.transfer.request";
+export declare class PrivatelyCollectionClient {
+    readonly contract: Contract;
+    private readonly signer;
+    private readonly domain;
+    constructor(signer: Signer, network: Network);
+    /**
+     * Retrieves a list of all NFT token IDs currently stored in the contract.
+     * @returns An array of token IDs as bigint.
+     */
+    getSupplyCollection(): Promise<bigint[]>;
+    /**
+     * Retrieves the list of NFT token IDs owned by a specific user.
+     * @param owner The address of the user whose Collection should be retrieved.
+     * @returns An array of token IDs as bigint.
+     */
+    getUserCollection(owner: string): Promise<PrivatelyNFT[]>;
+    /**
+     * Retrieves the list of NFT token IDs owned by the client's signer address.
+     * @returns An array of token IDs as bigint.
+     */
+    getCollection(): Promise<PrivatelyNFT[]>;
+    /**
+     * Fetches the metadata for a specific NFT token ID.
+     * @param tokenId The ID of the NFT (as BigNumberish).
+     * @returns A PrivatelyNFT object containing the NFT's metadata.
+     */
+    getData(tokenId: bigint): Promise<PrivatelyNFT>;
+    /**
+     * Creates and signs a MintRequest using EIP-712 structured data.
+     * This request can later be relayed to the contract via `relayMintRequest`.
+     * @param title The NFT title.
+     * @param tokenURI The URI for the NFT metadata.
+     * @returns An object containing the mint request struct and its EIP-712 signature.
+     */
+    createMintRequest(title: string, tokenURI: string): Promise<RequestSignature<CollectionMintRequest>>;
+    /**
+     * Relays a signed mint request to the blockchain.
+     * The relayer (caller of this function) is responsible for the transaction's gas cost.
+     * @param request The MintRequest object containing user, title, author, tokenURI, and nonce.
+     * @param signature The EIP-712 signature that authorizes this mint.
+     * @returns A TransactionResponse object from ethers.
+     */
+    relayMintRequest(request: CollectionMintRequest, signature: string): Promise<TransactionResponse>;
+    /**
+     * Creates and signs a TransferRequest using EIP-712 structured data.
+     * This request can later be relayed to the contract via `relayTransferRequest`.
+     * @param to The address to which the NFT should be transferred.
+     * @param tokenId The ID of the NFT (BigNumberish).
+     * @returns An object containing the transfer request struct and its EIP-712 signature.
+     */
+    createTransferRequest(to: string, tokenId: bigint): Promise<RequestSignature<CollectionTransferRequest>>;
+    /**
+     * Relays a signed transfer request to the blockchain.
+     * The relayer (caller of this function) is responsible for the transaction's gas cost.
+     * @param request The TransferRequest object containing from, to, tokenId, and nonce.
+     * @param signature The EIP-712 signature that authorizes this transfer.
+     * @returns A TransactionResponse object from ethers.
+     */
+    relayTransferRequest(request: CollectionTransferRequest, signature: string): Promise<TransactionResponse>;
+    /**
+     * Creates and signs an ApproveRequest using EIP-712 structured data.
+     * @param spender The address to which the approval should be granted.
+     * @param tokenId The ID of the NFT (BigNumberish).
+     * @returns An object containing the approval request struct and its EIP-712 signature.
+     */
+    createApproveRequest(spender: string, tokenId: bigint): Promise<RequestSignature<CollectionApproveRequest>>;
+    /**
+     * Relays a signed approval request to the blockchain.
+     * The relayer (caller of this function) is responsible for the transaction's gas cost.
+     * @param request The ApproveRequest object containing owner, spender, tokenId, and nonce.
+     * @param signature The EIP-712 signature that authorizes this approval.
+     * @returns A TransactionResponse object from ethers.
+     */
+    relayApproveRequest(request: CollectionApproveRequest, signature: string): Promise<TransactionResponse>;
+    /**
+     * Registers a listener for the "OnMint" event emitted by the contract when a new NFT is minted.
+     * @param listener A callback function to be executed when the "OnMint" event is triggered.
+     */
+    onMintEvent(listener: OnMintListener): void;
+    /**
+     * Subscribes a listener to the "OnTransfer" event emitted by the contract when a NFT transfer is executed.
+     * @param listener A callback function to be executed when the "OnTransfer" event is triggered.
+     */
+    onTransferEvent(listener: OnTransferListener): void;
+    /**
+     * Retrieves current nonce for meta-transactions
+     * @returns Current nonce for signer's address
+     */
+    private getNonces;
+}