@zebec-network/admin-sdk 1.0.0

package/dist/services/proxyStreamService.js

@@ -0,0 +1,302 @@
+import anchor, { Program, } from "@coral-xyz/anchor";
+import { createMetadataAccountV3, MPL_TOKEN_METADATA_PROGRAM_ID, updateMetadataAccountV2, } from "@metaplex-foundation/mpl-token-metadata";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import { fromWeb3JsPublicKey, toWeb3JsPublicKey, } from "@metaplex-foundation/umi-web3js-adapters";
+import { AuthorityType, createInitializeMintInstruction, createSetAuthorityInstruction, getMinimumBalanceForRentExemptMint, MINT_SIZE, TOKEN_PROGRAM_ID, } from "@solana/spl-token";
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey, SystemProgram, } from "@solana/web3.js";
+import { bpsToPercent, percentToBps } from "@zebec-network/core-utils";
+import { TransactionPayload, } from "@zebec-network/solana-common";
+import BN from "bn.js";
+import { ZEBEC_PROXY_STREAM_IDL, ZEBEC_STREAM_IDL, } from "../artifacts/index.js";
+import { STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS } from "../constants.js";
+import { deriveMintAuthorityPda, deriveProxyConfigPda, deriveStreamConfigPda, } from "../pda.js";
+const { translateAddress, AnchorProvider } = anchor;
+export class ProxyStreamAdminService {
+    provider;
+    proxyStreamProgram;
+    streamProgram;
+    network;
+    constructor(provider, proxyStreamProgram, streamProgram, network) {
+        this.provider = provider;
+        this.proxyStreamProgram = proxyStreamProgram;
+        this.streamProgram = streamProgram;
+        this.network = network;
+    }
+    static create(provider, network) {
+        const proxyStreamProgram = new Program(ZEBEC_PROXY_STREAM_IDL, provider);
+        const streamProgram = new Program(ZEBEC_STREAM_IDL, provider);
+        return new ProxyStreamAdminService(provider, proxyStreamProgram, streamProgram, network);
+    }
+    async _createTransactionPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
+        const errorMap = new Map();
+        this.proxyStreamProgram.idl.errors.map((error) => errorMap.set(error.code, error.msg));
+        let signTransaction;
+        const provider = this.provider;
+        if (provider instanceof AnchorProvider) {
+            signTransaction = async (tx) => {
+                return provider.wallet.signTransaction(tx);
+            };
+        }
+        return new TransactionPayload(this.provider.connection, errorMap, {
+            instructions,
+            feePayer: payerKey,
+            signers: signers ?? [],
+            addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+        }, signTransaction);
+    }
+    get proxyStreamProgramId() {
+        return this.proxyStreamProgram.programId;
+    }
+    get streamProgramId() {
+        return this.streamProgram.programId;
+    }
+    get connection() {
+        return this.provider.connection;
+    }
+    async getInitProxyConfigInstruction(admin, feeVault, mintAuthority, proxyConfig, data) {
+        return this.proxyStreamProgram.methods
+            .initProxyConfig({
+            chainId: data.chainId,
+            fee: data.fee,
+            minAmount: data.minAmount,
+        })
+            .accountsPartial({
+            feeVault,
+            admin,
+            mintAuthority,
+            proxyConfig,
+        })
+            .instruction();
+    }
+    async initProxyConfig(params) {
+        const admin = translateAddress(params.admin);
+        const feeVault = translateAddress(params.feeVault);
+        const [mintAuthority] = deriveMintAuthorityPda(this.proxyStreamProgramId);
+        const proxyConfigPda = deriveProxyConfigPda(params.chainId, this.proxyStreamProgramId);
+        const [proxyConfig] = proxyConfigPda;
+        const fee = Number(percentToBps(params.fee));
+        const minAmount = new BN(params.minAmount);
+        const ix = await this.getInitProxyConfigInstruction(admin, feeVault, mintAuthority, proxyConfig, {
+            chainId: params.chainId,
+            fee,
+            minAmount,
+        });
+        return this._createTransactionPayload(admin, [ix]);
+    }
+    async getUpdateProxyConfigInstruction(admin, proxyConfig, data) {
+        return this.proxyStreamProgram.methods
+            .updateProxy({
+            fee: data.fee,
+            newAdmin: data.newAdmin,
+        })
+            .accountsPartial({
+            proxyAdmin: admin,
+            proxyConfig,
+        })
+            .instruction();
+    }
+    async updateProxyConfig(params) {
+        const admin = translateAddress(params.admin);
+        const newAdmin = translateAddress(params.newAdmin);
+        const [proxyConfig] = deriveProxyConfigPda(params.chainId, this.proxyStreamProgramId);
+        const fee = Number(percentToBps(params.fee));
+        const ix = await this.getUpdateProxyConfigInstruction(admin, proxyConfig, {
+            fee,
+            newAdmin,
+        });
+        return this._createTransactionPayload(admin, [ix]);
+    }
+    async getSetMintableTokensInstruction(admin, proxyConfig, data) {
+        return this.proxyStreamProgram.methods
+            .setMintableTokens({
+            tokens: data.tokens,
+        })
+            .accountsPartial({
+            proxyAdmin: admin,
+            proxyConfig,
+        })
+            .instruction();
+    }
+    async getWhitelistTokensInstruction(admin, streamConfig, data) {
+        return this.streamProgram.methods
+            .whitelistTokens({ tokens: data.tokens })
+            .accountsPartial({ admin, streamConfig })
+            .instruction();
+    }
+    async createToken(params) {
+        const { tokenInfo } = params;
+        const connection = new Connection(this.connection.rpcEndpoint, this.connection.commitment);
+        const lamports = await getMinimumBalanceForRentExemptMint(connection);
+        const mintKeypair = tokenInfo.mintKeypair ?? Keypair.generate();
+        const mint = mintKeypair.publicKey;
+        const admin = translateAddress(params.admin);
+        const mintAuthority = admin;
+        const updateAuthority = admin;
+        const [newMintAuthority] = deriveMintAuthorityPda(this.proxyStreamProgramId);
+        const umi = createUmi(this.connection.rpcEndpoint);
+        const mplProgramId = toWeb3JsPublicKey(MPL_TOKEN_METADATA_PROGRAM_ID);
+        const [metadata] = PublicKey.findProgramAddressSync([Buffer.from("metadata"), mplProgramId.toBytes(), mint.toBytes()], mplProgramId);
+        const args = {
+            data: {
+                name: tokenInfo.tokenName,
+                symbol: tokenInfo.symbol,
+                uri: tokenInfo.metadataUri,
+                sellerFeeBasisPoints: 0,
+                collection: null,
+                creators: null,
+                uses: null,
+            },
+            isMutable: true,
+            collectionDetails: null,
+        };
+        // just a work around to create a umi signer from web3Js PublicKey
+        // as umi expects a Signer object. only publicKey is used, so others are null.
+        // biome-ignore lint/suspicious/noExplicitAny: see above
+        const mintAuthoritySigner = {
+            publicKey: fromWeb3JsPublicKey(mintAuthority),
+            signTransaction: null,
+            signMessage: null,
+            signAllTransactions: null,
+        };
+        const accounts = {
+            metadata: fromWeb3JsPublicKey(metadata),
+            mint: fromWeb3JsPublicKey(mint),
+            payer: mintAuthoritySigner,
+            mintAuthority: mintAuthoritySigner,
+            updateAuthority: fromWeb3JsPublicKey(updateAuthority),
+        };
+        const metadataBuilder = createMetadataAccountV3(umi, {
+            ...accounts,
+            ...args,
+        });
+        const ix = metadataBuilder.getInstructions()[0];
+        if (!ix) {
+            throw new Error("Failed to create metadata instruction");
+        }
+        const createMetadataInstruction = {
+            keys: ix.keys.map((key) => {
+                return {
+                    ...key,
+                    pubkey: toWeb3JsPublicKey(key.pubkey),
+                };
+            }),
+            data: Buffer.from(ix.data),
+            programId: toWeb3JsPublicKey(ix.programId),
+        };
+        const [proxyConfigPda] = deriveProxyConfigPda(params.chainId, this.proxyStreamProgramId);
+        const setMintableTokenIx = await this.getSetMintableTokensInstruction(admin, proxyConfigPda, {
+            tokens: [mint],
+        });
+        const [streamConfig] = deriveStreamConfigPda(params.streamConfigName, this.streamProgramId);
+        const whiteListTokensIx = await this.getWhitelistTokensInstruction(admin, streamConfig, { tokens: [mint] });
+        const ixs = [
+            SystemProgram.createAccount({
+                fromPubkey: mintAuthority,
+                newAccountPubkey: mint,
+                space: MINT_SIZE,
+                lamports: lamports,
+                programId: TOKEN_PROGRAM_ID,
+            }),
+            createInitializeMintInstruction(mint, tokenInfo.decimals, mintAuthority, null, TOKEN_PROGRAM_ID),
+            createMetadataInstruction,
+            createSetAuthorityInstruction(mint, mintAuthority, AuthorityType.MintTokens, // authority type
+            newMintAuthority),
+            setMintableTokenIx,
+            whiteListTokensIx,
+        ];
+        const addressLookupTableAccount = await this.connection
+            .getAccountInfo(translateAddress(STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS[this.network]))
+            .then((accountInfo) => {
+            if (!accountInfo) {
+                throw new Error(`Address lookup table for ${STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS[this.network]} account not found`);
+            }
+            return new AddressLookupTableAccount({
+                key: translateAddress(STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS[this.network]),
+                state: AddressLookupTableAccount.deserialize(accountInfo.data),
+            });
+        });
+        return this._createTransactionPayload(admin, ixs, [mintKeypair], [addressLookupTableAccount]);
+    }
+    async updateZTokenMetadata(params) {
+        const { tokenInfo } = params;
+        const admin = translateAddress(params.admin);
+        const mint = translateAddress(params.mint);
+        const updateAuthority = admin;
+        const umi = createUmi(this.connection.rpcEndpoint);
+        const mplProgramId = toWeb3JsPublicKey(MPL_TOKEN_METADATA_PROGRAM_ID);
+        const [metadata] = PublicKey.findProgramAddressSync([Buffer.from("metadata"), mplProgramId.toBytes(), mint.toBytes()], mplProgramId);
+        const args = {
+            data: {
+                name: tokenInfo.tokenName,
+                symbol: tokenInfo.symbol,
+                uri: tokenInfo.metadataUri,
+                sellerFeeBasisPoints: 0,
+                collection: null,
+                creators: null,
+                uses: null,
+            },
+            isMutable: true,
+            newUpdateAuthority: fromWeb3JsPublicKey(updateAuthority),
+            primarySaleHappened: null,
+        };
+        // just a work around to create a umi signer from web3Js PublicKey
+        // as umi expects a Signer object. only publicKey is used, so others are null.
+        // biome-ignore lint/suspicious/noExplicitAny: see above
+        const updateAuthoritySigner = {
+            publicKey: fromWeb3JsPublicKey(updateAuthority),
+            signTransaction: null,
+            signMessage: null,
+            signAllTransactions: null,
+        };
+        const accounts = {
+            metadata: fromWeb3JsPublicKey(metadata),
+            updateAuthority: updateAuthoritySigner,
+        };
+        const metadataBuilder = updateMetadataAccountV2(umi, {
+            ...accounts,
+            ...args,
+        });
+        const ix = metadataBuilder.getInstructions()[0];
+        if (!ix) {
+            throw new Error("Failed to create update metadata instruction");
+        }
+        const updateMetadataInstruction = {
+            keys: ix.keys.map((key) => {
+                return {
+                    ...key,
+                    pubkey: toWeb3JsPublicKey(key.pubkey),
+                };
+            }),
+            data: Buffer.from(ix.data),
+            programId: toWeb3JsPublicKey(ix.programId),
+        };
+        return this._createTransactionPayload(admin, [updateMetadataInstruction]);
+    }
+    async getEmergencyPauseInstruction(admin) {
+        return this.proxyStreamProgram.methods
+            .emergencyPause()
+            .accounts({
+            proxyAdmin: admin,
+        })
+            .instruction();
+    }
+    async emergencyPause(params) {
+        const admin = translateAddress(params.admin);
+        const ix = await this.getEmergencyPauseInstruction(admin);
+        return this._createTransactionPayload(admin, [ix]);
+    }
+    async getProxyConfig(chainId) {
+        const [proxyConfig] = deriveProxyConfigPda(chainId, this.proxyStreamProgramId);
+        const proxyConfigAccount = await this.proxyStreamProgram.account.proxyConfig.fetch(proxyConfig);
+        return {
+            address: proxyConfig,
+            fee: bpsToPercent(proxyConfigAccount.fee.toString()),
+            minAmount: proxyConfigAccount.minAmount.toString(),
+            proxyAdmin: proxyConfigAccount.proxyAdmin,
+            mintableTokens: proxyConfigAccount.mintableTokens,
+            feeVault: proxyConfigAccount.feeVault,
+            emergencyPaused: proxyConfigAccount.emergencyPause,
+            chainId: proxyConfigAccount.chainId,
+        };
+    }
+}

