@1upmonster/duel 0.1.8 → 0.2.2

package/dist/generated/rps-game/instructions/makeChoice.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount } from '@solana/kit';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+import { type Choice, type ChoiceArgs } from '../types';
+export declare const MAKE_CHOICE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getMakeChoiceDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type MakeChoiceInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer1Profile extends string | AccountMeta<string> = string, TAccountPlayer2Profile extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer1Profile extends string ? WritableAccount<TAccountPlayer1Profile> : TAccountPlayer1Profile, TAccountPlayer2Profile extends string ? WritableAccount<TAccountPlayer2Profile> : TAccountPlayer2Profile, TAccountPlayer extends string ? ReadonlySignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;
+export type MakeChoiceInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    choice: Choice;
+};
+export type MakeChoiceInstructionDataArgs = {
+    choice: ChoiceArgs;
+};
+export declare function getMakeChoiceInstructionDataEncoder(): FixedSizeEncoder<MakeChoiceInstructionDataArgs>;
+export declare function getMakeChoiceInstructionDataDecoder(): FixedSizeDecoder<MakeChoiceInstructionData>;
+export declare function getMakeChoiceInstructionDataCodec(): FixedSizeCodec<MakeChoiceInstructionDataArgs, MakeChoiceInstructionData>;
+export type MakeChoiceInput<TAccountGameSession extends string = string, TAccountPlayer1Profile extends string = string, TAccountPlayer2Profile extends string = string, TAccountPlayer extends string = string> = {
+    gameSession: Address<TAccountGameSession>;
+    player1Profile: Address<TAccountPlayer1Profile>;
+    player2Profile: Address<TAccountPlayer2Profile>;
+    player: TransactionSigner<TAccountPlayer>;
+    choice: MakeChoiceInstructionDataArgs["choice"];
+};
+export declare function getMakeChoiceInstruction<TAccountGameSession extends string, TAccountPlayer1Profile extends string, TAccountPlayer2Profile extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: MakeChoiceInput<TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPlayer>, config?: {
+    programAddress?: TProgramAddress;
+}): MakeChoiceInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPlayer>;
+export type ParsedMakeChoiceInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        gameSession: TAccountMetas[0];
+        player1Profile: TAccountMetas[1];
+        player2Profile: TAccountMetas[2];
+        player: TAccountMetas[3];
+    };
+    data: MakeChoiceInstructionData;
+};
+export declare function parseMakeChoiceInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedMakeChoiceInstruction<TProgram, TAccountMetas>;

package/dist/generated/rps-game/instructions/makeChoice.js

