@jpyc/sdk-core/dist/src/jpyc.js

Core SDK for JPYC protocol

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JPYC = void 0;
const soltypes_1 = require("soltypes");
const viem_1 = require("viem");
const interfaces_1 = require("./interfaces");
const utils_1 = require("./utils");
class JPYC {
    constructor(params) {
        this.contractAddress = process.env.SDK_ENV === 'local' ? utils_1.LOCAL_PROXY_ADDRESS : utils_1.V2_PROXY_ADDRESS;
        this.contractAbi = interfaces_1.JPYC_V2_ABI;
        if (!(0, utils_1.isValidAddress)({ address: this.contractAddress })) {
            throw new utils_1.InvalidAddressError(this.contractAddress);
        }
        this.contract = (0, viem_1.getContract)({
            address: this.contractAddress,
            abi: this.contractAbi,
            client: params.client,
        });
    }
    async isMinter(params) {
        const resp = await this.contract.read.isMinter([params.account]);
        return resp;
    }
    async minterAllowance(params) {
        const resp = await this.contract.read.minterAllowance([params.minter]);
        return (0, utils_1.restoreDecimals)(soltypes_1.Uint256.from(resp));
    }
    async totalSupply() {
        const resp = await this.contract.read.totalSupply();
        return (0, utils_1.restoreDecimals)(soltypes_1.Uint256.from(resp));
    }
    async balanceOf(params) {
        const resp = await this.contract.read.balanceOf([params.account]);
        return (0, utils_1.restoreDecimals)(soltypes_1.Uint256.from(resp));
    }
    async allowance(params) {
        const resp = await this.contract.read.allowance([params.owner, params.spender]);
        return (0, utils_1.restoreDecimals)(soltypes_1.Uint256.from(resp));
    }
    async nonces(params) {
        const resp = await this.contract.read.nonces([params.owner]);
        return (0, utils_1.toUint256)(resp);
    }
    async configureMinter(params) {
        const args = [params.minter, (0, utils_1.removeDecimals)(params.minterAllowedAmount)];
        try {
            await this.contract.simulate.configureMinter(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.configureMinter(args);
    }
    async mint(params) {
        const args = [params.to, (0, utils_1.removeDecimals)(params.amount)];
        try {
            await this.contract.simulate.mint(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.mint(args);
    }
    async transfer(params) {
        const args = [params.to, (0, utils_1.removeDecimals)(params.value)];
        try {
            await this.contract.simulate.transfer(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.transfer(args);
    }
    async transferFrom(params) {
        const args = [params.from, params.to, (0, utils_1.removeDecimals)(params.value)];
        try {
            await this.contract.simulate.transferFrom(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.transferFrom(args);
    }
    async transferWithAuthorization(params) {
        const args = [
            params.from,
            params.to,
            (0, utils_1.removeDecimals)(params.value),
            params.validAfter,
            params.validBefore,
            params.nonce,
            params.v,
            params.r,
            params.s,
        ];
        try {
            await this.contract.simulate.transferWithAuthorization(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.transferWithAuthorization(args);
    }
    async receiveWithAuthorization(params) {
        const args = [
            params.from,
            params.to,
            (0, utils_1.removeDecimals)(params.value),
            params.validAfter,
            params.validBefore,
            params.nonce,
            params.v,
            params.r,
            params.s,
        ];
        try {
            await this.contract.simulate.receiveWithAuthorization(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.receiveWithAuthorization(args);
    }
    async cancelAuthorization(params) {
        const args = [params.authorizer, params.nonce, params.v, params.r, params.s];
        try {
            await this.contract.simulate.cancelAuthorization(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.cancelAuthorization(args);
    }
    async approve(params) {
        const args = [params.spender, (0, utils_1.removeDecimals)(params.value)];
        try {
            await this.contract.simulate.approve(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.approve(args);
    }
    async increaseAllowance(params) {
        const args = [params.spender, (0, utils_1.removeDecimals)(params.increment)];
        try {
            await this.contract.simulate.increaseAllowance(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.increaseAllowance(args);
    }
    async decreaseAllowance(params) {
        const args = [params.spender, (0, utils_1.removeDecimals)(params.decrement)];
        try {
            await this.contract.simulate.decreaseAllowance(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.decreaseAllowance(args);
    }
    async permit(params) {
        const args = [
            params.owner,
            params.spender,
            (0, utils_1.removeDecimals)(params.value),
            params.deadline,
            params.v,
            params.r,
            params.s,
        ];
        try {
            await this.contract.simulate.permit(args);
        }
        catch (error) {
            throw new utils_1.InvalidTransactionError(error);
        }
        return await this.contract.write.permit(args);
    }
}
exports.JPYC = JPYC;
//# sourceMappingURL=jpyc.js.map