package/dist/services/solanaCardV2Service.d.ts

@@ -0,0 +1,50 @@
+import { type Address, Program, type Provider } from "@coral-xyz/anchor";
+import type { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { TransactionPayload } from "@zebec-network/solana-common";
+import { type ZebecCardV2Idl } from "../artifacts/index.js";
+import type { CardConfigInfo, CardPurchaseInfo, DeleteCustomFeesParams, DeletePartnerCustomFeesInstructionData, DeletePartnerCustomFeesParams, InitCardConfigInstructionData, InitCardConfigParams, InitPartnerCardConfigInstructionData, InitPartnerCardConfigParams, ParsedTokenFeeRecord, PartnerCardConfigInfo, SetCardConfigInstructionData, SetCardConfigParams, SetCustomFeesParams, SetPartnerCardConfigInstructionData, SetPartnerCardConfigParams, SetPartnerCustomFeesParams, TokenFeeRecord, UserPurchaseRecordInfo } from "../types.js";
+export declare class ZebecSolanaCardV2AdminService {
+    readonly provider: Provider;
+    readonly network: "mainnet-beta" | "devnet";
+    readonly program: Program<ZebecCardV2Idl>;
+    constructor(provider: Provider, network: "mainnet-beta" | "devnet", program: Program<ZebecCardV2Idl>);
+    static create(provider: Provider, network: "mainnet-beta" | "devnet"): ZebecSolanaCardV2AdminService;
+    private _createPayload;
+    get connection(): Connection;
+    get programId(): PublicKey;
+    getInitCardConfigsInstruction(usdcToken: PublicKey, zicOwner: PublicKey, data: InitCardConfigInstructionData): Promise<TransactionInstruction>;
+    getSetCardConfigsInstruction(zicOwner: PublicKey, data: SetCardConfigInstructionData): Promise<TransactionInstruction>;
+    getSetCustomFeesInstruction(zicOwner: PublicKey, tokenFeeList: ParsedTokenFeeRecord[]): Promise<TransactionInstruction>;
+    getDeleteCustomFeesInstruction(zicOwner: PublicKey, tokenList: PublicKey[]): Promise<TransactionInstruction>;
+    initCardConfig(params: InitCardConfigParams): Promise<TransactionPayload>;
+    setCardConfig(params: SetCardConfigParams): Promise<TransactionPayload>;
+    setCustomFees(params: SetCustomFeesParams): Promise<TransactionPayload>;
+    deleteCustomFees(params: DeleteCustomFeesParams): Promise<TransactionPayload>;
+    getCardConfigInfo(): Promise<CardConfigInfo>;
+    getCardPurchaseInfo(cardPurchasePda: Address): Promise<CardPurchaseInfo>;
+    getUserPurchaseRecord(userPurchaseRecordPda: Address): Promise<UserPurchaseRecordInfo>;
+    getCustomTokenFees(): Promise<TokenFeeRecord[]>;
+}
+export declare class ZebecSolanaPartnerAdminCardService {
+    readonly partnershipName: string;
+    readonly provider: Provider;
+    readonly network: "mainnet-beta" | "devnet";
+    readonly program: Program<ZebecCardV2Idl>;
+    constructor(partnershipName: string, provider: Provider, network: "mainnet-beta" | "devnet", program: Program<ZebecCardV2Idl>);
+    static create(partnershipName: string, provider: Provider, network: "mainnet-beta" | "devnet"): ZebecSolanaPartnerAdminCardService;
+    private _createPayload;
+    get connection(): Connection;
+    get programId(): PublicKey;
+    getInitPartnerCardConfigsInstruction(usdcToken: PublicKey, zicOwner: PublicKey, data: InitPartnerCardConfigInstructionData): Promise<TransactionInstruction>;
+    getSetPartnerCardConfigsInstruction(zicOwner: PublicKey, data: SetPartnerCardConfigInstructionData): Promise<TransactionInstruction>;
+    getSetPartnerCustomFeesInstruction(zicOwner: PublicKey, partnershipName: string, tokenFeeList: ParsedTokenFeeRecord[]): Promise<TransactionInstruction>;
+    getDeletePartnerCustomFeesInstruction(zicOwner: PublicKey, data: DeletePartnerCustomFeesInstructionData): Promise<TransactionInstruction>;
+    initPartnerCardConfig(params: InitPartnerCardConfigParams): Promise<TransactionPayload>;
+    setPartnerCardConfig(params: SetPartnerCardConfigParams): Promise<TransactionPayload>;
+    setPartnerCustomFees(params: SetPartnerCustomFeesParams): Promise<TransactionPayload>;
+    deletePartnerCustomFees(params: DeletePartnerCustomFeesParams): Promise<TransactionPayload>;
+    getPartnerCardConfigInfo(): Promise<PartnerCardConfigInfo>;
+    getPartnerCustomTokenFees(): Promise<TokenFeeRecord[]>;
+    getCardPurchaseInfo(cardPurchasePda: Address): Promise<CardPurchaseInfo>;
+    getPartnerUserPurchaseRecord(userPurchaseRecordPda: Address): Promise<UserPurchaseRecordInfo>;
+}