@@ -0,0 +1,46 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory } from '@solana/program-client-core';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+import { getChoiceDecoder, getChoiceEncoder } from '../types';
+export const MAKE_CHOICE_DISCRIMINATOR = new Uint8Array([207, 18, 251, 32, 135, 122, 160, 77]);
+export function getMakeChoiceDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(MAKE_CHOICE_DISCRIMINATOR); }
+export function getMakeChoiceInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['choice', getChoiceEncoder()]]), (value) => ({ ...value, discriminator: MAKE_CHOICE_DISCRIMINATOR }));
+}
+export function getMakeChoiceInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['choice', getChoiceDecoder()]]);
+}
+export function getMakeChoiceInstructionDataCodec() {
+    return combineCodec(getMakeChoiceInstructionDataEncoder(), getMakeChoiceInstructionDataDecoder());
+}
+export function getMakeChoiceInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player1Profile: { value: input.player1Profile ?? null, isWritable: true }, player2Profile: { value: input.player2Profile ?? null, isWritable: true }, player: { value: input.player ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Original args.
+    const args = { ...input, };
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("gameSession", accounts.gameSession), getAccountMeta("player1Profile", accounts.player1Profile), getAccountMeta("player2Profile", accounts.player2Profile), getAccountMeta("player", accounts.player)], data: getMakeChoiceInstructionDataEncoder().encode(args), programAddress });
+}
+export function parseMakeChoiceInstruction(instruction) {
+    if (instruction.accounts.length < 4) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { gameSession: getNextAccount(), player1Profile: getNextAccount(), player2Profile: getNextAccount(), player: getNextAccount() }, data: getMakeChoiceInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"makeChoice.js","sourceRoot":"","sources":["../../../../src/generated/rps-game/instructions/makeChoice.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount } from '@solana/kit';\nimport { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { RPS_GAME_PROGRAM_ADDRESS } from '../programs';\nimport { getChoiceDecoder, getChoiceEncoder, type Choice, type ChoiceArgs } from '../types';\n\nexport const MAKE_CHOICE_DISCRIMINATOR = new Uint8Array([207, 18, 251, 32, 135, 122, 160, 77]);\n\nexport function getMakeChoiceDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(MAKE_CHOICE_DISCRIMINATOR); }\n\nexport type MakeChoiceInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer1Profile extends string | AccountMeta<string> = string, TAccountPlayer2Profile extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer1Profile extends string ? WritableAccount<TAccountPlayer1Profile> : TAccountPlayer1Profile, TAccountPlayer2Profile extends string ? WritableAccount<TAccountPlayer2Profile> : TAccountPlayer2Profile, TAccountPlayer extends string ? ReadonlySignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;\n\nexport type MakeChoiceInstructionData = { discriminator: ReadonlyUint8Array; choice: Choice;  };\n\nexport type MakeChoiceInstructionDataArgs = { choice: ChoiceArgs;  };\n\nexport function getMakeChoiceInstructionDataEncoder(): FixedSizeEncoder<MakeChoiceInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['choice', getChoiceEncoder()]]), (value) => ({ ...value, discriminator: MAKE_CHOICE_DISCRIMINATOR }));\n}\n\nexport function getMakeChoiceInstructionDataDecoder(): FixedSizeDecoder<MakeChoiceInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['choice', getChoiceDecoder()]]);\n}\n\nexport function getMakeChoiceInstructionDataCodec(): FixedSizeCodec<MakeChoiceInstructionDataArgs, MakeChoiceInstructionData> {\n    return combineCodec(getMakeChoiceInstructionDataEncoder(), getMakeChoiceInstructionDataDecoder());\n}\n\nexport type MakeChoiceInput<TAccountGameSession extends string = string, TAccountPlayer1Profile extends string = string, TAccountPlayer2Profile extends string = string, TAccountPlayer extends string = string> =  {\n  gameSession: Address<TAccountGameSession>;\nplayer1Profile: Address<TAccountPlayer1Profile>;\nplayer2Profile: Address<TAccountPlayer2Profile>;\nplayer: TransactionSigner<TAccountPlayer>;\nchoice: MakeChoiceInstructionDataArgs[\"choice\"];\n}\n\nexport function getMakeChoiceInstruction<TAccountGameSession extends string, TAccountPlayer1Profile extends string, TAccountPlayer2Profile extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: MakeChoiceInput<TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): MakeChoiceInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPlayer> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player1Profile: { value: input.player1Profile ?? null, isWritable: true }, player2Profile: { value: input.player2Profile ?? null, isWritable: true }, player: { value: input.player ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Original args.\nconst args = { ...input,  };\n\n\n\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"gameSession\", accounts.gameSession), getAccountMeta(\"player1Profile\", accounts.player1Profile), getAccountMeta(\"player2Profile\", accounts.player2Profile), getAccountMeta(\"player\", accounts.player)], data: getMakeChoiceInstructionDataEncoder().encode(args as MakeChoiceInstructionDataArgs), programAddress } as MakeChoiceInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPlayer>);\n}\n\nexport type ParsedMakeChoiceInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\ngameSession: TAccountMetas[0];\nplayer1Profile: TAccountMetas[1];\nplayer2Profile: TAccountMetas[2];\nplayer: TAccountMetas[3];\n};\ndata: MakeChoiceInstructionData; };\n\nexport function parseMakeChoiceInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedMakeChoiceInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 4) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { gameSession: getNextAccount(), player1Profile: getNextAccount(), player2Profile: getNextAccount(), player: getNextAccount() }, data: getMakeChoiceInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/rps-game/instructions/onMatchFound.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner } from '@solana/kit';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export declare const ON_MATCH_FOUND_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getOnMatchFoundDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type OnMatchFoundInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner, ...TRemainingAccounts]>;
+export type OnMatchFoundInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    player1: Address;
+    player2: Address;
+    matchId: bigint;
+};
+export type OnMatchFoundInstructionDataArgs = {
+    player1: Address;
+    player2: Address;
+    matchId: number | bigint;
+};
+export declare function getOnMatchFoundInstructionDataEncoder(): FixedSizeEncoder<OnMatchFoundInstructionDataArgs>;
+export declare function getOnMatchFoundInstructionDataDecoder(): FixedSizeDecoder<OnMatchFoundInstructionData>;
+export declare function getOnMatchFoundInstructionDataCodec(): FixedSizeCodec<OnMatchFoundInstructionDataArgs, OnMatchFoundInstructionData>;
+export type OnMatchFoundInput<TAccountSigner extends string = string> = {
+    signer: TransactionSigner<TAccountSigner>;
+    player1: OnMatchFoundInstructionDataArgs["player1"];
+    player2: OnMatchFoundInstructionDataArgs["player2"];
+    matchId: OnMatchFoundInstructionDataArgs["matchId"];
+};
+export declare function getOnMatchFoundInstruction<TAccountSigner extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: OnMatchFoundInput<TAccountSigner>, config?: {
+    programAddress?: TProgramAddress;
+}): OnMatchFoundInstruction<TProgramAddress, TAccountSigner>;
+export type ParsedOnMatchFoundInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        signer: TAccountMetas[0];
+    };
+    data: OnMatchFoundInstructionData;
+};
+export declare function parseOnMatchFoundInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedOnMatchFoundInstruction<TProgram, TAccountMetas>;

