import { createPartyLayer } from '@partylayer/sdk';

const client = createPartyLayer({
  network: 'devnet',
  app: { name: 'My dApp' },
});

// List available wallets
const wallets = await client.listWallets();

// Connect to a wallet
const session = await client.connect({ walletId: 'console' });
console.log('Connected:', session.partyId);

// Sign a message
const signed = await client.signMessage({ message: 'Hello, Canton!' });

import { createPartyLayer } from '@partylayer/sdk';

// Initialize
const client = createPartyLayer({
  registryUrl: 'https://registry.partylayer.xyz',
  network: 'devnet',
  app: { name: 'My dApp' },
});

// Connect
const session = await client.connect({ walletId: 'console' });

// Sign message
const { signature } = await client.signMessage({
  message: 'Authorize login',
});

// Sign transaction
const { signedTx } = await client.signTransaction({
  tx: myTransaction,
});

// Submit transaction
const { txHash } = await client.submitTransaction({
  signedTx,
});

// Listen to events
client.on('session:connected', (event) => {
  console.log('Connected:', event.session);
});

client.on('session:disconnected', () => {
  console.log('Disconnected');
});

// Disconnect
await client.disconnect();

import { createPartyLayer, BronAdapter, getBuiltinAdapters } from '@partylayer/sdk';

const client = createPartyLayer({
  network: 'devnet',
  app: { name: 'My dApp' },
  adapters: [
    ...getBuiltinAdapters(), // Console, Loop, Cantor8, Nightly
    new BronAdapter({
      auth: {
        clientId: 'your-client-id',
        redirectUri: 'https://your-app.com/auth/callback',
        authorizationUrl: 'https://auth.bron.example/authorize',
        tokenUrl: 'https://auth.bron.example/token',
      },
      api: {
        baseUrl: 'https://api.bron.example',
        getAccessToken: async () => getStoredAccessToken(),
      },
    }),
  ],
});

import {
  WalletNotFoundError,
  WalletNotInstalledError,
  UserRejectedError,
  SessionExpiredError,
  TimeoutError,
} from '@partylayer/sdk';

try {
  await client.connect({ walletId: 'console' });
} catch (error) {
  if (error instanceof WalletNotFoundError) {
    console.error('Wallet not found in registry');
  } else if (error instanceof WalletNotInstalledError) {
    console.error('Please install the wallet extension');
  } else if (error instanceof UserRejectedError) {
    console.error('User rejected the connection');
  } else if (error instanceof SessionExpiredError) {
    console.error('Session expired, please reconnect');
  } else if (error instanceof TimeoutError) {
    console.error('Connection timed out');
  } else {
    console.error('Unexpected error:', error);
  }
}

const client = createPartyLayer(config: PartyLayerConfig);

import { PartyLayerProvider, discoverInjectedProviders } from '@partylayer/provider';

// Discover injected CIP-0103 wallets
const wallets = discoverInjectedProviders();

// Create a Provider backed by a native wallet
const provider = new PartyLayerProvider({ wallet: wallets[0].provider });

import { createPartyLayer } from '@partylayer/sdk';

const client = createPartyLayer({ network: 'devnet', app: { name: 'My dApp' } });
const provider = client.asProvider();

import { PartyLayerProvider } from '@partylayer/provider';

const provider = new PartyLayerProvider({ wallet: nativeWallet });

// Connect
const result = await provider.request({ method: 'connect' });
console.log(result.isConnected); // true

// Listen for status changes
provider.on('statusChanged', (status) => {
  console.log('Connection:', status.connection.isConnected);
  console.log('Network:', status.network?.networkId);
});

// Listen for transaction lifecycle
provider.on('txChanged', (event) => {
  switch (event.status) {
    case 'pending':  console.log('Tx pending:', event.commandId); break;
    case 'executed': console.log('Tx executed:', event.payload.updateId); break;
    case 'failed':   console.log('Tx failed:', event.commandId); break;
  }
});

// Sign a message
const signature = await provider.request({
  method: 'signMessage',
  params: { message: 'Hello, Canton!' },
});

// Prepare and execute a transaction
await provider.request({
  method: 'prepareExecute',
  params: { /* transaction payload */ },
});

import { ProviderRpcError, RPC_ERRORS } from '@partylayer/provider';

try {
  await provider.request({ method: 'signMessage', params: { message: 'test' } });
} catch (err) {
  if (err instanceof ProviderRpcError) {
    switch (err.code) {
      case RPC_ERRORS.USER_REJECTED:
        console.log('User declined');
        break;
      case RPC_ERRORS.DISCONNECTED:
        console.log('Not connected');
        break;
      default:
        console.log(`Error ${err.code}: ${err.message}`);
    }
  }
}

import { runCIP0103ConformanceTests, formatCIP0103Report } from '@partylayer/conformance-runner';

const report = await runCIP0103ConformanceTests(provider);
console.log(formatCIP0103Report(report));
// ═══ CIP-0103 Conformance Report ═══
// Total: 18  Passed: 18  Failed: 0