privately-smartcontract-lib 1.0.2

package/dist/modules/auctions/auctions.client.js

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivatelyAuctionSystemClient = void 0;
+const ethers_1 = require("ethers");
+const PrivatelyAuctionSystem_json_1 = __importDefault(require("../../../PrivatelyAuctionSystem.json"));
+const request_signature_1 = require("../../common/request-signature");
+const auctions_auction_1 = require("./auctions.auction");
+const auctions_bid_reqest_1 = require("./auctions.bid.reqest");
+const auctions_create_request_1 = require("./auctions.create.request");
+const auctions_errors_1 = require("./auctions.errors");
+const AUCTION_SYSTEM_ADDRESS = "0x9fe46736679d2d9a65f0992f2272de9f3c7fa6e0";
+class PrivatelyAuctionSystemClient {
+    contract;
+    signer;
+    domain;
+    constructor(signer, network) {
+        this.signer = signer;
+        this.contract = new ethers_1.Contract(AUCTION_SYSTEM_ADDRESS, PrivatelyAuctionSystem_json_1.default.abi, signer);
+        const name = PrivatelyAuctionSystem_json_1.default.contractName;
+        this.domain = {
+            name,
+            version: "1.0.0",
+            chainId: network.chainId,
+            verifyingContract: AUCTION_SYSTEM_ADDRESS
+        };
+    }
+    /**
+     * Retrieves the address of the current deployed contract.
+     * @returns The contract address.
+     */
+    getContractAddress() {
+        return AUCTION_SYSTEM_ADDRESS;
+    }
+    /**
+     * Creates and signs a CreateAuctionRequest using EIP-712 structured data.
+     * The request can later be relayed to the contract via `relayCreateAuction`.
+     * @param tokenId The ID of the NFT being auctioned.
+     * @param startPrice The auction's starting price in wei.
+     * @param endTime The timestamp at which the auction ends.
+     * @returns An object containing the request struct and its signature.
+     */
+    async createAuctionRequest(tokenId, startPrice, endTime) {
+        const seller = await this.signer.getAddress();
+        const nonce = (await this.getNonces(seller)).createAuctionNonce;
+        const request = {
+            seller,
+            tokenId,
+            startPrice,
+            endTime,
+            nonce
+        };
+        const signature = await this.signer.signTypedData(this.domain, auctions_create_request_1.AUCTIONS_CREATE_REQUEST_TYPE, request);
+        return new request_signature_1.RequestSignature(request_signature_1.RequestType.AUCTION_CREATE, signature, request);
+    }
+    /**
+     * Relays a signed CreateAuctionRequest on-chain. The relayer pays gas.
+     * @param request The CreateAuctionRequest struct.
+     * @param signature The EIP-712 signature that authorizes creating the auction.
+     * @returns A TransactionResponse from ethers.
+     */
+    async relayCreateAuctionRequest(request, signature) {
+        try {
+            return await this.contract.metaCreateAuction(request.seller, request.tokenId, request.startPrice, request.endTime, signature);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Creates and signs a BidRequest using EIP-712 structured data.
+     * The request can later be relayed to the contract via `relayBid`.
+     * @param auctionId The ID of the auction the bidder is bidding on.
+     * @param bidAmount The amount in wei the bidder is offering.
+     * @returns An object containing the bid request struct and its signature.
+     */
+    async createBidRequest(auctionId, bidAmount) {
+        const bidder = await this.signer.getAddress();
+        const nonce = (await this.getNonces(bidder)).bidNonce;
+        const request = {
+            bidder,
+            auctionId,
+            bidAmount,
+            nonce
+        };
+        const signature = await this.signer.signTypedData(this.domain, auctions_bid_reqest_1.AUCTIONS_BID_REQUEST_TYPE, request);
+        return new request_signature_1.RequestSignature(request_signature_1.RequestType.AUCTION_BID, signature, request);
+    }
+    /**
+     * Relays a signed bid request (BidRequest) on-chain. The relayer pays gas.
+     * IMPORTANT: The relayer must include `bidAmount` in `msg.value` when sending the transaction.
+     * @param request The BidRequest struct.
+     * @param signature The EIP-712 signature that authorizes the bid.
+     * @returns A TransactionResponse from ethers.
+     */
+    async relayBidRequest(request, signature) {
+        try {
+            return await this.contract.metaBidAuction(request.bidder, request.auctionId, request.bidAmount, signature);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Finalizes an auction once the endTime is reached. Anyone can call this.
+     * @param auctionId The ID of the auction to finalize.
+     * @returns A TransactionResponse.
+     */
+    async finalizeAuction(auctionId) {
+        try {
+            return await this.contract.finalizeAuction(auctionId);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Allows users to withdraw their pending refunds from previous unsuccessful bids.
+     * @returns A TransactionResponse.
+     */
+    async withdraw() {
+        try {
+            return await this.contract.withdraw();
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves all auction IDs created in the contract.
+     * @returns An array of auction IDs.
+     */
+    async getAllAuctions() {
+        try {
+            return await this.contract.getAllAuctions();
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves all active auction IDs in the contract.
+     * @returns An array of Auction objects representing active auctions.
+     */
+    async getAllActiveAuctions() {
+        try {
+            const auctionList = await this.contract.getAllActiveAuctions();
+            return await auctions_auction_1.Auction.map(auctionList, this);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves all auction IDs created by a specific seller.
+     * @param seller The address of the seller to fetch auctions for.
+     * @returns An array of Auction objects.
+     */
+    async getSellerAuctions(seller) {
+        try {
+            const auctionList = await this.contract.getSellerAuctions(seller);
+            return await auctions_auction_1.Auction.map(auctionList, this);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves all auction IDs created by the client's signer address.
+     * @returns An array of Auction objects.
+     */
+    async getAuctions() {
+        return this.getSellerAuctions(await this.signer.getAddress());
+    }
+    /**
+     * Retrieves the auction details for a specific auction ID.
+     * @param auctionId The ID of the auction to fetch.
+     * @returns An Auction object.
+     */
+    async getAuction(auctionId) {
+        try {
+            const auction = await this.contract.getAuction(auctionId);
+            return new auctions_auction_1.Auction(auctionId, auction.seller, auction.tokenId, auction.startPrice, auction.highestBid, auction.highestBidder, auction.endTime, auction.settled);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Registers a listener for the "OnCreate" event emitted by the contract when an auction is created.
+     * @param listener  A callback function to be executed when the "OnCreate" event is triggered.
+     */
+    onCreateEvent(listener) {
+        void this.contract.on("OnCreate", (auctionId, seller, tokenId, startPrice, endTime, event) => {
+            listener(auctionId, seller, tokenId, startPrice, endTime, event);
+        });
+    }
+    /**
+     * Registers a listener for the "OnBid" event emitted by the contract when a bid is placed.
+     * @param listener A callback function to be executed when the "OnBid" event is triggered.
+     */
+    onBidEvent(listener) {
+        void this.contract.on("OnBid", (auctionId, bidder, bidAmount, event) => {
+            listener(auctionId, bidder, bidAmount, event);
+        });
+    }
+    /**
+     * Registers a listener for the "OnEnd" event emitted by the contract when an auction ends.
+     * @param listener A callback function to be executed when the "OnEnd" event is triggered.
+     */
+    onEndEvent(listener) {
+        void this.contract.on("OnEnd", (auctionId, tokenId, highestBidder, highestBid, event) => {
+            listener(auctionId, tokenId, highestBidder, highestBid, event);
+        });
+    }
+    /**
+     * Registers a listener for the "OnWithdraw" event emitted by the contract when a user withdraws funds.
+     * @param listener A callback function to be executed when the "OnWithdraw" event is triggered.
+     */
+    onWithdrawEvent(listener) {
+        void this.contract.on("OnWithdraw", (user, amount, event) => {
+            listener(user, amount, event);
+        });
+    }
+    /**
+     * Retrieves all auctions (settled or not) for a given tokenId,
+     * and maps them into Auction instances via Auction.map().
+     * @param tokenId The NFT identifier.
+     * @returns A list of Auction objects.
+     */
+    async getAuctionsByToken(tokenId) {
+        try {
+            const rawList = await this.contract.getAuctionsByToken(tokenId);
+            return rawList.map(raw => new auctions_auction_1.Auction(raw[1], raw[0], tokenId, raw[2], raw[3], raw[4], raw[5], raw[6]));
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Fetches the current nonces for a user.
+     * @param userAddress The address of the user to fetch the nonce for.
+     * @returns An object containing the nonces.
+     */
+    async getNonces(userAddress) {
+        try {
+            const nonce = await this.contract.getNonces(userAddress);
+            return { createAuctionNonce: nonce.createAuctionNonce, bidNonce: nonce.bidNonce };
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves all auctions where the user has placed at least one bid.
+     * @param userAddress The address of the user to fetch auctions for.
+     * @returns An array of Auction objects where the user has bid.
+     */
+    async getUserBidAuctions(userAddress) {
+        try {
+            const auctionIds = await this.contract.getUserBidAuctions(userAddress);
+            return await auctions_auction_1.Auction.map(auctionIds, this);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves all active auctions where the user has placed at least one bid.
+     * @param userAddress The address of the user to fetch active auctions for.
+     * @returns An array of active Auction objects where the user has bid.
+     */
+    async getUserActiveBidAuctions(userAddress) {
+        try {
+            const auctionIds = await this.contract.getUserActiveBidAuctions(userAddress);
+            return await auctions_auction_1.Auction.map(auctionIds, this);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+    /**
+     * Retrieves all auctions where the current signer has placed at least one bid.
+     * @returns An array of Auction objects where the signer has bid.
+     */
+    async getBidAuctions() {
+        return this.getUserBidAuctions(await this.signer.getAddress());
+    }
+    /**
+     * Retrieves all active auctions where the current signer has placed at least one bid.
+     * @returns An array of active Auction objects where the signer has bid.
+     */
+    async getActiveBidAuctions() {
+        return this.getUserActiveBidAuctions(await this.signer.getAddress());
+    }
+    /**
+     * Retrieves all expired but unfinalized auction IDs in the contract.
+     * @returns An array of expired auction objects that need to be finalized.
+     */
+    async getAllExpiredUnfinalizedAuctions() {
+        try {
+            const auctionList = await this.contract.getAllExpiredUnfinalizedAuctions();
+            return await auctions_auction_1.Auction.map(auctionList, this);
+        }
+        catch (error) {
+            throw auctions_errors_1.AuctionSystemError.from(error, this.contract);
+        }
+    }
+}
+exports.PrivatelyAuctionSystemClient = PrivatelyAuctionSystemClient;

package/dist/modules/auctions/auctions.create.request.d.ts

@@ -0,0 +1,13 @@
+export interface CreateAuctionRequest {
+    seller: string;
+    tokenId: bigint;
+    startPrice: bigint;
+    endTime: bigint;
+    nonce: bigint;
+}
+export declare const AUCTIONS_CREATE_REQUEST_TYPE: {
+    CreateAuctionRequest: {
+        name: string;
+        type: string;
+    }[];
+};

package/dist/modules/auctions/auctions.create.request.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUCTIONS_CREATE_REQUEST_TYPE = void 0;
+exports.AUCTIONS_CREATE_REQUEST_TYPE = {
+    CreateAuctionRequest: [
+        { name: "seller", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "startPrice", type: "uint256" },
+        { name: "endTime", type: "uint256" },
+        { name: "nonce", type: "uint256" }
+    ]
+};

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

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

package/dist/modules/auctions/auctions.errors.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuctionSystemError = void 0;
+const privately_error_1 = require("../../common/privately.error");
+class AuctionSystemError extends privately_error_1.PrivatelyError {
+    constructor(message) {
+        super(`AuctionSystemError: ${message}`);
+        this.name = "AuctionSystemError";
+    }
+    static from(error, contract) {
+        return new AuctionSystemError((0, privately_error_1.parseContractError)(error, contract?.interface));
+    }
+}
+exports.AuctionSystemError = AuctionSystemError;

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

@@ -0,0 +1,5 @@
+import { Log } from "ethers/lib.esm";
+export type OnCreateListener = (auctionId: bigint, seller: string, tokenId: bigint, startPrice: bigint, endTime: bigint, event: Log) => void;
+export type OnBidListener = (auctionId: bigint, bidder: string, bidAmount: bigint, event: Log) => void;
+export type OnEnd = (auctionId: bigint, tokenId: bigint, highestBidder: string, highestBid: bigint, event: Log) => void;
+export type OnWithdrawListener = (user: string, amount: bigint, event: Log) => void;

package/dist/modules/auctions/auctions.events.js

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

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

@@ -0,0 +1,4 @@
+export interface AuctionsNonces {
+    createAuctionNonce: bigint;
+    bidNonce: bigint;
+}

package/dist/modules/auctions/auctions.nonces.js

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

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

@@ -0,0 +1,6 @@
+export * from "./auctions.auction";
+export * from "./auctions.bid.reqest";
+export * from "./auctions.client";
+export * from "./auctions.create.request";
+export * from "./auctions.errors";
+export * from "./auctions.nonces";

package/dist/modules/auctions/index.js

@@ -0,0 +1,22 @@
+"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("./auctions.auction"), exports);
+__exportStar(require("./auctions.bid.reqest"), exports);
+__exportStar(require("./auctions.client"), exports);
+__exportStar(require("./auctions.create.request"), exports);
+__exportStar(require("./auctions.errors"), exports);
+__exportStar(require("./auctions.nonces"), exports);

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

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

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

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

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

@@ -0,0 +1,120 @@
+import { Contract, Network, Signer, TransactionResponse } from "ethers";
+import { RequestSignature } from "../../common/request-signature";
+import { CoinApproveRequest } from "./coin.approve.request";
+import { OnMintListener, OnTransferListener } from "./coin.events";
+import { CoinTransferRequest } from "./coin.transfer.request";
+/**
+ * CoinClient class to interact with the PrivatelyCoin smart contract
+ */
+export declare class PrivatelyCoinClient {
+    readonly contract: Contract;
+    private readonly signer;
+    private readonly 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: Signer, network: Network);
+    /**
+     * Retrieves the address of the current deployed contract.
+     * @returns The contract address.
+     */
+    getContractAddress(): string;
+    /**
+     * 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
+     */
+    createTransferRequest(to: string, amount: bigint): Promise<RequestSignature<CoinTransferRequest>>;
+    /**
+     * 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
+     */
+    relayTransferRequest(request: CoinTransferRequest, signature: string): Promise<TransactionResponse>;
+    /**
+     * 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
+     */
+    createApproveRequest(spender: string, amount: bigint): Promise<RequestSignature<CoinApproveRequest>>;
+    /**
+     * 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
+     */
+    relayApproveRequest(request: CoinApproveRequest, signature: string): Promise<TransactionResponse>;
+    /**
+     * Mints new tokens (requires minter role)
+     * @param to Recipient address
+     * @param amount Amount to mint
+     * @returns Blockchain transaction response
+     */
+    mint(to: string, amount: bigint): Promise<TransactionResponse>;
+    /**
+     * Executes standard ERC20 token transfer
+     * @param to Recipient address
+     * @param amount Amount to transfer
+     * @returns Blockchain transaction response
+     */
+    transfer(to: string, amount: bigint): Promise<TransactionResponse>;
+    /**
+     * Approves spending allowance for a spender address
+     * @param spender Authorized spending address
+     * @param amount Approved amount
+     * @returns Blockchain transaction response
+     */
+    approve(spender: string, amount: bigint): Promise<TransactionResponse>;
+    /**
+     * Gets remaining approved spending allowance
+     * @param owner Token owner address
+     * @param spender Authorized spender address
+     * @returns Remaining allowed amount
+     */
+    allowance(owner: string, spender: string): Promise<bigint>;
+    /**
+     * 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
+     */
+    transferFrom(from: string, to: string, amount: bigint): Promise<TransactionResponse>;
+    /**
+     * Retrieves total token supply
+     * @returns Total circulating token amount
+     */
+    totalSupply(): Promise<bigint>;
+    /**
+     * Gets token balance for a specific address
+     * @param user Address to check
+     * @returns Current token balance
+     */
+    getUserBalance(user: string): Promise<bigint>;
+    /**
+     * Retrieves current balance for the signer's address
+     * @returns Current token balance for signer
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * 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: OnMintListener): void;
+    /**
+     * 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: OnTransferListener): void;
+    /**
+     * Retrieves the current nonce for transfer and approve requests
+     * @returns Current nonces for signer's address
+     */
+    private getNonces;
+}