package/dist/generated/rps-game/instructions/onMatchFound.js

@@ -0,0 +1,45 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory } from '@solana/program-client-core';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export const ON_MATCH_FOUND_DISCRIMINATOR = new Uint8Array([66, 209, 170, 159, 10, 195, 34, 214]);
+export function getOnMatchFoundDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(ON_MATCH_FOUND_DISCRIMINATOR); }
+export function getOnMatchFoundInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['player1', getAddressEncoder()], ['player2', getAddressEncoder()], ['matchId', getU64Encoder()]]), (value) => ({ ...value, discriminator: ON_MATCH_FOUND_DISCRIMINATOR }));
+}
+export function getOnMatchFoundInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['player1', getAddressDecoder()], ['player2', getAddressDecoder()], ['matchId', getU64Decoder()]]);
+}
+export function getOnMatchFoundInstructionDataCodec() {
+    return combineCodec(getOnMatchFoundInstructionDataEncoder(), getOnMatchFoundInstructionDataDecoder());
+}
+export function getOnMatchFoundInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { signer: { value: input.signer ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Original args.
+    const args = { ...input, };
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("signer", accounts.signer)], data: getOnMatchFoundInstructionDataEncoder().encode(args), programAddress });
+}
+export function parseOnMatchFoundInstruction(instruction) {
+    if (instruction.accounts.length < 1) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 1 });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { signer: getNextAccount() }, data: getOnMatchFoundInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"onMatchFound.js","sourceRoot":"","sources":["../../../../src/generated/rps-game/instructions/onMatchFound.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { combineCodec, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner } from '@solana/kit';\nimport { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { RPS_GAME_PROGRAM_ADDRESS } from '../programs';\n\nexport const ON_MATCH_FOUND_DISCRIMINATOR = new Uint8Array([66, 209, 170, 159, 10, 195, 34, 214]);\n\nexport function getOnMatchFoundDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(ON_MATCH_FOUND_DISCRIMINATOR); }\n\nexport type OnMatchFoundInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner, ...TRemainingAccounts]>;\n\nexport type OnMatchFoundInstructionData = { discriminator: ReadonlyUint8Array; player1: Address; player2: Address; matchId: bigint;  };\n\nexport type OnMatchFoundInstructionDataArgs = { player1: Address; player2: Address; matchId: number | bigint;  };\n\nexport function getOnMatchFoundInstructionDataEncoder(): FixedSizeEncoder<OnMatchFoundInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['player1', getAddressEncoder()], ['player2', getAddressEncoder()], ['matchId', getU64Encoder()]]), (value) => ({ ...value, discriminator: ON_MATCH_FOUND_DISCRIMINATOR }));\n}\n\nexport function getOnMatchFoundInstructionDataDecoder(): FixedSizeDecoder<OnMatchFoundInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['player1', getAddressDecoder()], ['player2', getAddressDecoder()], ['matchId', getU64Decoder()]]);\n}\n\nexport function getOnMatchFoundInstructionDataCodec(): FixedSizeCodec<OnMatchFoundInstructionDataArgs, OnMatchFoundInstructionData> {\n    return combineCodec(getOnMatchFoundInstructionDataEncoder(), getOnMatchFoundInstructionDataDecoder());\n}\n\nexport type OnMatchFoundInput<TAccountSigner extends string = string> =  {\n  signer: TransactionSigner<TAccountSigner>;\nplayer1: OnMatchFoundInstructionDataArgs[\"player1\"];\nplayer2: OnMatchFoundInstructionDataArgs[\"player2\"];\nmatchId: OnMatchFoundInstructionDataArgs[\"matchId\"];\n}\n\nexport function getOnMatchFoundInstruction<TAccountSigner extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: OnMatchFoundInput<TAccountSigner>, config?: { programAddress?: TProgramAddress } ): OnMatchFoundInstruction<TProgramAddress, TAccountSigner> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { signer: { value: input.signer ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Original args.\nconst args = { ...input,  };\n\n\n\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"signer\", accounts.signer)], data: getOnMatchFoundInstructionDataEncoder().encode(args as OnMatchFoundInstructionDataArgs), programAddress } as OnMatchFoundInstruction<TProgramAddress, TAccountSigner>);\n}\n\nexport type ParsedOnMatchFoundInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nsigner: TAccountMetas[0];\n};\ndata: OnMatchFoundInstructionData; };\n\nexport function parseOnMatchFoundInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedOnMatchFoundInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 1) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 1 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { signer: getNextAccount() }, data: getOnMatchFoundInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/rps-game/instructions/persistResults.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export declare const PERSIST_RESULTS_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getPersistResultsDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type PersistResultsInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer1Profile extends string | AccountMeta<string> = string, TAccountPlayer2Profile extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountMagicProgram extends string | AccountMeta<string> = "Magic11111111111111111111111111111111111111", TAccountMagicContext extends string | AccountMeta<string> = "MagicContext1111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer1Profile extends string ? WritableAccount<TAccountPlayer1Profile> : TAccountPlayer1Profile, TAccountPlayer2Profile extends string ? WritableAccount<TAccountPlayer2Profile> : TAccountPlayer2Profile, TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountMagicProgram extends string ? ReadonlyAccount<TAccountMagicProgram> : TAccountMagicProgram, TAccountMagicContext extends string ? WritableAccount<TAccountMagicContext> : TAccountMagicContext, ...TRemainingAccounts]>;
+export type PersistResultsInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type PersistResultsInstructionDataArgs = {};
+export declare function getPersistResultsInstructionDataEncoder(): FixedSizeEncoder<PersistResultsInstructionDataArgs>;
+export declare function getPersistResultsInstructionDataDecoder(): FixedSizeDecoder<PersistResultsInstructionData>;
+export declare function getPersistResultsInstructionDataCodec(): FixedSizeCodec<PersistResultsInstructionDataArgs, PersistResultsInstructionData>;
+export type PersistResultsInput<TAccountGameSession extends string = string, TAccountPlayer1Profile extends string = string, TAccountPlayer2Profile extends string = string, TAccountPayer extends string = string, TAccountMagicProgram extends string = string, TAccountMagicContext extends string = string> = {
+    gameSession: Address<TAccountGameSession>;
+    player1Profile: Address<TAccountPlayer1Profile>;
+    player2Profile: Address<TAccountPlayer2Profile>;
+    payer: TransactionSigner<TAccountPayer>;
+    magicProgram?: Address<TAccountMagicProgram>;
+    magicContext?: Address<TAccountMagicContext>;
+};
+export declare function getPersistResultsInstruction<TAccountGameSession extends string, TAccountPlayer1Profile extends string, TAccountPlayer2Profile extends string, TAccountPayer extends string, TAccountMagicProgram extends string, TAccountMagicContext extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: PersistResultsInput<TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>, config?: {
+    programAddress?: TProgramAddress;
+}): PersistResultsInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>;
+export type ParsedPersistResultsInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        gameSession: TAccountMetas[0];
+        player1Profile: TAccountMetas[1];
+        player2Profile: TAccountMetas[2];
+        payer: TAccountMetas[3];
+        magicProgram: TAccountMetas[4];
+        magicContext: TAccountMetas[5];
+    };
+    data: PersistResultsInstructionData;
+};
+export declare function parsePersistResultsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPersistResultsInstruction<TProgram, TAccountMetas>;

package/dist/generated/rps-game/instructions/persistResults.js

@@ -0,0 +1,50 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory } from '@solana/program-client-core';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export const PERSIST_RESULTS_DISCRIMINATOR = new Uint8Array([9, 175, 42, 217, 2, 48, 80, 81]);
+export function getPersistResultsDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PERSIST_RESULTS_DISCRIMINATOR); }
+export function getPersistResultsInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: PERSIST_RESULTS_DISCRIMINATOR }));
+}
+export function getPersistResultsInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getPersistResultsInstructionDataCodec() {
+    return combineCodec(getPersistResultsInstructionDataEncoder(), getPersistResultsInstructionDataDecoder());
+}
+export function getPersistResultsInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player1Profile: { value: input.player1Profile ?? null, isWritable: true }, player2Profile: { value: input.player2Profile ?? null, isWritable: true }, payer: { value: input.payer ?? null, isWritable: true }, magicProgram: { value: input.magicProgram ?? null, isWritable: false }, magicContext: { value: input.magicContext ?? null, isWritable: true } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.magicProgram.value) {
+        accounts.magicProgram.value = 'Magic11111111111111111111111111111111111111';
+    }
+    if (!accounts.magicContext.value) {
+        accounts.magicContext.value = 'MagicContext1111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("gameSession", accounts.gameSession), getAccountMeta("player1Profile", accounts.player1Profile), getAccountMeta("player2Profile", accounts.player2Profile), getAccountMeta("payer", accounts.payer), getAccountMeta("magicProgram", accounts.magicProgram), getAccountMeta("magicContext", accounts.magicContext)], data: getPersistResultsInstructionDataEncoder().encode({}), programAddress });
+}
+export function parsePersistResultsInstruction(instruction) {
+    if (instruction.accounts.length < 6) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 6 });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { gameSession: getNextAccount(), player1Profile: getNextAccount(), player2Profile: getNextAccount(), payer: getNextAccount(), magicProgram: getNextAccount(), magicContext: getNextAccount() }, data: getPersistResultsInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"persistResults.js","sourceRoot":"","sources":["../../../../src/generated/rps-game/instructions/persistResults.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';\nimport { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { RPS_GAME_PROGRAM_ADDRESS } from '../programs';\n\nexport const PERSIST_RESULTS_DISCRIMINATOR = new Uint8Array([9, 175, 42, 217, 2, 48, 80, 81]);\n\nexport function getPersistResultsDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PERSIST_RESULTS_DISCRIMINATOR); }\n\nexport type PersistResultsInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer1Profile extends string | AccountMeta<string> = string, TAccountPlayer2Profile extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountMagicProgram extends string | AccountMeta<string> = \"Magic11111111111111111111111111111111111111\", TAccountMagicContext extends string | AccountMeta<string> = \"MagicContext1111111111111111111111111111111\", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer1Profile extends string ? WritableAccount<TAccountPlayer1Profile> : TAccountPlayer1Profile, TAccountPlayer2Profile extends string ? WritableAccount<TAccountPlayer2Profile> : TAccountPlayer2Profile, TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountMagicProgram extends string ? ReadonlyAccount<TAccountMagicProgram> : TAccountMagicProgram, TAccountMagicContext extends string ? WritableAccount<TAccountMagicContext> : TAccountMagicContext, ...TRemainingAccounts]>;\n\nexport type PersistResultsInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type PersistResultsInstructionDataArgs = {  };\n\nexport function getPersistResultsInstructionDataEncoder(): FixedSizeEncoder<PersistResultsInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: PERSIST_RESULTS_DISCRIMINATOR }));\n}\n\nexport function getPersistResultsInstructionDataDecoder(): FixedSizeDecoder<PersistResultsInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getPersistResultsInstructionDataCodec(): FixedSizeCodec<PersistResultsInstructionDataArgs, PersistResultsInstructionData> {\n    return combineCodec(getPersistResultsInstructionDataEncoder(), getPersistResultsInstructionDataDecoder());\n}\n\nexport type PersistResultsInput<TAccountGameSession extends string = string, TAccountPlayer1Profile extends string = string, TAccountPlayer2Profile extends string = string, TAccountPayer extends string = string, TAccountMagicProgram extends string = string, TAccountMagicContext extends string = string> =  {\n  gameSession: Address<TAccountGameSession>;\nplayer1Profile: Address<TAccountPlayer1Profile>;\nplayer2Profile: Address<TAccountPlayer2Profile>;\npayer: TransactionSigner<TAccountPayer>;\nmagicProgram?: Address<TAccountMagicProgram>;\nmagicContext?: Address<TAccountMagicContext>;\n}\n\nexport function getPersistResultsInstruction<TAccountGameSession extends string, TAccountPlayer1Profile extends string, TAccountPlayer2Profile extends string, TAccountPayer extends string, TAccountMagicProgram extends string, TAccountMagicContext extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: PersistResultsInput<TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>, config?: { programAddress?: TProgramAddress } ): PersistResultsInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player1Profile: { value: input.player1Profile ?? null, isWritable: true }, player2Profile: { value: input.player2Profile ?? null, isWritable: true }, payer: { value: input.payer ?? null, isWritable: true }, magicProgram: { value: input.magicProgram ?? null, isWritable: false }, magicContext: { value: input.magicContext ?? null, isWritable: true } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.magicProgram.value) {\naccounts.magicProgram.value = 'Magic11111111111111111111111111111111111111' as Address<'Magic11111111111111111111111111111111111111'>;\n}\nif (!accounts.magicContext.value) {\naccounts.magicContext.value = 'MagicContext1111111111111111111111111111111' as Address<'MagicContext1111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"gameSession\", accounts.gameSession), getAccountMeta(\"player1Profile\", accounts.player1Profile), getAccountMeta(\"player2Profile\", accounts.player2Profile), getAccountMeta(\"payer\", accounts.payer), getAccountMeta(\"magicProgram\", accounts.magicProgram), getAccountMeta(\"magicContext\", accounts.magicContext)], data: getPersistResultsInstructionDataEncoder().encode({}), programAddress } as PersistResultsInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>);\n}\n\nexport type ParsedPersistResultsInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\ngameSession: TAccountMetas[0];\nplayer1Profile: TAccountMetas[1];\nplayer2Profile: TAccountMetas[2];\npayer: TAccountMetas[3];\nmagicProgram: TAccountMetas[4];\nmagicContext: TAccountMetas[5];\n};\ndata: PersistResultsInstructionData; };\n\nexport function parsePersistResultsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPersistResultsInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 6) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 6 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { gameSession: getNextAccount(), player1Profile: getNextAccount(), player2Profile: getNextAccount(), payer: getNextAccount(), magicProgram: getNextAccount(), magicContext: getNextAccount() }, data: getPersistResultsInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/rps-game/instructions/processUndelegation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type Address, type Codec, type Decoder, type Encoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type WritableAccount } from '@solana/kit';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export declare const PROCESS_UNDELEGATION_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getProcessUndelegationDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type ProcessUndelegationInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountBaseAccount extends string | AccountMeta<string> = string, TAccountBuffer extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountBaseAccount extends string ? WritableAccount<TAccountBaseAccount> : TAccountBaseAccount, TAccountBuffer extends string ? ReadonlyAccount<TAccountBuffer> : TAccountBuffer, TAccountPayer extends string ? WritableAccount<TAccountPayer> : TAccountPayer, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+export type ProcessUndelegationInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    accountSeeds: Array<ReadonlyUint8Array>;
+};
+export type ProcessUndelegationInstructionDataArgs = {
+    accountSeeds: Array<ReadonlyUint8Array>;
+};
+export declare function getProcessUndelegationInstructionDataEncoder(): Encoder<ProcessUndelegationInstructionDataArgs>;
+export declare function getProcessUndelegationInstructionDataDecoder(): Decoder<ProcessUndelegationInstructionData>;
+export declare function getProcessUndelegationInstructionDataCodec(): Codec<ProcessUndelegationInstructionDataArgs, ProcessUndelegationInstructionData>;
+export type ProcessUndelegationInput<TAccountBaseAccount extends string = string, TAccountBuffer extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> = {
+    baseAccount: Address<TAccountBaseAccount>;
+    buffer: Address<TAccountBuffer>;
+    payer: Address<TAccountPayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    accountSeeds: ProcessUndelegationInstructionDataArgs["accountSeeds"];
+};
+export declare function getProcessUndelegationInstruction<TAccountBaseAccount extends string, TAccountBuffer extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: ProcessUndelegationInput<TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): ProcessUndelegationInstruction<TProgramAddress, TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram>;
+export type ParsedProcessUndelegationInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        baseAccount: TAccountMetas[0];
+        buffer: TAccountMetas[1];
+        payer: TAccountMetas[2];
+        systemProgram: TAccountMetas[3];
+    };
+    data: ProcessUndelegationInstructionData;
+};
+export declare function parseProcessUndelegationInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProcessUndelegationInstruction<TProgram, TAccountMetas>;

package/dist/generated/rps-game/instructions/processUndelegation.js

@@ -0,0 +1,49 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { addDecoderSizePrefix, addEncoderSizePrefix, combineCodec, fixDecoderSize, fixEncoderSize, getArrayDecoder, getArrayEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory } from '@solana/program-client-core';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export const PROCESS_UNDELEGATION_DISCRIMINATOR = new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167]);
+export function getProcessUndelegationDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PROCESS_UNDELEGATION_DISCRIMINATOR); }
+export function getProcessUndelegationInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['accountSeeds', getArrayEncoder(addEncoderSizePrefix(getBytesEncoder(), getU32Encoder()))]]), (value) => ({ ...value, discriminator: PROCESS_UNDELEGATION_DISCRIMINATOR }));
+}
+export function getProcessUndelegationInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['accountSeeds', getArrayDecoder(addDecoderSizePrefix(getBytesDecoder(), getU32Decoder()))]]);
+}
+export function getProcessUndelegationInstructionDataCodec() {
+    return combineCodec(getProcessUndelegationInstructionDataEncoder(), getProcessUndelegationInstructionDataDecoder());
+}
+export function getProcessUndelegationInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { baseAccount: { value: input.baseAccount ?? null, isWritable: true }, buffer: { value: input.buffer ?? null, isWritable: false }, payer: { value: input.payer ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Original args.
+    const args = { ...input, };
+    // Resolve default values.
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("baseAccount", accounts.baseAccount), getAccountMeta("buffer", accounts.buffer), getAccountMeta("payer", accounts.payer), getAccountMeta("systemProgram", accounts.systemProgram)], data: getProcessUndelegationInstructionDataEncoder().encode(args), programAddress });
+}
+export function parseProcessUndelegationInstruction(instruction) {
+    if (instruction.accounts.length < 4) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { baseAccount: getNextAccount(), buffer: getNextAccount(), payer: getNextAccount(), systemProgram: getNextAccount() }, data: getProcessUndelegationInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processUndelegation.js","sourceRoot":"","sources":["../../../../src/generated/rps-game/instructions/processUndelegation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { addDecoderSizePrefix, addEncoderSizePrefix, combineCodec, fixDecoderSize, fixEncoderSize, getArrayDecoder, getArrayEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type Address, type Codec, type Decoder, type Encoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type WritableAccount } from '@solana/kit';\nimport { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { RPS_GAME_PROGRAM_ADDRESS } from '../programs';\n\nexport const PROCESS_UNDELEGATION_DISCRIMINATOR = new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167]);\n\nexport function getProcessUndelegationDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PROCESS_UNDELEGATION_DISCRIMINATOR); }\n\nexport type ProcessUndelegationInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountBaseAccount extends string | AccountMeta<string> = string, TAccountBuffer extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = \"11111111111111111111111111111111\", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountBaseAccount extends string ? WritableAccount<TAccountBaseAccount> : TAccountBaseAccount, TAccountBuffer extends string ? ReadonlyAccount<TAccountBuffer> : TAccountBuffer, TAccountPayer extends string ? WritableAccount<TAccountPayer> : TAccountPayer, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;\n\nexport type ProcessUndelegationInstructionData = { discriminator: ReadonlyUint8Array; accountSeeds: Array<ReadonlyUint8Array>;  };\n\nexport type ProcessUndelegationInstructionDataArgs = { accountSeeds: Array<ReadonlyUint8Array>;  };\n\nexport function getProcessUndelegationInstructionDataEncoder(): Encoder<ProcessUndelegationInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['accountSeeds', getArrayEncoder(addEncoderSizePrefix(getBytesEncoder(), getU32Encoder()))]]), (value) => ({ ...value, discriminator: PROCESS_UNDELEGATION_DISCRIMINATOR }));\n}\n\nexport function getProcessUndelegationInstructionDataDecoder(): Decoder<ProcessUndelegationInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['accountSeeds', getArrayDecoder(addDecoderSizePrefix(getBytesDecoder(), getU32Decoder()))]]);\n}\n\nexport function getProcessUndelegationInstructionDataCodec(): Codec<ProcessUndelegationInstructionDataArgs, ProcessUndelegationInstructionData> {\n    return combineCodec(getProcessUndelegationInstructionDataEncoder(), getProcessUndelegationInstructionDataDecoder());\n}\n\nexport type ProcessUndelegationInput<TAccountBaseAccount extends string = string, TAccountBuffer extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> =  {\n  baseAccount: Address<TAccountBaseAccount>;\nbuffer: Address<TAccountBuffer>;\npayer: Address<TAccountPayer>;\nsystemProgram?: Address<TAccountSystemProgram>;\naccountSeeds: ProcessUndelegationInstructionDataArgs[\"accountSeeds\"];\n}\n\nexport function getProcessUndelegationInstruction<TAccountBaseAccount extends string, TAccountBuffer extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: ProcessUndelegationInput<TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): ProcessUndelegationInstruction<TProgramAddress, TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { baseAccount: { value: input.baseAccount ?? null, isWritable: true }, buffer: { value: input.buffer ?? null, isWritable: false }, payer: { value: input.payer ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Original args.\nconst args = { ...input,  };\n\n\n// Resolve default values.\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"baseAccount\", accounts.baseAccount), getAccountMeta(\"buffer\", accounts.buffer), getAccountMeta(\"payer\", accounts.payer), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getProcessUndelegationInstructionDataEncoder().encode(args as ProcessUndelegationInstructionDataArgs), programAddress } as ProcessUndelegationInstruction<TProgramAddress, TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram>);\n}\n\nexport type ParsedProcessUndelegationInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nbaseAccount: TAccountMetas[0];\nbuffer: TAccountMetas[1];\npayer: TAccountMetas[2];\nsystemProgram: TAccountMetas[3];\n};\ndata: ProcessUndelegationInstructionData; };\n\nexport function parseProcessUndelegationInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProcessUndelegationInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 4) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { baseAccount: getNextAccount(), buffer: getNextAccount(), payer: getNextAccount(), systemProgram: getNextAccount() }, data: getProcessUndelegationInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/rps-game/instructions/startGame.d.ts

@@ -0,0 +1,54 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export declare const START_GAME_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getStartGameDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type StartGameInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+export type StartGameInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    gameId: bigint;
+    opponent: Address;
+};
+export type StartGameInstructionDataArgs = {
+    gameId: number | bigint;
+    opponent: Address;
+};
+export declare function getStartGameInstructionDataEncoder(): FixedSizeEncoder<StartGameInstructionDataArgs>;
+export declare function getStartGameInstructionDataDecoder(): FixedSizeDecoder<StartGameInstructionData>;
+export declare function getStartGameInstructionDataCodec(): FixedSizeCodec<StartGameInstructionDataArgs, StartGameInstructionData>;
+export type StartGameAsyncInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> = {
+    gameSession?: Address<TAccountGameSession>;
+    player: TransactionSigner<TAccountPlayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    gameId: StartGameInstructionDataArgs["gameId"];
+    opponent: StartGameInstructionDataArgs["opponent"];
+};
+export declare function getStartGameInstructionAsync<TAccountGameSession extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameAsyncInput<TAccountGameSession, TAccountPlayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram>>;
+export type StartGameInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> = {
+    gameSession: Address<TAccountGameSession>;
+    player: TransactionSigner<TAccountPlayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    gameId: StartGameInstructionDataArgs["gameId"];
+    opponent: StartGameInstructionDataArgs["opponent"];
+};
+export declare function getStartGameInstruction<TAccountGameSession extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameInput<TAccountGameSession, TAccountPlayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram>;
+export type ParsedStartGameInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        gameSession: TAccountMetas[0];
+        player: TAccountMetas[1];
+        systemProgram: TAccountMetas[2];
+    };
+    data: StartGameInstructionData;
+};
+export declare function parseStartGameInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedStartGameInstruction<TProgram, TAccountMetas>;